inquanto.ansatzes¶
Basic ansatzes¶
- class GeneralAnsatz(reference, *args, **kwargs)¶
Bases:
Symbolic
,Representable
Base class for a quantum state that can be represented with a single circuit.
- Parameters:
reference (
Union
[int
,List
[Qubit
],List
[int
],QubitSpace
,QubitState
,Circuit
]) – A reference state circuit or any valid initializer forreference_circuit_builder()
.args (
Any
) –kwargs (
Any
) –
- circuit_resources(return_circuit=False)¶
Returns crude resource estimates for the implementation of unoptimized ansatz preparation circuit (e.g. gatecount).
This proceeds via decomposition of boxes in the state preparation circuit, followed by rebasing to the native TKET gateset (CX, TK1, Phase). Analysis of the circuit is performed on a copy – the original circuit stored in this object is left unmodified.
- Parameters:
return_circuit (
bool
, default:False
) – If set to True, the rebased circuit will be included as an additional element of the dictionary under the key “circuit”.- Returns:
dict
[str
,int
|Circuit
] – A dictionary of resource estimates of the ansatz circuit keyed by resource label (e.g. “depth”), optionally including the rebased circuit.
- default_pass()¶
Get the default compiler pass for the ansatz type.
- Returns:
BasePass
– A tket pass object.
- df_numeric(symbol_map=None, *, space=None, backend=None, dtype=complex, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_numeric_representation()
to generate a numeric vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_numeric_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_numeric_representation()
.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation. Passed toget_numeric_representation()
.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted. Passed toget_numeric_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- df_symbolic(symbol_map=None, *, space=None, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_symbolic_representation()
to generate a symbolic vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Symbolic coefficients are simplified before being added to dataframe.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_symbolic_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_symbolic_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- abstract free_symbols()¶
Returns the free symbols in the object.
- Returns:
Set
[Symbol
] – Unordered set of symbols.
- free_symbols_ordered()¶
Returns the free symbols in increasing lexicographic order.
- Returns:
SymbolEnsemble
– Ordered free symbols in object.
- abstract get_circuit(symbol_map=None)¶
Constructs a single state circuit.
- get_circuit_no_ref(symbol_map=None)¶
Constructs a single state circuit without the reference state.
- Parameters:
- Returns:
Circuit
– A circuit that represent the referenceless state.
- get_numeric_representation(symbol_map=None, *, space=None, backend=None, dtype=complex)¶
Constructs a single numeric matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation.space (
Any
, default:None
) – Basis information to represent the object.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted.
- Returns:
Union
[_SupportsArray
[dtype
[Any
]],_NestedSequence
[_SupportsArray
[dtype
[Any
]]],bool
,int
,float
,complex
,str
,bytes
,_NestedSequence
[bool
|int
|float
|complex
|str
|bytes
]] – A matrix/vector representing the object.
- get_symbolic_representation(symbol_map=None, *, space=None)¶
Constructs a single symbolic matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
- Returns:
Expr
– A symbolic expression as a representation, which is a symbolic NDArray.
- make_hashable()¶
Returns a hashable representation of the ansatz object.
- Returns:
Hashable
– Hashable representation of ansatz.
- reference_qubit_state()¶
Create a symbolic
QubitState
representation of the reference state.- Returns:
QubitState
– Reference state as aQubitState
.
- reset_reference(reference)¶
Resetting the reference state of the ansatz in place.
Note
The number of qubits in the new reference has to match with the already existing reference state.
- Parameters:
reference (
Union
[int
,List
[Qubit
],List
[int
],QubitSpace
,QubitState
,Circuit
]) – Any reference that can be converted into a non-symbolic reference state circuit.- Returns:
Returns self with the modified reference.
- property state_circuit: Circuit¶
Returns the symbolic state circuit with a default compilation.
- property state_symbols: SymbolEnsemble¶
Returns the ordered parameter symbols this state uses.
- subs(symbol_map)¶
Returns a new objects with symbols substituted.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
]) – A mapping for substitution of free symbols.- Returns:
TypeVar
(SYMBOLICTYPE
, bound= Symbolic) – A copy of self with symbols substituted according to the provided map.
- abstract symbol_substitution(symbol_map=None)¶
Performs an in-place symbol substation in the object.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – Dictionary or Callable mapping existing symbols to new symbols or values.
Note
While this is an in-place operation, consistency in free_symbols_ordered() is not guaranteed.
- Returns:
TypeVar
(SYMBOLICTYPE
, bound= Symbolic) –self
, with symbols substituted.
- to_CircuitAnsatz(symbol_map=None)¶
Cast the ansatz as CircuitAnsatz with optional symbol substitution.
- to_QubitState()¶
Create a symbolic
QubitState
representation of the ansatz.- Returns:
QubitState
– Ansatz as aQubitState
.
- abstract unsympify(precision=15)¶
Unsympifies dictionary values.
Replaces symbolic expressions that do not contain free symbols with their corresponding numeric values.
- Parameters:
precision (
int
, default:15
) – The number of decimal digits of precision for evaluation.- Returns:
GeneralAnsatz
– Updated instance ofGeneralAnsatz
. This operation is in-place.
- class CircuitAnsatz(circuit, reference=None)¶
Bases:
GeneralAnsatz
An ansatz that stores a single symbolic circuit.
- Parameters:
circuit (
Circuit
) – A symbolic circuit.reference (
Union
[int
,List
[Qubit
],List
[int
],QubitSpace
,QubitState
,Circuit
,None
], default:None
) – An optional reference state circuit or any valid initializer forreference_circuit_builder()
.
- circuit_resources(return_circuit=False)¶
Returns crude resource estimates for the implementation of unoptimized ansatz preparation circuit (e.g. gatecount).
This proceeds via decomposition of boxes in the state preparation circuit, followed by rebasing to the native TKET gateset (CX, TK1, Phase). Analysis of the circuit is performed on a copy – the original circuit stored in this object is left unmodified.
- Parameters:
return_circuit (
bool
, default:False
) – If set to True, the rebased circuit will be included as an additional element of the dictionary under the key “circuit”.- Returns:
dict
[str
,int
|Circuit
] – A dictionary of resource estimates of the ansatz circuit keyed by resource label (e.g. “depth”), optionally including the rebased circuit.
- default_pass()¶
Get the default compiler pass for the ansatz type.
- Returns:
BasePass
– A tket pass object.
- df_numeric(symbol_map=None, *, space=None, backend=None, dtype=complex, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_numeric_representation()
to generate a numeric vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_numeric_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_numeric_representation()
.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation. Passed toget_numeric_representation()
.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted. Passed toget_numeric_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- df_symbolic(symbol_map=None, *, space=None, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_symbolic_representation()
to generate a symbolic vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Symbolic coefficients are simplified before being added to dataframe.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_symbolic_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_symbolic_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- free_symbols()¶
Returns the free symbols in the object.
- Returns:
Set
[Symbol
] – Unordered set of symbols.
- free_symbols_ordered()¶
Returns the free symbols in increasing lexicographic order.
- Returns:
SymbolEnsemble
– Ordered free symbols in object.
- get_circuit(symbol_map=None)¶
Constructs a single state circuit.
- get_circuit_no_ref(symbol_map=None)¶
Constructs a single state circuit without the reference state.
- Parameters:
- Returns:
Circuit
– A circuit that represent the referenceless state.
- get_numeric_representation(symbol_map=None, *, space=None, backend=None, dtype=complex)¶
Constructs a single numeric matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation.space (
Any
, default:None
) – Basis information to represent the object.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted.
- Returns:
Union
[_SupportsArray
[dtype
[Any
]],_NestedSequence
[_SupportsArray
[dtype
[Any
]]],bool
,int
,float
,complex
,str
,bytes
,_NestedSequence
[bool
|int
|float
|complex
|str
|bytes
]] – A matrix/vector representing the object.
- get_symbolic_representation(symbol_map=None, *, space=None)¶
Constructs a single symbolic matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
- Returns:
Expr
– A symbolic expression as a representation, which is a symbolic NDArray.
- make_hashable()¶
Returns a hashable representation of the ansatz object.
- Returns:
Hashable
– Hashable representation of ansatz.
- reference_qubit_state()¶
Create a symbolic
QubitState
representation of the reference state.- Returns:
QubitState
– Reference state as aQubitState
.
- reset_reference(reference)¶
Resetting the reference state of the ansatz in place.
Note
The number of qubits in the new reference has to match with the already existing reference state.
- Parameters:
reference (
Union
[int
,List
[Qubit
],List
[int
],QubitSpace
,QubitState
,Circuit
]) – Any reference that can be converted into a non-symbolic reference state circuit.- Returns:
Returns self with the modified reference.
- property state_circuit: Circuit¶
Returns the symbolic state circuit with a default compilation.
- property state_symbols: SymbolEnsemble¶
Returns the ordered parameter symbols this state uses.
- subs(symbol_map)¶
Returns a new objects with symbols substituted.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
]) – A mapping for substitution of free symbols.- Returns:
TypeVar
(SYMBOLICTYPE
, bound= Symbolic) – A copy of self with symbols substituted according to the provided map.
- symbol_substitution(symbol_map=None)¶
Performs an in-place symbol substation in the object.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – Dictionary or Callable mapping existing symbols to new symbols or values.
Note
While this is an in-place operation, consistency in free_symbols_ordered() is not guaranteed.
- Returns:
CircuitAnsatz
–self
, with symbols substituted.
- to_CircuitAnsatz(symbol_map=None)¶
Cast the ansatz as CircuitAnsatz with optional symbol substitution.
- to_QubitState()¶
Create a symbolic
QubitState
representation of the ansatz.- Returns:
QubitState
– Ansatz as aQubitState
.
- unsympify(precision=15)¶
Unsympifies dictionary values.
Replaces symbolic expressions that do not contain free symbols with their corresponding numeric values. For
CircuitAnsatz
, this has no effect.- Parameters:
precision (
int
, default:15
) – The number of decimal digits of precision for evaluation.- Returns:
CircuitAnsatz
– Updated instance ofCircuitAnsatz
. This operation is in-place.
- class ComposedAnsatz(*ansatzes, reference=None)¶
Bases:
CircuitAnsatz
Composes circuit ansatzes into one circuit ansatz.
Note
The composed circuit is built by applying the arguments of the
ComposedAnsatz
constructor in reverse order. i.e. for two instances ofCircuitAnsatz
A, B, the composed circuit ofComposedAnsatz(A, B)
represents the state AB \(|0\rangle\), hence B is applied first.Examples
>>> A = CircuitAnsatz(Circuit(1).Y(0)) >>> B = CircuitAnsatz(Circuit(1).Z(0), [1]) >>> ComposedAnsatz(A, B).get_circuit() [X q[0]; Z q[0]; Y q[0]; ] >>> C = CircuitAnsatz(Circuit(1).Y(0)) >>> D = CircuitAnsatz(Circuit(1).Z(0)) >>> ComposedAnsatz(C, D, reference = [1]).get_circuit() [X q[0]; Z q[0]; Y q[0]; ]
- Parameters:
*ansatzes (
GeneralAnsatz
) – Sequence of circuit ansatzes that will be appended together.reference (
Union
[int
,List
[Qubit
],List
[int
],QubitSpace
,QubitState
,Circuit
,None
], default:None
) – An optional reference state circuit or any valid initializer forreference_circuit_builder()
.
- circuit_resources(return_circuit=False)¶
Returns crude resource estimates for the implementation of unoptimized ansatz preparation circuit (e.g. gatecount).
This proceeds via decomposition of boxes in the state preparation circuit, followed by rebasing to the native TKET gateset (CX, TK1, Phase). Analysis of the circuit is performed on a copy – the original circuit stored in this object is left unmodified.
- Parameters:
return_circuit (
bool
, default:False
) – If set to True, the rebased circuit will be included as an additional element of the dictionary under the key “circuit”.- Returns:
dict
[str
,int
|Circuit
] – A dictionary of resource estimates of the ansatz circuit keyed by resource label (e.g. “depth”), optionally including the rebased circuit.
- default_pass()¶
Get the default compiler pass for the ansatz type.
- Returns:
BasePass
– A tket pass object.
- df_numeric(symbol_map=None, *, space=None, backend=None, dtype=complex, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_numeric_representation()
to generate a numeric vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_numeric_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_numeric_representation()
.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation. Passed toget_numeric_representation()
.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted. Passed toget_numeric_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- df_symbolic(symbol_map=None, *, space=None, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_symbolic_representation()
to generate a symbolic vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Symbolic coefficients are simplified before being added to dataframe.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_symbolic_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_symbolic_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- free_symbols()¶
Returns the free symbols in the object.
- Returns:
Set
[Symbol
] – Unordered set of symbols.
- free_symbols_ordered()¶
Returns the free symbols in increasing lexicographic order.
- Returns:
SymbolEnsemble
– Ordered free symbols in object.
- get_circuit(symbol_map=None)¶
Constructs a single state circuit.
- get_circuit_no_ref(symbol_map=None)¶
Constructs a single state circuit without the reference state.
- Parameters:
- Returns:
Circuit
– A circuit that represent the referenceless state.
- get_numeric_representation(symbol_map=None, *, space=None, backend=None, dtype=complex)¶
Constructs a single numeric matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation.space (
Any
, default:None
) – Basis information to represent the object.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted.
- Returns:
Union
[_SupportsArray
[dtype
[Any
]],_NestedSequence
[_SupportsArray
[dtype
[Any
]]],bool
,int
,float
,complex
,str
,bytes
,_NestedSequence
[bool
|int
|float
|complex
|str
|bytes
]] – A matrix/vector representing the object.
- get_symbolic_representation(symbol_map=None, *, space=None)¶
Constructs a single symbolic matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
- Returns:
Expr
– A symbolic expression as a representation, which is a symbolic NDArray.
- make_hashable()¶
Returns a hashable representation of the ansatz object.
- Returns:
Hashable
– Hashable representation of ansatz.
- reference_qubit_state()¶
Create a symbolic
QubitState
representation of the reference state.- Returns:
QubitState
– Reference state as aQubitState
.
- reset_reference(reference)¶
Resetting the reference state of the ansatz in place.
Note
The number of qubits in the new reference has to match with the already existing reference state.
- Parameters:
reference (
Union
[int
,List
[Qubit
],List
[int
],QubitSpace
,QubitState
,Circuit
]) – Any reference that can be converted into a non-symbolic reference state circuit.- Returns:
Returns self with the modified reference.
- property state_circuit: Circuit¶
Returns the symbolic state circuit with a default compilation.
- property state_symbols: SymbolEnsemble¶
Returns the ordered parameter symbols this state uses.
- subs(symbol_map)¶
Returns a new objects with symbols substituted.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
]) – A mapping for substitution of free symbols.- Returns:
TypeVar
(SYMBOLICTYPE
, bound= Symbolic) – A copy of self with symbols substituted according to the provided map.
- symbol_substitution(symbol_map=None)¶
Performs an in-place symbol substation in the object.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – Dictionary or Callable mapping existing symbols to new symbols or values.
Note
While this is an in-place operation, consistency in free_symbols_ordered() is not guaranteed.
- Returns:
CircuitAnsatz
–self
, with symbols substituted.
- to_CircuitAnsatz(symbol_map=None)¶
Cast the ansatz as CircuitAnsatz with optional symbol substitution.
- to_QubitState()¶
Create a symbolic
QubitState
representation of the ansatz.- Returns:
QubitState
– Ansatz as aQubitState
.
- unsympify(precision=15)¶
Unsympifies dictionary values.
Replaces symbolic expressions that do not contain free symbols with their corresponding numeric values. For
CircuitAnsatz
, this has no effect.- Parameters:
precision (
int
, default:15
) – The number of decimal digits of precision for evaluation.- Returns:
CircuitAnsatz
– Updated instance ofCircuitAnsatz
. This operation is in-place.
- class TrotterAnsatz(exponents, reference=None)¶
Bases:
GeneralAnsatz
Ansatz representing a state built from a product of Pauli-exponentials.
This is at the core of the UCC family of
ansatzes
in InQuanto.Note: This class requires numerical operators within the input
QubitOperatorList
.- Parameters:
exponents (
QubitOperatorList
) – Contains exponent and symbol data.reference (
Union
[int
,List
[Qubit
],List
[int
],QubitSpace
,QubitState
,Circuit
,None
], default:None
) – An optional reference state circuit or any valid initializer forreference_circuit_builder()
.
Examples
>>> from inquanto.states import QubitState >>> exponents = QubitOperatorList.from_string("a [(1j, Y0 X2)], b [(1j, Y1 X3)]") >>> ref = QubitState([1, 1, 0, 0]) >>> ansatz = TrotterAnsatz(exponents, reference=ref) >>> ansatz.free_symbols_ordered().as_list() # returns an lexicographically ordered set of symbols [a, b] >>> ansatz.free_symbols() == {Symbol("a"), Symbol("b")} # returns a set of symbols True >>> ansatz.subs("new_{}").free_symbols() == {Symbol("new_a"), Symbol("new_b")} # new instance True >>> ansatz2 = ansatz.symbol_substitution("new_{}") # in-place substitution >>> ansatz2 is ansatz True >>> ansatz.free_symbols() == {Symbol("new_a"), Symbol("new_b")} True
- circuit_resources(return_circuit=False)¶
Returns crude resource estimates for the implementation of unoptimized ansatz preparation circuit (e.g. gatecount).
This proceeds via decomposition of boxes in the state preparation circuit, followed by rebasing to the native TKET gateset (CX, TK1, Phase). Analysis of the circuit is performed on a copy – the original circuit stored in this object is left unmodified.
- Parameters:
return_circuit (
bool
, default:False
) – If set to True, the rebased circuit will be included as an additional element of the dictionary under the key “circuit”.- Returns:
dict
[str
,int
|Circuit
] – A dictionary of resource estimates of the ansatz circuit keyed by resource label (e.g. “depth”), optionally including the rebased circuit.
- default_pass()¶
Get the default compiler pass for the ansatz type.
- Returns:
A tket pass object.
- df_numeric(symbol_map=None, *, space=None, backend=None, dtype=complex, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_numeric_representation()
to generate a numeric vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_numeric_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_numeric_representation()
.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation. Passed toget_numeric_representation()
.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted. Passed toget_numeric_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- df_symbolic(symbol_map=None, *, space=None, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_symbolic_representation()
to generate a symbolic vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Symbolic coefficients are simplified before being added to dataframe.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_symbolic_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_symbolic_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- property exponents: QubitOperatorList¶
Returns the qubit operator exponents.
- free_symbols()¶
Returns the free symbols in the object.
- Returns:
Set
[Symbol
] – Unordered set of symbols.
- free_symbols_ordered()¶
Returns the free symbols in increasing lexicographic order.
- Returns:
SymbolEnsemble
– Ordered free symbols in object.
- get_circuit(symbol_map=None)¶
Constructs a single state circuit.
- get_circuit_no_ref(symbol_map=None)¶
Constructs a single state circuit without the reference state.
- Parameters:
- Returns:
Circuit
– A circuit that represent the referenceless state.
- get_numeric_representation(symbol_map=None, *, space=None, backend=None, dtype=complex)¶
Constructs a single numeric matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation.space (
Any
, default:None
) – Basis information to represent the object.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted.
- Returns:
Union
[_SupportsArray
[dtype
[Any
]],_NestedSequence
[_SupportsArray
[dtype
[Any
]]],bool
,int
,float
,complex
,str
,bytes
,_NestedSequence
[bool
|int
|float
|complex
|str
|bytes
]] – A matrix/vector representing the object.
- get_symbolic_representation(symbol_map=None, *, space=None)¶
Constructs a single symbolic matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
- Returns:
Expr
– A symbolic expression as a representation, which is a symbolic NDArray.
- make_hashable()¶
Returns a hashable representation of the ansatz object.
- Returns:
Hashable
– Hashable representation of ansatz.
- reference_qubit_state()¶
Create a symbolic
QubitState
representation of the reference state.- Returns:
QubitState
– Reference state as aQubitState
.
- reset_reference(reference)¶
Resetting the reference state of the ansatz in place.
Note
The number of qubits in the new reference has to match with the already existing reference state.
- Parameters:
reference (
Union
[int
,List
[Qubit
],List
[int
],QubitSpace
,QubitState
,Circuit
]) – Any reference that can be converted into a non-symbolic reference state circuit.- Returns:
Returns self with the modified reference.
- property state_circuit: Circuit¶
Returns the symbolic state circuit with a default compilation.
- property state_symbols: SymbolEnsemble¶
Returns the ordered parameter symbols this state uses.
- subs(symbol_map)¶
Returns a new objects with symbols substituted.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
]) – A mapping for substitution of free symbols.- Returns:
TypeVar
(SYMBOLICTYPE
, bound= Symbolic) – A copy of self with symbols substituted according to the provided map.
- symbol_substitution(symbol_map=None)¶
Performs an in-place symbol substation in the object.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – Dictionary or Callable mapping existing symbols to new symbols or values.
Note
While this is an in-place operation, consistency in free_symbols_ordered() is not guaranteed.
- Returns:
TrotterAnsatz
–self
, with symbols substituted.
- to_CircuitAnsatz(symbol_map=None)¶
Cast the ansatz as CircuitAnsatz with optional symbol substitution.
- to_QubitState(reverse=False)¶
Returns a
QubitState
object corresponding to the generated state.This proceeds through direct exponentiation of individual terms and application to the reference state. The ansatz must have been constructed with a QubitState reference.
Danger
In general, this will blow up exponentially.
- Parameters:
reverse (
bool
, default:False
) – set to True to reverse the order of term application- Returns:
The Ansatz state.
- to_QubitState_direct(reverse=False)¶
Returns a
QubitState
object corresponding to the generated state.This proceeds through direct exponentiation of individual terms and application to the reference state. The ansatz must have been constructed with a QubitState reference.
Danger
In general, this will blow up exponentially.
- Parameters:
reverse (
bool
, default:False
) – set to True to reverse the order of term application- Returns:
QubitState
– The Ansatz state.
- unsympify(precision=15)¶
Unsympifies coefficient values.
Replaces symbolic expressions that do not contain free symbols with their corresponding numeric values.
- Parameters:
precision (
int
, default:15
) – The number of decimal digits of precision used for evaluation.- Returns:
TrotterAnsatz
– Updated instance ofTrotterAnsatz
. This operation is in-place.
- reference_circuit_builder(initializer)¶
Building a non-symbolic reference circuit.
- Parameters:
initializer (
Union
[int
,List
[Qubit
],List
[int
],QubitSpace
,QubitState
,Circuit
,None
]) –- A non-symbolic initializer circuit or an object that can be converted to one.
If
initializer
is anint
, an empty initializer circuit is created withinitializer
number of qubits.If
initializer
is alist
of qubit-s, an empty initializer circuit is created with the qubits.- If
initializer
is alist
of 0 or 1-s, an initializer circuit is created andX
gate is added for indices where the
initializer[index] == 1
.
- If
- If
initializer
is aQubitSpace
, an empty initializer circuit is created with qubits in the
QubitSpace
.
- If
- If
initializer
is a non-symbolicQubitState
, an initializer circuit is created that represents the initializer state.
- If
- Returns:
Optional
[Circuit
] – A non-symbolic reference circuit.
Fermion Space ansatzes¶
- class FermionSpaceStateExp(fermion_operator_exponents, fock_state, qubit_mapping=QubitMappingJordanWigner(), qubits=None, taperer=None, tapering_exponent_check_behavior='except', *args, **kwargs)¶
Bases:
TrotterAnsatz
Fermion operator exponentiation (e.g. for UCC). Also initializes state trotterization.
Qubit tapering can optionally be performed. To enable qubit tapering, pass a
TapererZ2
object totaperer
. Tapering behavior can be modified by passingtapering_exponent_check_behavior
as specified below.- Parameters:
fermion_operator_exponents (
FermionOperatorList
) – Excitation operators (anti-hermitian for UCC).fock_state (
FermionState
) – Spin orbital occupations.qubit_mapping (
QubitMapping
, default:QubitMappingJordanWigner()
) – How to map fock state operators and states to qubit operators and circuits.qubits (
Optional
[List
[Qubit
]], default:None
) – The qubit register used to represent the ansatz state. If no register is provided, a minimal register consisting of qubits indexed from 0 to N is built, where N is the number of spin-orbitals in the reference state provided. Note that this may include qubits corresponding to spin-orbitals which the excitations do not act on.taperer (
TapererZ2
, default:None
) – The taperer object used to control how the ansatz is tapered. Set toNone
(default) to skip.tapering_exponent_check_behavior (
str
, default:"except"
) –Controls treatment of exponents which don’t commute with the Z2 symmetry operators. Options are:
"except"
: Tests each exponent and throws an exception if any exponent does not commute with the symmetry operators."skip"
: Skips exponent testing entirely. This may be dangerous (and is untested) but will be faster when exponents are known to be safe."discard"
: Tests each exponent and discards any that don’t commute with the Z2 symmetry operators. This should only discard excitations which don’t contribute to the ground state, but may be unsafe.
*args – Additional arguments offered by parent object.
**kwargs – Additional keyword arguments offered by parent object.
- circuit_resources(return_circuit=False)¶
Returns crude resource estimates for the implementation of unoptimized ansatz preparation circuit (e.g. gatecount).
This proceeds via decomposition of boxes in the state preparation circuit, followed by rebasing to the native TKET gateset (CX, TK1, Phase). Analysis of the circuit is performed on a copy – the original circuit stored in this object is left unmodified.
- Parameters:
return_circuit (
bool
, default:False
) – If set to True, the rebased circuit will be included as an additional element of the dictionary under the key “circuit”.- Returns:
dict
[str
,int
|Circuit
] – A dictionary of resource estimates of the ansatz circuit keyed by resource label (e.g. “depth”), optionally including the rebased circuit.
- default_pass()¶
Get the default compiler pass for the ansatz type.
- Returns:
A tket pass object.
- df_numeric(symbol_map=None, *, space=None, backend=None, dtype=complex, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_numeric_representation()
to generate a numeric vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_numeric_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_numeric_representation()
.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation. Passed toget_numeric_representation()
.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted. Passed toget_numeric_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- df_symbolic(symbol_map=None, *, space=None, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_symbolic_representation()
to generate a symbolic vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Symbolic coefficients are simplified before being added to dataframe.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_symbolic_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_symbolic_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- property exponents: QubitOperatorList¶
Returns the qubit operator exponents.
- property fermion_operator_exponents: FermionOperatorList¶
Returns the list of exponents of the exponential product included in the ansatz.
- free_symbols()¶
Returns the free symbols in the object.
- Returns:
Set
[Symbol
] – Unordered set of symbols.
- free_symbols_ordered()¶
Returns the free symbols in increasing lexicographic order.
- Returns:
SymbolEnsemble
– Ordered free symbols in object.
- get_circuit(symbol_map=None)¶
Constructs a single state circuit.
- get_circuit_no_ref(symbol_map=None)¶
Constructs a single state circuit without the reference state.
- Parameters:
- Returns:
Circuit
– A circuit that represent the referenceless state.
- get_numeric_representation(symbol_map=None, *, space=None, backend=None, dtype=complex)¶
Constructs a single numeric matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation.space (
Any
, default:None
) – Basis information to represent the object.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted.
- Returns:
Union
[_SupportsArray
[dtype
[Any
]],_NestedSequence
[_SupportsArray
[dtype
[Any
]]],bool
,int
,float
,complex
,str
,bytes
,_NestedSequence
[bool
|int
|float
|complex
|str
|bytes
]] – A matrix/vector representing the object.
- get_symbolic_representation(symbol_map=None, *, space=None)¶
Constructs a single symbolic matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
- Returns:
Expr
– A symbolic expression as a representation, which is a symbolic NDArray.
- make_hashable()¶
Returns a hashable representation of the ansatz object.
- Returns:
Hashable
– Hashable representation of ansatz.
- reference_qubit_state()¶
Create a symbolic
QubitState
representation of the reference state.- Returns:
QubitState
– Reference state as aQubitState
.
- reset_reference(reference)¶
Resetting the reference state of the ansatz in place.
Note
The number of qubits in the new reference has to match with the already existing reference state.
- Parameters:
reference (
Union
[int
,List
[Qubit
],List
[int
],QubitSpace
,QubitState
,Circuit
]) – Any reference that can be converted into a non-symbolic reference state circuit.- Returns:
Returns self with the modified reference.
- property state_circuit: Circuit¶
Returns the symbolic state circuit with a default compilation.
- property state_symbols: SymbolEnsemble¶
Returns the ordered parameter symbols this state uses.
- subs(symbol_map)¶
Returns a new objects with symbols substituted.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
]) – A mapping for substitution of free symbols.- Returns:
TypeVar
(SYMBOLICTYPE
, bound= Symbolic) – A copy of self with symbols substituted according to the provided map.
- symbol_substitution(symbol_map=None)¶
Performs an in-place symbol substation in the object.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – Dictionary or Callable mapping existing symbols to new symbols or values.
Note
While this is an in-place operation, consistency in free_symbols_ordered() is not guaranteed.
- Returns:
TrotterAnsatz
–self
, with symbols substituted.
- to_CircuitAnsatz(symbol_map=None)¶
Cast the ansatz as CircuitAnsatz with optional symbol substitution.
- to_QubitState(reverse=False)¶
Returns a
QubitState
object corresponding to the generated state.This proceeds through direct exponentiation of individual terms and application to the reference state. The ansatz must have been constructed with a QubitState reference.
Danger
In general, this will blow up exponentially.
- Parameters:
reverse (
bool
, default:False
) – set to True to reverse the order of term application- Returns:
The Ansatz state.
- to_QubitState_direct(reverse=False)¶
Returns a
QubitState
object corresponding to the generated state.This proceeds through direct exponentiation of individual terms and application to the reference state. The ansatz must have been constructed with a QubitState reference.
Danger
In general, this will blow up exponentially.
- Parameters:
reverse (
bool
, default:False
) – set to True to reverse the order of term application- Returns:
QubitState
– The Ansatz state.
- unsympify(precision=15)¶
Unsympifies exponents and coefficient values.
Replaces symbolic expressions that do not contain free symbols with their corresponding numeric values.
- Parameters:
precision (
int
, default:15
) – The number of decimal digits of precision used for evaluation.- Returns:
FermionSpaceStateExp
– Updated instance ofFermionSpaceStateExp
. This operation is in-place.
- class FermionSpaceAnsatzUCCSD(fermion_space, fermion_state, qubit_mapping=QubitMappingJordanWigner(), *args, **kwargs)¶
Bases:
FermionSpaceStateExp
Unitary coupled cluster with singles and doubles excitations (UCCSD).
Builds ansatz for a given
fermion_space
andfermion_state
.- Parameters:
fermion_space (
Union
[FermionSpace
,int
]) – Spin orbital indices, occupations, and spatial orbitals indices.fermion_state (
FermionState
) – Spin orbital occupations.qubit_mapping (
QubitMapping
, default:QubitMappingJordanWigner()
) – How to map fock state operators and states to qubit operators and circuits.*args – Additional arguments offered by parent object.
**kwargs – Additional keyword arguments offered by parent object.
- circuit_resources(return_circuit=False)¶
Returns crude resource estimates for the implementation of unoptimized ansatz preparation circuit (e.g. gatecount).
This proceeds via decomposition of boxes in the state preparation circuit, followed by rebasing to the native TKET gateset (CX, TK1, Phase). Analysis of the circuit is performed on a copy – the original circuit stored in this object is left unmodified.
- Parameters:
return_circuit (
bool
, default:False
) – If set to True, the rebased circuit will be included as an additional element of the dictionary under the key “circuit”.- Returns:
dict
[str
,int
|Circuit
] – A dictionary of resource estimates of the ansatz circuit keyed by resource label (e.g. “depth”), optionally including the rebased circuit.
- default_pass()¶
Get the default compiler pass for the ansatz type.
- Returns:
A tket pass object.
- df_numeric(symbol_map=None, *, space=None, backend=None, dtype=complex, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_numeric_representation()
to generate a numeric vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_numeric_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_numeric_representation()
.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation. Passed toget_numeric_representation()
.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted. Passed toget_numeric_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- df_symbolic(symbol_map=None, *, space=None, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_symbolic_representation()
to generate a symbolic vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Symbolic coefficients are simplified before being added to dataframe.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_symbolic_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_symbolic_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- property exponents: QubitOperatorList¶
Returns the qubit operator exponents.
- property fermion_operator_exponents: FermionOperatorList¶
Returns the list of exponents of the exponential product included in the ansatz.
- free_symbols()¶
Returns the free symbols in the object.
- Returns:
Set
[Symbol
] – Unordered set of symbols.
- free_symbols_ordered()¶
Returns the free symbols in increasing lexicographic order.
- Returns:
SymbolEnsemble
– Ordered free symbols in object.
- get_circuit(symbol_map=None)¶
Constructs a single state circuit.
- get_circuit_no_ref(symbol_map=None)¶
Constructs a single state circuit without the reference state.
- Parameters:
- Returns:
Circuit
– A circuit that represent the referenceless state.
- get_numeric_representation(symbol_map=None, *, space=None, backend=None, dtype=complex)¶
Constructs a single numeric matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation.space (
Any
, default:None
) – Basis information to represent the object.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted.
- Returns:
Union
[_SupportsArray
[dtype
[Any
]],_NestedSequence
[_SupportsArray
[dtype
[Any
]]],bool
,int
,float
,complex
,str
,bytes
,_NestedSequence
[bool
|int
|float
|complex
|str
|bytes
]] – A matrix/vector representing the object.
- get_symbolic_representation(symbol_map=None, *, space=None)¶
Constructs a single symbolic matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
- Returns:
Expr
– A symbolic expression as a representation, which is a symbolic NDArray.
- make_hashable()¶
Returns a hashable representation of the ansatz object.
- Returns:
Hashable
– Hashable representation of ansatz.
- reference_qubit_state()¶
Create a symbolic
QubitState
representation of the reference state.- Returns:
QubitState
– Reference state as aQubitState
.
- reset_reference(reference)¶
Resetting the reference state of the ansatz in place.
Note
The number of qubits in the new reference has to match with the already existing reference state.
- Parameters:
reference (
Union
[int
,List
[Qubit
],List
[int
],QubitSpace
,QubitState
,Circuit
]) – Any reference that can be converted into a non-symbolic reference state circuit.- Returns:
Returns self with the modified reference.
- property state_circuit: Circuit¶
Returns the symbolic state circuit with a default compilation.
- property state_symbols: SymbolEnsemble¶
Returns the ordered parameter symbols this state uses.
- subs(symbol_map)¶
Returns a new objects with symbols substituted.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
]) – A mapping for substitution of free symbols.- Returns:
TypeVar
(SYMBOLICTYPE
, bound= Symbolic) – A copy of self with symbols substituted according to the provided map.
- symbol_substitution(symbol_map=None)¶
Performs an in-place symbol substation in the object.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – Dictionary or Callable mapping existing symbols to new symbols or values.
Note
While this is an in-place operation, consistency in free_symbols_ordered() is not guaranteed.
- Returns:
TrotterAnsatz
–self
, with symbols substituted.
- to_CircuitAnsatz(symbol_map=None)¶
Cast the ansatz as CircuitAnsatz with optional symbol substitution.
- to_QubitState(reverse=False)¶
Returns a
QubitState
object corresponding to the generated state.This proceeds through direct exponentiation of individual terms and application to the reference state. The ansatz must have been constructed with a QubitState reference.
Danger
In general, this will blow up exponentially.
- Parameters:
reverse (
bool
, default:False
) – set to True to reverse the order of term application- Returns:
The Ansatz state.
- to_QubitState_direct(reverse=False)¶
Returns a
QubitState
object corresponding to the generated state.This proceeds through direct exponentiation of individual terms and application to the reference state. The ansatz must have been constructed with a QubitState reference.
Danger
In general, this will blow up exponentially.
- Parameters:
reverse (
bool
, default:False
) – set to True to reverse the order of term application- Returns:
QubitState
– The Ansatz state.
- unsympify(precision=15)¶
Unsympifies exponents and coefficient values.
Replaces symbolic expressions that do not contain free symbols with their corresponding numeric values.
- Parameters:
precision (
int
, default:15
) – The number of decimal digits of precision used for evaluation.- Returns:
FermionSpaceStateExp
– Updated instance ofFermionSpaceStateExp
. This operation is in-place.
- class FermionSpaceAnsatzUCCD(fermion_space, fermion_state, qubit_mapping=QubitMappingJordanWigner(), *args, **kwargs)¶
Bases:
FermionSpaceStateExp
Unitary coupled cluster with doubles excitations, no singles (UCCD).
Builds ansatz for a given
fermion_space
andfermion_state
.- Parameters:
fermion_space (
Union
[FermionSpace
,int
]) – Spin orbital indices, occupations, and spatial orbitals indices.fermion_state (
FermionState
) – Spin orbital occupations.qubit_mapping (
QubitMapping
, default:QubitMappingJordanWigner()
) – How to map fock state operators and states to qubit operators and circuits.*args – Additional arguments offered by parent object.
**kwargs – Additional keyword arguments offered by parent object.
- circuit_resources(return_circuit=False)¶
Returns crude resource estimates for the implementation of unoptimized ansatz preparation circuit (e.g. gatecount).
This proceeds via decomposition of boxes in the state preparation circuit, followed by rebasing to the native TKET gateset (CX, TK1, Phase). Analysis of the circuit is performed on a copy – the original circuit stored in this object is left unmodified.
- Parameters:
return_circuit (
bool
, default:False
) – If set to True, the rebased circuit will be included as an additional element of the dictionary under the key “circuit”.- Returns:
dict
[str
,int
|Circuit
] – A dictionary of resource estimates of the ansatz circuit keyed by resource label (e.g. “depth”), optionally including the rebased circuit.
- default_pass()¶
Get the default compiler pass for the ansatz type.
- Returns:
A tket pass object.
- df_numeric(symbol_map=None, *, space=None, backend=None, dtype=complex, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_numeric_representation()
to generate a numeric vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_numeric_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_numeric_representation()
.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation. Passed toget_numeric_representation()
.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted. Passed toget_numeric_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- df_symbolic(symbol_map=None, *, space=None, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_symbolic_representation()
to generate a symbolic vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Symbolic coefficients are simplified before being added to dataframe.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_symbolic_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_symbolic_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- property exponents: QubitOperatorList¶
Returns the qubit operator exponents.
- property fermion_operator_exponents: FermionOperatorList¶
Returns the list of exponents of the exponential product included in the ansatz.
- free_symbols()¶
Returns the free symbols in the object.
- Returns:
Set
[Symbol
] – Unordered set of symbols.
- free_symbols_ordered()¶
Returns the free symbols in increasing lexicographic order.
- Returns:
SymbolEnsemble
– Ordered free symbols in object.
- get_circuit(symbol_map=None)¶
Constructs a single state circuit.
- get_circuit_no_ref(symbol_map=None)¶
Constructs a single state circuit without the reference state.
- Parameters:
- Returns:
Circuit
– A circuit that represent the referenceless state.
- get_numeric_representation(symbol_map=None, *, space=None, backend=None, dtype=complex)¶
Constructs a single numeric matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation.space (
Any
, default:None
) – Basis information to represent the object.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted.
- Returns:
Union
[_SupportsArray
[dtype
[Any
]],_NestedSequence
[_SupportsArray
[dtype
[Any
]]],bool
,int
,float
,complex
,str
,bytes
,_NestedSequence
[bool
|int
|float
|complex
|str
|bytes
]] – A matrix/vector representing the object.
- get_symbolic_representation(symbol_map=None, *, space=None)¶
Constructs a single symbolic matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
- Returns:
Expr
– A symbolic expression as a representation, which is a symbolic NDArray.
- make_hashable()¶
Returns a hashable representation of the ansatz object.
- Returns:
Hashable
– Hashable representation of ansatz.
- reference_qubit_state()¶
Create a symbolic
QubitState
representation of the reference state.- Returns:
QubitState
– Reference state as aQubitState
.
- reset_reference(reference)¶
Resetting the reference state of the ansatz in place.
Note
The number of qubits in the new reference has to match with the already existing reference state.
- Parameters:
reference (
Union
[int
,List
[Qubit
],List
[int
],QubitSpace
,QubitState
,Circuit
]) – Any reference that can be converted into a non-symbolic reference state circuit.- Returns:
Returns self with the modified reference.
- property state_circuit: Circuit¶
Returns the symbolic state circuit with a default compilation.
- property state_symbols: SymbolEnsemble¶
Returns the ordered parameter symbols this state uses.
- subs(symbol_map)¶
Returns a new objects with symbols substituted.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
]) – A mapping for substitution of free symbols.- Returns:
TypeVar
(SYMBOLICTYPE
, bound= Symbolic) – A copy of self with symbols substituted according to the provided map.
- symbol_substitution(symbol_map=None)¶
Performs an in-place symbol substation in the object.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – Dictionary or Callable mapping existing symbols to new symbols or values.
Note
While this is an in-place operation, consistency in free_symbols_ordered() is not guaranteed.
- Returns:
TrotterAnsatz
–self
, with symbols substituted.
- to_CircuitAnsatz(symbol_map=None)¶
Cast the ansatz as CircuitAnsatz with optional symbol substitution.
- to_QubitState(reverse=False)¶
Returns a
QubitState
object corresponding to the generated state.This proceeds through direct exponentiation of individual terms and application to the reference state. The ansatz must have been constructed with a QubitState reference.
Danger
In general, this will blow up exponentially.
- Parameters:
reverse (
bool
, default:False
) – set to True to reverse the order of term application- Returns:
The Ansatz state.
- to_QubitState_direct(reverse=False)¶
Returns a
QubitState
object corresponding to the generated state.This proceeds through direct exponentiation of individual terms and application to the reference state. The ansatz must have been constructed with a QubitState reference.
Danger
In general, this will blow up exponentially.
- Parameters:
reverse (
bool
, default:False
) – set to True to reverse the order of term application- Returns:
QubitState
– The Ansatz state.
- unsympify(precision=15)¶
Unsympifies exponents and coefficient values.
Replaces symbolic expressions that do not contain free symbols with their corresponding numeric values.
- Parameters:
precision (
int
, default:15
) – The number of decimal digits of precision used for evaluation.- Returns:
FermionSpaceStateExp
– Updated instance ofFermionSpaceStateExp
. This operation is in-place.
- class FermionSpaceStateExpChemicallyAware(fermion_operator_exponents, fermion_state)¶
Bases:
GeneralAnsatz
Efficient fermion operator exponentiation (e.g. for UCC). Also initializes state trotterization.
Synthesizes molecular orbital to molecular orbital double excitations uniquely. Changes trotter order of excitations to synthesize circuit with fewer two qubit gates compared to
FermionSpaceStateExp
. Circuit is synthesized in Jordan-Wigner encoding.- Parameters:
fermion_operator_exponents (
FermionOperatorList
) – Contains exponents and symbols. Assumes input exponents are ordered as single exponents first, followed by double exponents.fermion_state (
FermionState
) – Initial fermionic reference state.
- circuit_resources(return_circuit=False)¶
Returns crude resource estimates for the implementation of unoptimized ansatz preparation circuit (e.g. gatecount).
This proceeds via decomposition of boxes in the state preparation circuit, followed by rebasing to the native TKET gateset (CX, TK1, Phase). Analysis of the circuit is performed on a copy – the original circuit stored in this object is left unmodified.
- Parameters:
return_circuit (
bool
, default:False
) – If set to True, the rebased circuit will be included as an additional element of the dictionary under the key “circuit”.- Returns:
dict
[str
,int
|Circuit
] – A dictionary of resource estimates of the ansatz circuit keyed by resource label (e.g. “depth”), optionally including the rebased circuit.
- default_pass()¶
Get the default compiler pass for the ansatz type.
- Returns:
BasePass
– A tket pass object.
- df_numeric(symbol_map=None, *, space=None, backend=None, dtype=complex, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_numeric_representation()
to generate a numeric vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_numeric_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_numeric_representation()
.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation. Passed toget_numeric_representation()
.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted. Passed toget_numeric_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- df_symbolic(symbol_map=None, *, space=None, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_symbolic_representation()
to generate a symbolic vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Symbolic coefficients are simplified before being added to dataframe.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_symbolic_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_symbolic_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- property fermion_operator_exponents: FermionOperatorList¶
Returns the list of exponents of the exponential product included in the ansatz.
- free_symbols()¶
Returns the free symbols in the object.
- Returns:
set
[Symbol
] – Unordered set of symbols.
- free_symbols_ordered()¶
Returns the free symbols in increasing lexicographic order.
- Returns:
SymbolEnsemble
– Ordered free symbols in object.
- get_circuit(symbol_map=None, compiler_pass=None)¶
Constructs a single state circuit.
- Parameters:
- Returns:
Circuit
– A circuit that represent the state.
- get_circuit_no_ref(symbol_map=None)¶
Constructs a single state circuit without the reference state.
- Parameters:
- Returns:
Circuit
– A circuit that represent the referenceless state.
- get_numeric_representation(symbol_map=None, *, space=None, backend=None, dtype=complex)¶
Constructs a single numeric matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation.space (
Any
, default:None
) – Basis information to represent the object.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted.
- Returns:
Union
[_SupportsArray
[dtype
[Any
]],_NestedSequence
[_SupportsArray
[dtype
[Any
]]],bool
,int
,float
,complex
,str
,bytes
,_NestedSequence
[bool
|int
|float
|complex
|str
|bytes
]] – A matrix/vector representing the object.
- get_symbolic_representation(symbol_map=None, *, space=None)¶
Constructs a single symbolic matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
- Returns:
Expr
– A symbolic expression as a representation, which is a symbolic NDArray.
- make_hashable()¶
Returns a hashable representation of the ansatz object.
- Returns:
Hashable
– Hashable representation of ansatz.
- reference_qubit_state()¶
Create a symbolic
QubitState
representation of the reference state.- Returns:
QubitState
– Reference state as aQubitState
.
- reset_reference(reference)¶
Resetting the reference state of the ansatz in place.
Note
The number of qubits in the new reference has to match with the already existing reference state.
- Parameters:
reference (
Union
[int
,List
[Qubit
],List
[int
],QubitSpace
,QubitState
,Circuit
]) – Any reference that can be converted into a non-symbolic reference state circuit.- Returns:
Returns self with the modified reference.
- property state_circuit: Circuit¶
Returns the symbolic state circuit with a default compilation.
- property state_symbols: SymbolEnsemble¶
Returns the ordered parameter symbols this state uses.
- subs(symbol_map)¶
Returns a new objects with symbols substituted.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
]) – A mapping for substitution of free symbols.- Returns:
TypeVar
(SYMBOLICTYPE
, bound= Symbolic) – A copy of self with symbols substituted according to the provided map.
- symbol_substitution(symbol_map=None)¶
Performs an in-place symbol substation in the object.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – Dictionary or Callable mapping existing symbols to new symbols or values.
Note
While this is an in-place operation, consistency in free_symbols_ordered() is not guaranteed.
- Returns:
FermionSpaceStateExpChemicallyAware
–self
, with symbols substituted.
- to_CircuitAnsatz(symbol_map=None)¶
Cast the ansatz as CircuitAnsatz with optional symbol substitution.
- to_QubitState()¶
Create a symbolic
QubitState
representation of the ansatz.- Returns:
QubitState
– Ansatz as aQubitState
.
- unsympify(precision=15)¶
Unsympifies dictionary values.
Replaces symbolic expressions that do not contain free symbols with their corresponding numeric values.
- Parameters:
precision (
int
, default:15
) – The number of decimal digits of precision used for evaluation.partial – Set to True to allow partial unsympification where terms containing free symbols are present. By default, free symbols in any coefficient will cause an exception.
- Returns:
FermionSpaceStateExpChemicallyAware
– Updated instance ofFermionSpaceStateExpChemicallyAware
. This operation is in-place.
- class FermionSpaceAnsatzChemicallyAwareUCCSD(fermion_space, fermion_state, *args, **kwargs)¶
Bases:
FermionSpaceStateExpChemicallyAware
Chemically aware unitary coupled cluster with singles and doubles excitations (UCCSD).
Described in https://doi.org/10.1063/5.0144680.
Builds ansatz for a given
fermion_space
andfermion_state
. Circuit is synthesized in Jordan-Wigner encoding.- Parameters:
fermion_space (
Union
[FermionSpace
,int
]) – Spin orbital indices, occupations, and spatial orbitals indices.fermion_state (
FermionState
) – Spin orbital occupations.*args – Additional arguments offered by parent object.
**kwargs – Additional keyword arguments offered by parent object.
- circuit_resources(return_circuit=False)¶
Returns crude resource estimates for the implementation of unoptimized ansatz preparation circuit (e.g. gatecount).
This proceeds via decomposition of boxes in the state preparation circuit, followed by rebasing to the native TKET gateset (CX, TK1, Phase). Analysis of the circuit is performed on a copy – the original circuit stored in this object is left unmodified.
- Parameters:
return_circuit (
bool
, default:False
) – If set to True, the rebased circuit will be included as an additional element of the dictionary under the key “circuit”.- Returns:
dict
[str
,int
|Circuit
] – A dictionary of resource estimates of the ansatz circuit keyed by resource label (e.g. “depth”), optionally including the rebased circuit.
- default_pass()¶
Get the default compiler pass for the ansatz type.
- Returns:
BasePass
– A tket pass object.
- df_numeric(symbol_map=None, *, space=None, backend=None, dtype=complex, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_numeric_representation()
to generate a numeric vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_numeric_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_numeric_representation()
.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation. Passed toget_numeric_representation()
.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted. Passed toget_numeric_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- df_symbolic(symbol_map=None, *, space=None, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_symbolic_representation()
to generate a symbolic vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Symbolic coefficients are simplified before being added to dataframe.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_symbolic_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_symbolic_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- property fermion_operator_exponents: FermionOperatorList¶
Returns the list of exponents of the exponential product included in the ansatz.
- free_symbols()¶
Returns the free symbols in the object.
- Returns:
set
[Symbol
] – Unordered set of symbols.
- free_symbols_ordered()¶
Returns the free symbols in increasing lexicographic order.
- Returns:
SymbolEnsemble
– Ordered free symbols in object.
- get_circuit(symbol_map=None, compiler_pass=None)¶
Constructs a single state circuit.
- Parameters:
- Returns:
Circuit
– A circuit that represent the state.
- get_circuit_no_ref(symbol_map=None)¶
Constructs a single state circuit without the reference state.
- Parameters:
- Returns:
Circuit
– A circuit that represent the referenceless state.
- get_numeric_representation(symbol_map=None, *, space=None, backend=None, dtype=complex)¶
Constructs a single numeric matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation.space (
Any
, default:None
) – Basis information to represent the object.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted.
- Returns:
Union
[_SupportsArray
[dtype
[Any
]],_NestedSequence
[_SupportsArray
[dtype
[Any
]]],bool
,int
,float
,complex
,str
,bytes
,_NestedSequence
[bool
|int
|float
|complex
|str
|bytes
]] – A matrix/vector representing the object.
- get_symbolic_representation(symbol_map=None, *, space=None)¶
Constructs a single symbolic matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
- Returns:
Expr
– A symbolic expression as a representation, which is a symbolic NDArray.
- make_hashable()¶
Returns a hashable representation of the ansatz object.
- Returns:
Hashable
– Hashable representation of ansatz.
- reference_qubit_state()¶
Create a symbolic
QubitState
representation of the reference state.- Returns:
QubitState
– Reference state as aQubitState
.
- reset_reference(reference)¶
Resetting the reference state of the ansatz in place.
Note
The number of qubits in the new reference has to match with the already existing reference state.
- Parameters:
reference (
Union
[int
,List
[Qubit
],List
[int
],QubitSpace
,QubitState
,Circuit
]) – Any reference that can be converted into a non-symbolic reference state circuit.- Returns:
Returns self with the modified reference.
- property state_circuit: Circuit¶
Returns the symbolic state circuit with a default compilation.
- property state_symbols: SymbolEnsemble¶
Returns the ordered parameter symbols this state uses.
- subs(symbol_map)¶
Returns a new objects with symbols substituted.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
]) – A mapping for substitution of free symbols.- Returns:
TypeVar
(SYMBOLICTYPE
, bound= Symbolic) – A copy of self with symbols substituted according to the provided map.
- symbol_substitution(symbol_map=None)¶
Performs an in-place symbol substation in the object.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – Dictionary or Callable mapping existing symbols to new symbols or values.
Note
While this is an in-place operation, consistency in free_symbols_ordered() is not guaranteed.
- Returns:
FermionSpaceStateExpChemicallyAware
–self
, with symbols substituted.
- to_CircuitAnsatz(symbol_map=None)¶
Cast the ansatz as CircuitAnsatz with optional symbol substitution.
- to_QubitState()¶
Create a symbolic
QubitState
representation of the ansatz.- Returns:
QubitState
– Ansatz as aQubitState
.
- unsympify(precision=15)¶
Unsympifies dictionary values.
Replaces symbolic expressions that do not contain free symbols with their corresponding numeric values.
- Parameters:
precision (
int
, default:15
) – The number of decimal digits of precision used for evaluation.partial – Set to True to allow partial unsympification where terms containing free symbols are present. By default, free symbols in any coefficient will cause an exception.
- Returns:
FermionSpaceStateExpChemicallyAware
– Updated instance ofFermionSpaceStateExpChemicallyAware
. This operation is in-place.
- class FermionSpaceAnsatzkUpCCGD(fermion_space, fermion_state, k_input, qubit_mapping=QubitMappingJordanWigner(), *args, **kwargs)¶
Bases:
FermionSpaceStateExp
k-UpCCGD Ansatz.
Ansatz consisting of k factors of variationally independent unitary coupled cluster operators with generalized spin-paired doubles excitations, no singles (k-UpCCGD).
Here, generalized means occupied and virtual orbital subspaces are undistinguished, hence occupied-occupied and virtual-virtual excitations are included. See https://arxiv.org/abs/1810.02327 for more details.
- Parameters:
fermion_space (
Union
[FermionSpace
,int
]) – Spin orbital indices, occupations, and spatial orbitals indices.fermion_state (
FermionState
) – Spin orbital occupations.k_input (
int
) – Value of k in k-UpCC; results in k cluster operators.qubit_mapping (
QubitMapping
, default:QubitMappingJordanWigner()
) – How to map fock state operators and states to qubit operators and circuits.*args – Additional arguments offered by parent object.
**kwargs – Additional keyword arguments offered by parent object.
- circuit_resources(return_circuit=False)¶
Returns crude resource estimates for the implementation of unoptimized ansatz preparation circuit (e.g. gatecount).
This proceeds via decomposition of boxes in the state preparation circuit, followed by rebasing to the native TKET gateset (CX, TK1, Phase). Analysis of the circuit is performed on a copy – the original circuit stored in this object is left unmodified.
- Parameters:
return_circuit (
bool
, default:False
) – If set to True, the rebased circuit will be included as an additional element of the dictionary under the key “circuit”.- Returns:
dict
[str
,int
|Circuit
] – A dictionary of resource estimates of the ansatz circuit keyed by resource label (e.g. “depth”), optionally including the rebased circuit.
- default_pass()¶
Get the default compiler pass for the ansatz type.
- Returns:
A tket pass object.
- df_numeric(symbol_map=None, *, space=None, backend=None, dtype=complex, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_numeric_representation()
to generate a numeric vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_numeric_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_numeric_representation()
.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation. Passed toget_numeric_representation()
.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted. Passed toget_numeric_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- df_symbolic(symbol_map=None, *, space=None, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_symbolic_representation()
to generate a symbolic vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Symbolic coefficients are simplified before being added to dataframe.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_symbolic_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_symbolic_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- property exponents: QubitOperatorList¶
Returns the qubit operator exponents.
- property fermion_operator_exponents: FermionOperatorList¶
Returns the list of exponents of the exponential product included in the ansatz.
- free_symbols()¶
Returns the free symbols in the object.
- Returns:
Set
[Symbol
] – Unordered set of symbols.
- free_symbols_ordered()¶
Returns the free symbols in increasing lexicographic order.
- Returns:
SymbolEnsemble
– Ordered free symbols in object.
- get_circuit(symbol_map=None)¶
Constructs a single state circuit.
- get_circuit_no_ref(symbol_map=None)¶
Constructs a single state circuit without the reference state.
- Parameters:
- Returns:
Circuit
– A circuit that represent the referenceless state.
- get_numeric_representation(symbol_map=None, *, space=None, backend=None, dtype=complex)¶
Constructs a single numeric matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation.space (
Any
, default:None
) – Basis information to represent the object.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted.
- Returns:
Union
[_SupportsArray
[dtype
[Any
]],_NestedSequence
[_SupportsArray
[dtype
[Any
]]],bool
,int
,float
,complex
,str
,bytes
,_NestedSequence
[bool
|int
|float
|complex
|str
|bytes
]] – A matrix/vector representing the object.
- get_symbolic_representation(symbol_map=None, *, space=None)¶
Constructs a single symbolic matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
- Returns:
Expr
– A symbolic expression as a representation, which is a symbolic NDArray.
- make_hashable()¶
Returns a hashable representation of the ansatz object.
- Returns:
Hashable
– Hashable representation of ansatz.
- reference_qubit_state()¶
Create a symbolic
QubitState
representation of the reference state.- Returns:
QubitState
– Reference state as aQubitState
.
- reset_reference(reference)¶
Resetting the reference state of the ansatz in place.
Note
The number of qubits in the new reference has to match with the already existing reference state.
- Parameters:
reference (
Union
[int
,List
[Qubit
],List
[int
],QubitSpace
,QubitState
,Circuit
]) – Any reference that can be converted into a non-symbolic reference state circuit.- Returns:
Returns self with the modified reference.
- property state_circuit: Circuit¶
Returns the symbolic state circuit with a default compilation.
- property state_symbols: SymbolEnsemble¶
Returns the ordered parameter symbols this state uses.
- subs(symbol_map)¶
Returns a new objects with symbols substituted.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
]) – A mapping for substitution of free symbols.- Returns:
TypeVar
(SYMBOLICTYPE
, bound= Symbolic) – A copy of self with symbols substituted according to the provided map.
- symbol_substitution(symbol_map=None)¶
Performs an in-place symbol substation in the object.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – Dictionary or Callable mapping existing symbols to new symbols or values.
Note
While this is an in-place operation, consistency in free_symbols_ordered() is not guaranteed.
- Returns:
TrotterAnsatz
–self
, with symbols substituted.
- to_CircuitAnsatz(symbol_map=None)¶
Cast the ansatz as CircuitAnsatz with optional symbol substitution.
- to_QubitState(reverse=False)¶
Returns a
QubitState
object corresponding to the generated state.This proceeds through direct exponentiation of individual terms and application to the reference state. The ansatz must have been constructed with a QubitState reference.
Danger
In general, this will blow up exponentially.
- Parameters:
reverse (
bool
, default:False
) – set to True to reverse the order of term application- Returns:
The Ansatz state.
- to_QubitState_direct(reverse=False)¶
Returns a
QubitState
object corresponding to the generated state.This proceeds through direct exponentiation of individual terms and application to the reference state. The ansatz must have been constructed with a QubitState reference.
Danger
In general, this will blow up exponentially.
- Parameters:
reverse (
bool
, default:False
) – set to True to reverse the order of term application- Returns:
QubitState
– The Ansatz state.
- unsympify(precision=15)¶
Unsympifies exponents and coefficient values.
Replaces symbolic expressions that do not contain free symbols with their corresponding numeric values.
- Parameters:
precision (
int
, default:15
) – The number of decimal digits of precision used for evaluation.- Returns:
FermionSpaceStateExp
– Updated instance ofFermionSpaceStateExp
. This operation is in-place.
- class FermionSpaceAnsatzkUpCCGSD(fermion_space, fermion_state, k_input, qubit_mapping=QubitMappingJordanWigner(), *args, **kwargs)¶
Bases:
FermionSpaceStateExp
k-UpCCGSD ansatz.
Ansatz consisting of k factors of variationally independent unitary coupled cluster operators with fully generalized singles and generalized spin-paired doubles excitations (k-UpCCGSD).
Here, generalized means occupied and virtual orbital subspaces are undistinguished, hence occupied-occupied and virtual-virtual excitations are included. See https://arxiv.org/abs/1810.02327 for more details.
- Parameters:
fermion_space (
Union
[FermionSpace
,int
]) – Spin orbital indices, occupations, and spatial orbitals indices.fermion_state (
FermionState
) – Spin orbital occupations.k_input (
int
) – Value of k in k-UpCC; results in k cluster operators.qubit_mapping (
QubitMapping
, default:QubitMappingJordanWigner()
) – How to map fock state operators and states to qubit operators and circuits.*args – Additional arguments offered by parent object.
**kwargs – Additional keyword arguments offered by parent object.
- circuit_resources(return_circuit=False)¶
Returns crude resource estimates for the implementation of unoptimized ansatz preparation circuit (e.g. gatecount).
This proceeds via decomposition of boxes in the state preparation circuit, followed by rebasing to the native TKET gateset (CX, TK1, Phase). Analysis of the circuit is performed on a copy – the original circuit stored in this object is left unmodified.
- Parameters:
return_circuit (
bool
, default:False
) – If set to True, the rebased circuit will be included as an additional element of the dictionary under the key “circuit”.- Returns:
dict
[str
,int
|Circuit
] – A dictionary of resource estimates of the ansatz circuit keyed by resource label (e.g. “depth”), optionally including the rebased circuit.
- default_pass()¶
Get the default compiler pass for the ansatz type.
- Returns:
A tket pass object.
- df_numeric(symbol_map=None, *, space=None, backend=None, dtype=complex, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_numeric_representation()
to generate a numeric vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_numeric_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_numeric_representation()
.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation. Passed toget_numeric_representation()
.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted. Passed toget_numeric_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- df_symbolic(symbol_map=None, *, space=None, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_symbolic_representation()
to generate a symbolic vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Symbolic coefficients are simplified before being added to dataframe.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_symbolic_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_symbolic_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- property exponents: QubitOperatorList¶
Returns the qubit operator exponents.
- property fermion_operator_exponents: FermionOperatorList¶
Returns the list of exponents of the exponential product included in the ansatz.
- free_symbols()¶
Returns the free symbols in the object.
- Returns:
Set
[Symbol
] – Unordered set of symbols.
- free_symbols_ordered()¶
Returns the free symbols in increasing lexicographic order.
- Returns:
SymbolEnsemble
– Ordered free symbols in object.
- get_circuit(symbol_map=None)¶
Constructs a single state circuit.
- get_circuit_no_ref(symbol_map=None)¶
Constructs a single state circuit without the reference state.
- Parameters:
- Returns:
Circuit
– A circuit that represent the referenceless state.
- get_numeric_representation(symbol_map=None, *, space=None, backend=None, dtype=complex)¶
Constructs a single numeric matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation.space (
Any
, default:None
) – Basis information to represent the object.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted.
- Returns:
Union
[_SupportsArray
[dtype
[Any
]],_NestedSequence
[_SupportsArray
[dtype
[Any
]]],bool
,int
,float
,complex
,str
,bytes
,_NestedSequence
[bool
|int
|float
|complex
|str
|bytes
]] – A matrix/vector representing the object.
- get_symbolic_representation(symbol_map=None, *, space=None)¶
Constructs a single symbolic matrix/vector representation.
Danger
This is an exponentially exploding method!
- Parameters:
- Returns:
Expr
– A symbolic expression as a representation, which is a symbolic NDArray.
- make_hashable()¶
Returns a hashable representation of the ansatz object.
- Returns:
Hashable
– Hashable representation of ansatz.
- reference_qubit_state()¶
Create a symbolic
QubitState
representation of the reference state.- Returns:
QubitState
– Reference state as aQubitState
.
- reset_reference(reference)¶
Resetting the reference state of the ansatz in place.
Note
The number of qubits in the new reference has to match with the already existing reference state.
- Parameters:
reference (
Union
[int
,List
[Qubit
],List
[int
],QubitSpace
,QubitState
,Circuit
]) – Any reference that can be converted into a non-symbolic reference state circuit.- Returns:
Returns self with the modified reference.
- property state_circuit: Circuit¶
Returns the symbolic state circuit with a default compilation.
- property state_symbols: SymbolEnsemble¶
Returns the ordered parameter symbols this state uses.
- subs(symbol_map)¶
Returns a new objects with symbols substituted.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
]) – A mapping for substitution of free symbols.- Returns:
TypeVar
(SYMBOLICTYPE
, bound= Symbolic) – A copy of self with symbols substituted according to the provided map.
- symbol_substitution(symbol_map=None)¶
Performs an in-place symbol substation in the object.
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – Dictionary or Callable mapping existing symbols to new symbols or values.
Note
While this is an in-place operation, consistency in free_symbols_ordered() is not guaranteed.
- Returns:
TrotterAnsatz
–self
, with symbols substituted.
- to_CircuitAnsatz(symbol_map=None)¶
Cast the ansatz as CircuitAnsatz with optional symbol substitution.
- to_QubitState(reverse=False)¶
Returns a
QubitState
object corresponding to the generated state.This proceeds through direct exponentiation of individual terms and application to the reference state. The ansatz must have been constructed with a QubitState reference.
Danger
In general, this will blow up exponentially.
- Parameters:
reverse (
bool
, default:False
) – set to True to reverse the order of term application- Returns:
The Ansatz state.
- to_QubitState_direct(reverse=False)¶
Returns a
QubitState
object corresponding to the generated state.This proceeds through direct exponentiation of individual terms and application to the reference state. The ansatz must have been constructed with a QubitState reference.
Danger
In general, this will blow up exponentially.
- Parameters:
reverse (
bool
, default:False
) – set to True to reverse the order of term application- Returns:
QubitState
– The Ansatz state.
- unsympify(precision=15)¶
Unsympifies exponents and coefficient values.
Replaces symbolic expressions that do not contain free symbols with their corresponding numeric values.
- Parameters:
precision (
int
, default:15
) – The number of decimal digits of precision used for evaluation.- Returns:
FermionSpaceStateExp
– Updated instance ofFermionSpaceStateExp
. This operation is in-place.
- class FermionSpaceAnsatzkUpCCGSDSinglet(fermion_space, fermion_state, k_input, qubit_mapping=QubitMappingJordanWigner(), *args, **kwargs)¶
Bases:
FermionSpaceStateExp
k-UpCCGSDSinglet ansatz.
Ansatz consisting of k factors of variationally independent unitary coupled cluster operators with fully generalized singles and generalized spin paired doubles excitations.
Here, generalized means occupied and virtual orbital subspaces are undistinguished, hence occupied-occupied and virtual-virtual excitations are included. See https://arxiv.org/abs/1810.02327 for more details.
Adapted to singlets, so alpha-alpha and beta-beta single excitations between a given pair of spatial orbitals have the same parameter.
- Parameters:
fermion_space (
Union
[FermionSpace
,int
]) – Spin orbital indices, occupations, and spatial orbitals indices.fermion_state (
FermionState
) – Spin orbital occupations.k_input (
int
) – Value of k in k-UpCC; results in k cluster operators.qubit_mapping (
QubitMapping
, default:QubitMappingJordanWigner()
) – How to map fock state operators and states to qubit operators and circuits.*args – Additional arguments offered by parent object.
**kwargs – Additional keyword arguments offered by parent object.
- circuit_resources(return_circuit=False)¶
Returns crude resource estimates for the implementation of unoptimized ansatz preparation circuit (e.g. gatecount).
This proceeds via decomposition of boxes in the state preparation circuit, followed by rebasing to the native TKET gateset (CX, TK1, Phase). Analysis of the circuit is performed on a copy – the original circuit stored in this object is left unmodified.
- Parameters:
return_circuit (
bool
, default:False
) – If set to True, the rebased circuit will be included as an additional element of the dictionary under the key “circuit”.- Returns:
dict
[str
,int
|Circuit
] – A dictionary of resource estimates of the ansatz circuit keyed by resource label (e.g. “depth”), optionally including the rebased circuit.
- default_pass()¶
Get the default compiler pass for the ansatz type.
- Returns:
A tket pass object.
- df_numeric(symbol_map=None, *, space=None, backend=None, dtype=complex, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_numeric_representation()
to generate a numeric vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Danger
This is an exponentially exploding method!
- Parameters:
symbol_map (
Union
[Dict
[Symbol
,Expr
],Dict
[Symbol
,float
],Dict
[Symbol
,Union
[float
,complex
,Expr
]],Callable
[[Symbol
],Expr
],str
,None
], default:None
) – A symbol substitution map before constructing the representation. Passed toget_numeric_representation()
.space (
Any
, default:None
) – Basis information to represent the object. Passed toget_numeric_representation()
.backend (
Optional
[Backend
], default:None
) – An optional backend to use to build the representation. Passed toget_numeric_representation()
.dtype (
Union
[dtype
[Any
],None
,type
[Any
],_SupportsDType
[dtype
[Any
]],str
,tuple
[Any
,int
],tuple
[Any
,SupportsIndex
|Sequence
[SupportsIndex
]],list
[Any
],_DTypeDict
,tuple
[Any
,Any
]], default:complex
) – Specifies what dtype the return array should be converted. Passed toget_numeric_representation()
.tol (
float
, default:ANSATZ_ABSOLUTE_TOLERANCE
) – Absolute tolerance below which terms in the ansatz will be omitted from the dataframe. If negative, no terms are discarded.
- Returns:
DataFrame
– A dataframe representing the object.
- df_symbolic(symbol_map=None, *, space=None, tol=ANSATZ_ABSOLUTE_TOLERANCE)¶
Returns a
pandas.DataFrame
representation of the ansatz state.Uses
get_symbolic_representation()
to generate a symbolic vector for the ansatz state, and returns a dataframe with coefficients alongside their corresponding computational basis states.Assumes lexicographical ordering of basis states.
Symbolic coefficients are simplified before being added to dataframe.
Danger
This is an exponentially exploding method!