# Source code for pennylane.qchem.convert

```
# Copyright 2018-2022 Xanadu Quantum Technologies Inc.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
This module contains the functions for converting an external operator to a Pennylane operator.
"""
import warnings
from itertools import product
import numpy as np
# pylint: disable= import-outside-toplevel,no-member,too-many-function-args
import pennylane as qml
from pennylane.operation import Tensor, active_new_opmath
from pennylane.pauli import pauli_sentence
from pennylane.wires import Wires
def _process_wires(wires, n_wires=None):
r"""Checks and consolidates custom user wire mapping into a consistent, direction-free, ``Wires``
format. Used for converting between OpenFermion qubit numbering and PennyLane wire labels.
Since OpenFermion's qubit numbering is always consecutive int, simple iterable types such as
list, tuple, or Wires can be used to specify the 2-way `qubit index` <-> `wire label` mapping
with indices representing qubits. Dict can also be used as a mapping, but does not provide any
advantage over lists other than the ability to do partial mapping/permutation in the
`qubit index` -> `wire label` direction.
It is recommended to pass Wires/list/tuple `wires` since it's direction-free, i.e. the same
`wires` argument can be used to convert both ways between OpenFermion and PennyLane. Only use
dict for partial or unordered mapping.
Args:
wires (Wires, list, tuple, dict): User wire labels.
For types Wires, list, or tuple, each item in the iterable represents a wire label
corresponding to the qubit number equal to its index.
For type dict, only int-keyed dict (for qubit-to-wire conversion) or
consecutive-int-valued dict (for wire-to-qubit conversion) is accepted.
If None, will be set to consecutive int based on ``n_wires``.
n_wires (int): Number of wires used if known. If None, will be inferred from ``wires``; if
``wires`` is not available, will be set to 1.
Returns:
Wires: Cleaned wire mapping with indices corresponding to qubits and values
corresponding to wire labels.
**Example**
>>> # consec int wires if no wires mapping provided, ie. identity map: 0<->0, 1<->1, 2<->2
>>> _process_wires(None, 3)
<Wires = [0, 1, 2]>
>>> # List as mapping, qubit indices with wire label values: 0<->w0, 1<->w1, 2<->w2
>>> _process_wires(['w0','w1','w2'])
<Wires = ['w0', 'w1', 'w2']>
>>> # Wires as mapping, qubit indices with wire label values: 0<->w0, 1<->w1, 2<->w2
>>> _process_wires(Wires(['w0', 'w1', 'w2']))
<Wires = ['w0', 'w1', 'w2']>
>>> # Dict as partial mapping, int qubits keys to wire label values: 0->w0, 1 unchanged, 2->w2
>>> _process_wires({0:'w0',2:'w2'})
<Wires = ['w0', 1, 'w2']>
>>> # Dict as mapping, wires label keys to consec int qubit values: w2->2, w0->0, w1->1
>>> _process_wires({'w2':2, 'w0':0, 'w1':1})
<Wires = ['w0', 'w1', 'w2']>
"""
# infer from wires, or assume 1 if wires is not of accepted types.
if n_wires is None:
n_wires = len(wires) if isinstance(wires, (Wires, list, tuple, dict)) else 1
# defaults to no mapping.
if wires is None:
return Wires(range(n_wires))
if isinstance(wires, (Wires, list, tuple)):
# does not care about the tail if more wires are provided than n_wires.
wires = Wires(wires[:n_wires])
elif isinstance(wires, dict):
if all(isinstance(w, int) for w in wires.keys()):
# Assuming keys are taken from consecutive int wires. Allows for partial mapping.
n_wires = max(wires) + 1
labels = list(range(n_wires)) # used for completing potential partial mapping.
for k, v in wires.items():
if k < n_wires:
labels[k] = v
wires = Wires(labels)
elif set(range(n_wires)).issubset(set(wires.values())):
# Assuming values are consecutive int wires (up to n_wires, ignores the rest).
# Does NOT allow for partial mapping.
wires = {v: k for k, v in wires.items()} # flip for easy indexing
wires = Wires([wires[i] for i in range(n_wires)])
else:
raise ValueError("Expected only int-keyed or consecutive int-valued dict for `wires`")
else:
raise ValueError(
f"Expected type Wires, list, tuple, or dict for `wires`, got {type(wires)}"
)
if len(wires) != n_wires:
# check length consistency when all checking and cleaning are done.
raise ValueError(f"Length of `wires` ({len(wires)}) does not match `n_wires` ({n_wires})")
return wires
def _openfermion_to_pennylane(qubit_operator, wires=None):
r"""Convert OpenFermion ``QubitOperator`` to a 2-tuple of coefficients and
PennyLane Pauli observables.
Args:
qubit_operator (QubitOperator): fermionic-to-qubit transformed operator in terms of
Pauli matrices
wires (Wires, list, tuple, dict): Custom wire mapping used to convert the qubit operator
to an observable terms measurable in a PennyLane ansatz.
For types Wires/list/tuple, each item in the iterable represents a wire label
corresponding to the qubit number equal to its index.
For type dict, only int-keyed dict (for qubit-to-wire conversion) is accepted.
If None, will use identity map (e.g. 0->0, 1->1, ...).
Returns:
tuple[array[float], Iterable[pennylane.operation.Operator]]: coefficients and their
corresponding PennyLane observables in the Pauli basis
**Example**
>>> q_op = 0.1 * QubitOperator('X0') + 0.2 * QubitOperator('Y0 Z2')
>>> q_op
0.1 [X0] +
0.2 [Y0 Z2]
>>> _openfermion_to_pennylane(q_op, wires=['w0','w1','w2','extra_wire'])
(tensor([0.1, 0.2], requires_grad=False), [X('w0'), Y('w0') @ Z('w2')])
If the new op-math is active, the list of operators will be cast as :class:`~.Prod` instances instead of
:class:`~.Tensor` instances when appropriate.
"""
n_wires = (
1 + max(max(i for i, _ in t) if t else 1 for t in qubit_operator.terms)
if qubit_operator.terms
else 1
)
wires = _process_wires(wires, n_wires=n_wires)
if not qubit_operator.terms: # added since can't unpack empty zip to (coeffs, ops) below
return np.array([0.0]), [qml.Identity(wires[0])]
xyz2pauli = {"X": qml.X, "Y": qml.Y, "Z": qml.Z}
def _get_op(term, wires):
"""A function to compute the PL operator associated with the term string."""
if len(term) > 1:
if active_new_opmath():
return qml.prod(*[xyz2pauli[op[1]](wires=wires[op[0]]) for op in term])
return Tensor(*[xyz2pauli[op[1]](wires=wires[op[0]]) for op in term])
if len(term) == 1:
return xyz2pauli[term[0][1]](wires=wires[term[0][0]])
return qml.Identity(wires[0])
coeffs, ops = zip(
*[(coef, _get_op(term, wires)) for term, coef in qubit_operator.terms.items()]
# example term: ((0,'X'), (2,'Z'), (3,'Y'))
)
return np.array(coeffs).real, list(ops)
def _ps_to_coeff_term(ps, wire_order):
"""Convert a non-empty pauli sentence to a list of coeffs and terms."""
ops_str = []
pws, coeffs = zip(*ps.items())
for pw in pws:
if len(pw) == 0:
ops_str.append("")
continue
wires, ops = zip(*pw.items())
ops_str.append(" ".join([f"{op}{wire_order.index(wire)}" for op, wire in zip(ops, wires)]))
return coeffs, ops_str
def _pennylane_to_openfermion(coeffs, ops, wires=None):
r"""Convert a 2-tuple of complex coefficients and PennyLane operations to
OpenFermion ``QubitOperator``.
Args:
coeffs (array[complex]):
coefficients for each observable, same length as ops
ops (Iterable[pennylane.operation.Operations]): list of PennyLane operations that
have a valid PauliSentence representation.
wires (Wires, list, tuple, dict): Custom wire mapping used to convert to qubit operator
from an observable terms measurable in a PennyLane ansatz.
For types Wires/list/tuple, each item in the iterable represents a wire label
corresponding to the qubit number equal to its index.
For type dict, only consecutive-int-valued dict (for wire-to-qubit conversion) is
accepted. If None, will map sorted wires from all `ops` to consecutive int.
Returns:
QubitOperator: an instance of OpenFermion's ``QubitOperator``.
**Example**
>>> coeffs = np.array([0.1, 0.2, 0.3, 0.4])
>>> ops = [
... qml.operation.Tensor(qml.X('w0')),
... qml.operation.Tensor(qml.Y('w0'), qml.Z('w2')),
... qml.sum(qml.Z('w0'), qml.s_prod(-0.5, qml.X('w0'))),
... qml.prod(qml.X('w0'), qml.Z('w1')),
... ]
>>> _pennylane_to_openfermion(coeffs, ops, wires=Wires(['w0', 'w1', 'w2']))
(-0.05+0j) [X0] +
(0.4+0j) [X0 Z1] +
(0.2+0j) [Y0 Z2] +
(0.3+0j) [Z0]
"""
try:
import openfermion
except ImportError as Error:
raise ImportError(
"This feature requires openfermion. "
"It can be installed with: pip install openfermion"
) from Error
all_wires = Wires.all_wires([op.wires for op in ops], sort=True)
if wires is not None:
qubit_indexed_wires = _process_wires(
wires,
)
if not set(all_wires).issubset(set(qubit_indexed_wires)):
raise ValueError("Supplied `wires` does not cover all wires defined in `ops`.")
else:
qubit_indexed_wires = all_wires
q_op = openfermion.QubitOperator()
for coeff, op in zip(coeffs, ops):
if isinstance(op, Tensor):
try:
ps = pauli_sentence(op)
except ValueError as e:
raise ValueError(
f"Expected a Pennylane operator with a valid Pauli word representation, "
f"but got {op}."
) from e
elif (ps := op.pauli_rep) is None:
raise ValueError(
f"Expected a Pennylane operator with a valid Pauli word representation, but got {op}."
)
if len(ps) > 0:
sub_coeffs, op_strs = _ps_to_coeff_term(ps, wire_order=qubit_indexed_wires)
for c, op_str in zip(sub_coeffs, op_strs):
# This is how one makes QubitOperator in OpenFermion
q_op += complex(coeff * c) * openfermion.QubitOperator(op_str)
return q_op
def _openfermion_pennylane_equivalent(
openfermion_qubit_operator, pennylane_qubit_operator, wires=None
):
r"""Check equivalence between OpenFermion :class:`~.QubitOperator` and Pennylane VQE
``Hamiltonian`` (Tensor product of Pauli matrices).
Equality is based on OpenFermion :class:`~.QubitOperator`'s equality.
Args:
openfermion_qubit_operator (QubitOperator): OpenFermion qubit operator represented as
a Pauli summation
pennylane_qubit_operator (pennylane.Hamiltonian): PennyLane
Hamiltonian object
wires (Wires, list, tuple, dict): Custom wire mapping used to convert to qubit operator
from an observable terms measurable in a PennyLane ansatz.
For types Wires/list/tuple, each item in the iterable represents a wire label
corresponding to the qubit number equal to its index.
For type dict, only int-keyed dict (for qubit-to-wire conversion) is accepted.
If None, will map sorted wires from all Pennylane terms to consecutive int.
Returns:
(bool): True if equivalent
"""
coeffs, ops = pennylane_qubit_operator.terms()
return openfermion_qubit_operator == _pennylane_to_openfermion(coeffs, ops, wires=wires)
[docs]def import_operator(qubit_observable, format="openfermion", wires=None, tol=1e010):
r"""Convert an external operator to a PennyLane operator.
We currently support `OpenFermion <https://quantumai.google/openfermion>`__ operators: the function accepts most types of
OpenFermion qubit operators, such as those corresponding to Pauli words and sums of Pauli words.
Args:
qubit_observable: external qubit operator that will be converted
format (str): the format of the operator object to convert from
wires (.Wires, list, tuple, dict): Custom wire mapping used to convert the external qubit
operator to a PennyLane operator.
For types ``Wires``/list/tuple, each item in the iterable represents a wire label
for the corresponding qubit index.
For type dict, only int-keyed dictionaries (for qubit-to-wire conversion) are accepted.
If ``None``, the identity map (e.g., ``0->0, 1->1, ...``) will be used.
tol (float): Tolerance in `machine epsilon <https://numpy.org/doc/stable/reference/generated/numpy.real_if_close.html>`_
for the imaginary part of the coefficients in ``qubit_observable``.
Coefficients with imaginary part less than :math:`(2.22 \cdot 10^{-16}) \cdot \text{tol}` are considered to be real.
Returns:
(.Operator): PennyLane operator representing any operator expressed as linear combinations of
Pauli words, e.g.,
:math:`\sum_{k=0}^{N-1} c_k O_k`
**Example**
>>> assert qml.operation.active_new_opmath() == True
>>> h_pl = import_operator(h_of, format='openfermion')
>>> print(h_pl)
(-0.0548 * X(0 @ X(1) @ Y(2) @ Y(3))) + (0.14297 * Z(0 @ Z(1)))
If the new op-math is deactivated, a :class:`~Hamiltonian` is returned instead.
>>> assert qml.operation.active_new_opmath() == False
>>> from openfermion import QubitOperator
>>> h_of = QubitOperator('X0 X1 Y2 Y3', -0.0548) + QubitOperator('Z0 Z1', 0.14297)
>>> h_pl = import_operator(h_of, format='openfermion')
>>> print(h_pl)
(0.14297) [Z0 Z1]
+ (-0.0548) [X0 X1 Y2 Y3]
"""
if format not in ["openfermion"]:
raise TypeError(f"Converter does not exist for {format} format.")
coeffs = np.array([np.real_if_close(coef, tol=tol) for coef in qubit_observable.terms.values()])
if any(np.iscomplex(coeffs)):
warnings.warn(
f"The coefficients entering the QubitOperator must be real;"
f" got complex coefficients in the operator"
f" {list(coeffs[np.iscomplex(coeffs)])}"
)
if active_new_opmath():
return qml.dot(*_openfermion_to_pennylane(qubit_observable, wires=wires))
return qml.Hamiltonian(*_openfermion_to_pennylane(qubit_observable, wires=wires))
def _excitations(electrons, orbitals):
r"""Generate all possible single and double excitations from a Hartree-Fock reference state.
This function is a more performant version of ``qchem.excitations``, where the order of the
generated excitations is consistent with PySCF.
Single and double excitations can be generated by acting with the operators
:math:`\hat T_1` and :math:`\hat T_2` on the Hartree-Fock reference state:
.. math::
&& \hat{T}_1 = \sum_{p \in \mathrm{occ} \\ q \in \mathrm{unocc}}
\hat{c}_q^\dagger \hat{c}_p \\
&& \hat{T}_2 = \sum_{p>q \in \mathrm{occ} \\ r>s \in
\mathrm{unocc}} \hat{c}_r^\dagger \hat{c}_s^\dagger \hat{c}_p \hat{c}_q.
In the equations above the indices :math:`p, q, r, s` run over the
occupied (occ) and unoccupied (unocc) *spin* orbitals and :math:`\hat c` and
:math:`\hat c^\dagger` are the electron annihilation and creation operators,
respectively.
Args:
electrons (int): number of electrons
orbitals (int): number of spin orbitals
Returns:
tuple(list, list): lists with the indices of the spin orbitals involved in the excitations
**Example**
>>> electrons = 2
>>> orbitals = 4
>>> _excitations(electrons, orbitals)
([[0, 2], [0, 3], [1, 2], [1, 3]], [[0, 1, 2, 3]])
"""
singles_p, singles_q = [], []
doubles_pq, doubles_rs = [], []
for i in range(electrons):
singles_p += [i]
doubles_pq += [[k, i] for k in range(i)]
for j in range(electrons, orbitals):
singles_q += [j]
doubles_rs += [[k, j] for k in range(electrons, j)]
singles = [[p] + [q] for p in singles_p for q in singles_q]
doubles = [pq + rs for pq in doubles_pq for rs in doubles_rs]
return singles, doubles
def _excited_configurations(electrons, orbitals, excitation):
r"""Generate excited configurations from a Hartree-Fock reference state.
This function generates excited configurations in the form of integers representing a binary
string, e.g., :math:`|1 1 0 1 0 0 \rangle` is represented by :math:`int('110100', 2) = 52`.
The excited configurations are generated from a Hartree-Fock (HF) reference state. The HF state
is assumed to have the form :math:`|1 1 ...1 0 ... 0 0 \rangle` where the number of :math:`1`
and :math:`0` elements are the number of occupied and unoccupied spin orbitals, respectively.
The string representation of the state is obtained by converting the occupation-number vector to
a string, e.g., ``111000`` to represent :math:`|1 1 1 0 0 0 \rangle.
Each excited configuration has a sign, :math:`+1` or :math:`-1`, that is obtained by reordering
the creation operators.
Args:
electrons (int): number of electrons
orbitals (int): number of spin orbitals
excitation (int): number of excited electrons
Returns:
tuple(list, list): lists of excited configurations and signs obtained by reordering the
creation operators
**Example**
>>> electrons = 3
>>> orbitals = 5
>>> excitation = 2
>>> _excited_configurations(electrons, orbitals, excitation)
([28, 26, 25], [1, -1, 1])
"""
if excitation not in [1, 2]:
raise ValueError(
"Only single (excitation = 1) and double (excitation = 2) excitations are supported."
)
hf_state = qml.qchem.hf_state(electrons, orbitals)
singles, doubles = _excitations(electrons, orbitals)
states, signs = [], []
if excitation == 1:
for s in singles:
state = hf_state.copy()
state[s] = state[[s[1], s[0]]] # apply single excitation
states += [state]
signs.append((-1) ** len(range(s[0], electrons - 1)))
if excitation == 2:
for d in doubles:
state = hf_state.copy()
state[d] = state[[d[2], d[3], d[0], d[1]]] # apply double excitation
states += [state]
order_pq = len(range(d[0], electrons - 1))
order_rs = len(range(d[1], electrons - 1))
signs.append((-1) ** (order_pq + order_rs + 1))
states_str = ["".join([str(i) for i in state]) for state in states]
states_int = [int(state[::-1], 2) for state in states_str]
return states_int, signs
[docs]def import_state(solver, tol=1e-15):
r"""Convert an external wavefunction to a state vector.
The sources of wavefunctions that are currently accepted are listed below.
* The PySCF library (the restricted and unrestricted CISD/CCSD
methods are supported). The `solver` argument is then the associated PySCF CISD/CCSD Solver object.
* The library Dice implementing the SHCI method. The `solver` argument is then the tuple(list[str], array[float]) of Slater determinants and their coefficients.
* The library Block2 implementing the DMRG method. The `solver` argument is then the tuple(list[int], array[float]) of Slater determinants and their coefficients.
Args:
solver: external wavefunction object
tol (float): the tolerance for discarding Slater determinants based on their coefficients
Raises:
ValueError: if external object type is not supported
Returns:
array: normalized state vector of length :math:`2^M`, where :math:`M` is the number of spin orbitals
**Example**
>>> from pyscf import gto, scf, ci
>>> mol = gto.M(atom=[['H', (0, 0, 0)], ['H', (0,0,0.71)]], basis='sto6g')
>>> myhf = scf.UHF(mol).run()
>>> myci = ci.UCISD(myhf).run()
>>> wf_cisd = qml.qchem.import_state(myci, tol=1e-1)
>>> print(wf_cisd)
[ 0. +0.j 0. +0.j 0. +0.j 0.1066467 +0.j
0. +0.j 0. +0.j 0. +0.j 0. +0.j
0. +0.j 0. +0.j 0. +0.j 0. +0.j
-0.99429698+0.j 0. +0.j 0. +0.j 0. +0.j]
"""
method = str(solver.__str__)
if "CISD" in method and "UCISD" not in method:
wf_dict = _rcisd_state(solver, tol=tol)
elif "UCISD" in method:
wf_dict = _ucisd_state(solver, tol=tol)
elif "CCSD" in method and "UCCSD" not in method:
wf_dict = _rccsd_state(solver, tol=tol)
elif "UCCSD" in method:
wf_dict = _uccsd_state(solver, tol=tol)
elif "tuple" in method and len(solver) == 2:
if isinstance(solver[0][0], str):
wf_dict = _shci_state(solver, tol=tol)
elif isinstance(solver[0][0][0], int):
wf_dict = _dmrg_state(solver, tol=tol)
else:
raise ValueError(
"For tuple input, the supported objects are"
" tuple(list[str], array[float]) for SHCI calculations with Dice library and "
"tuple(list[int], array[float]) for DMRG calculations with the Block2 library."
)
else:
raise ValueError(
"The supported objects are RCISD, UCISD, RCCSD, and UCCSD for restricted and"
" unrestricted configuration interaction and coupled cluster calculations, and"
" tuple(list[str], array[float]) for SHCI calculations with Dice library and "
"tuple(list[int], array[float]) for DMRG calculations with the Block2 library."
)
if "tuple" in method:
wf = _wfdict_to_statevector(wf_dict, len(solver[0][0]))
else:
wf = _wfdict_to_statevector(wf_dict, solver.mol.nao)
return wf
def _wfdict_to_statevector(fcimatr_dict, norbs):
r"""Convert a wavefunction in sparse dictionary format to a PennyLane statevector.
In the sparse dictionary format, the keys ``(int_a, int_b)`` are integers whose binary
representation shows the Fock occupation vector for alpha and beta electrons and values are the
CI coefficients.
Args:
fcimatr_dict (dict[tuple(int,int),float]): the sparse dictionary format of a wavefunction
norbs (int): number of molecular orbitals
Returns:
array: normalized state vector of length :math:`2^M`, where :math:`M` is the number of spin orbitals
"""
statevector = np.zeros(2 ** (2 * norbs), dtype=complex)
for (int_a, int_b), coeff in fcimatr_dict.items():
bin_a = bin(int_a)[2:][::-1]
bin_b = bin(int_b)[2:][::-1]
bin_a += "0" * (norbs - len(bin_a))
bin_b += "0" * (norbs - len(bin_b))
bin_ab = "".join(i + j for i, j in zip(bin_a, bin_b))
statevector[int(bin_ab, 2)] += coeff
statevector = statevector / np.sqrt(np.sum(statevector**2))
return statevector
def _rcisd_state(cisd_solver, tol=1e-15):
r"""Construct a wavefunction from PySCF's ``RCISD`` solver object.
The generated wavefunction is a dictionary where the keys represent a configuration, which
corresponds to a Slater determinant, and the values are the CI coefficients of the Slater
determinant. Each dictionary key is a tuple of two integers. The binary representation of these
integers correspond to a specific configuration: the first number represents the
configuration of the alpha electrons and the second number represents the configuration of the
beta electrons. For instance, the Hartree-Fock state :math:`|1 1 0 0 \rangle` will be
represented by the flipped binary string ``0011`` which is split to ``01`` and ``01`` for
the alpha and beta electrons. The integer corresponding to ``01`` is ``1`` and the dictionary
representation of the Hartree-Fock state will be ``{(1, 1): 1.0}``. The dictionary
representation of a state with ``0.99`` contribution from the Hartree-Fock state and ``0.01``
contribution from the doubly-excited state, i.e., :math:`|0 0 1 1 \rangle`, will be
``{(1, 1): 0.99, (2, 2): 0.01}``.
Args:
cisd_solver (PySCF CISD Class instance): the class object representing the CISD calculation in PySCF
tol (float): the tolerance for discarding Slater determinants based on their coefficients
Returns:
fcimatr_dict (dict[tuple(int,int),float]): dictionary of the form ``{(int_a, int_b) :coeff}``, with integers ``int_a, int_b``
having binary representation corresponding to the Fock occupation vector in alpha and beta
spin sectors, respectively, and coeff being the CI coefficients of those configurations
**Example**
>>> from pyscf import gto, scf, ci
>>> mol = gto.M(atom=[['H', (0, 0, 0)], ['H', (0,0,0.71)]], basis='sto6g', symmetry='d2h')
>>> myhf = scf.RHF(mol).run()
>>> myci = ci.CISD(myhf).run()
>>> wf_cisd = _rcisd_state(myci, tol=1e-1)
>>> print(wf_cisd)
{(1, 1): -0.9942969785398775, (2, 2): 0.10664669927602162}
"""
mol = cisd_solver.mol
cisdvec = cisd_solver.ci
norb = mol.nao
nelec = mol.nelectron
nocc, nvir = nelec // 2, norb - nelec // 2
c0, c1, c2 = (
cisdvec[0],
cisdvec[1 : nocc * nvir + 1],
cisdvec[nocc * nvir + 1 :].reshape(nocc, nocc, nvir, nvir),
)
c2ab = c2.transpose(0, 2, 1, 3).reshape(nocc * nvir, -1)
# numbers representing the Hartree-Fock vector, e.g., bin(ref_a)[::-1] = 1111...10...0
ref_a = int(2**nocc - 1)
ref_b = ref_a
fcimatr_dict = dict(zip(list(zip([ref_a], [ref_b])), [c0]))
# alpha -> alpha excitations
c1a_configs, c1a_signs = _excited_configurations(nocc, norb, 1)
fcimatr_dict.update(
dict(zip(list(zip(c1a_configs, [ref_b] * len(c1a_configs))), c1 * c1a_signs))
)
# beta -> beta excitations
fcimatr_dict.update(
dict(zip(list(zip([ref_a] * len(c1a_configs), c1a_configs)), c1 * c1a_signs))
)
# check if double excitations within one spin sector (aa->aa and bb->bb) are possible
if nocc > 1 and nvir > 1:
# get rid of excitations from identical orbitals, double-count the allowed ones
c2_tr = c2 - c2.transpose(1, 0, 2, 3)
# select only unique excitations, via lower triangle of matrix (already double-counted)
ooidx, vvidx = np.tril_indices(nocc, -1), np.tril_indices(nvir, -1)
c2aa = c2_tr[ooidx][:, vvidx[0], vvidx[1]].ravel()
# alpha, alpha -> alpha, alpha excitations
c2aa_configs, c2aa_signs = _excited_configurations(nocc, norb, 2)
fcimatr_dict.update(
dict(zip(list(zip(c2aa_configs, [ref_b] * len(c2aa_configs))), c2aa * c2aa_signs))
)
# beta, beta -> beta, beta excitations
fcimatr_dict.update(
dict(zip(list(zip([ref_a] * len(c2aa_configs), c2aa_configs)), c2aa * c2aa_signs))
)
# alpha, beta -> alpha, beta excitations
# generate all possible pairwise combinations of _single_ excitations of alpha and beta sectors
fcimatr_dict.update(
dict(
zip(
list(product(c1a_configs, c1a_configs)),
np.einsum("i,j,ij->ij", c1a_signs, c1a_signs, c2ab, optimize=True).ravel(),
)
)
)
# filter based on tolerance cutoff
fcimatr_dict = {key: value for key, value in fcimatr_dict.items() if abs(value) > tol}
# convert sign parity from chemist to physicist convention (interleaving spin operators
# rather than commuting all spin-up operators to the left)
fcimatr_dict = _sign_chem_to_phys(fcimatr_dict, norb)
return fcimatr_dict
def _ucisd_state(cisd_solver, tol=1e-15):
r"""Construct a wavefunction from PySCF's ``UCISD`` solver object.
The generated wavefunction is a dictionary where the keys represent a configuration, which
corresponds to a Slater determinant, and the values are the CI coefficients of the Slater
determinant. Each dictionary key is a tuple of two integers. The binary representation of these
integers correspond to a specific configuration: the first number represents the
configuration of the alpha electrons and the second number represents the configuration of the
beta electrons. For instance, the Hartree-Fock state :math:`|1 1 0 0 \rangle` will be
represented by the flipped binary string ``0011`` which is split to ``01`` and ``01`` for
the alpha and beta electrons. The integer corresponding to ``01`` is ``1`` and the dictionary
representation of the Hartree-Fock state will be ``{(1, 1): 1.0}``. The dictionary
representation of a state with `0.99` contribution from the Hartree-Fock state and ``0.01``
contribution from the doubly-excited state, i.e., :math:`|0 0 1 1 \rangle`, will be
``{(1, 1): 0.99, (2, 2): 0.01}``.
Args:
cisd_solver (PySCF UCISD Class instance): the class object representing the UCISD calculation in PySCF
tol (float): the tolerance for discarding Slater determinants based on their coefficients
Returns:
fcimatr_dict (dict[tuple(int,int),float]): dictionary of the form ``{(int_a, int_b) :coeff}``, with integers ``int_a, int_b``
having binary representation corresponding to the Fock occupation vector in alpha and beta
spin sectors, respectively, and coeff being the CI coefficients of those configurations
**Example**
>>> from pyscf import gto, scf, ci
>>> mol = gto.M(atom=[['H', (0, 0, 0)], ['H', (0,0,0.71)]], basis='sto6g', symmetry='d2h')
>>> myhf = scf.UHF(mol).run()
>>> myci = ci.UCISD(myhf).run()
>>> wf_cisd = _ucisd_state(myci, tol=1e-1)
>>> print(wf_cisd)
{(1, 1): -0.9942969785398778, (2, 2): 0.10664669927602159}
"""
mol = cisd_solver.mol
cisdvec = cisd_solver.ci
norb = mol.nao
nelec = mol.nelectron
nelec_a = int((nelec + mol.spin) / 2)
nelec_b = int((nelec - mol.spin) / 2)
nvir_a, nvir_b = norb - nelec_a, norb - nelec_b
size_a, size_b = nelec_a * nvir_a, nelec_b * nvir_b
size_aa = int(nelec_a * (nelec_a - 1) / 2) * int(nvir_a * (nvir_a - 1) / 2)
size_bb = int(nelec_b * (nelec_b - 1) / 2) * int(nvir_b * (nvir_b - 1) / 2)
size_ab = size_a * size_b
cumul = np.cumsum([0, 1, size_a, size_b, size_ab, size_aa, size_bb])
c0, c1a, c1b, c2ab, c2aa, c2bb = [
cisdvec[cumul[idx] : cumul[idx + 1]] for idx in range(len(cumul) - 1)
]
c2ab = (
c2ab.reshape(nelec_a, nelec_b, nvir_a, nvir_b)
.transpose(0, 2, 1, 3)
.reshape(nelec_a * nvir_a, -1)
)
# numbers representing the Hartree-Fock vector, e.g., bin(ref_a)[::-1] = 1111...10...0
ref_a = int(2**nelec_a - 1)
ref_b = int(2**nelec_b - 1)
fcimatr_dict = dict(zip(list(zip([ref_a], [ref_b])), c0))
# alpha -> alpha excitations
c1a_configs, c1a_signs = _excited_configurations(nelec_a, norb, 1)
fcimatr_dict.update(dict(zip(list(zip(c1a_configs, [ref_b] * size_a)), c1a * c1a_signs)))
# beta -> beta excitations
c1b_configs, c1b_signs = _excited_configurations(nelec_b, norb, 1)
fcimatr_dict.update(dict(zip(list(zip([ref_a] * size_b, c1b_configs)), c1b * c1b_signs)))
# alpha, alpha -> alpha, alpha excitations
c2aa_configs, c2aa_signs = _excited_configurations(nelec_a, norb, 2)
fcimatr_dict.update(dict(zip(list(zip(c2aa_configs, [ref_b] * size_aa)), c2aa * c2aa_signs)))
# alpha, beta -> alpha, beta excitations
fcimatr_dict.update(
dict(
zip(
list(product(c1a_configs, c1b_configs)),
np.einsum("i,j,ij->ij", c1a_signs, c1b_signs, c2ab, optimize=True).ravel(),
)
)
)
# beta, beta -> beta, beta excitations
c2bb_configs, c2bb_signs = _excited_configurations(nelec_b, norb, 2)
fcimatr_dict.update(dict(zip(list(zip([ref_a] * size_bb, c2bb_configs)), c2bb * c2bb_signs)))
# filter based on tolerance cutoff
fcimatr_dict = {key: value for key, value in fcimatr_dict.items() if abs(value) > tol}
# convert sign parity from chemist to physicist convention (interleaving spin operators
# rather than commuting all spin-up operators to the left)
fcimatr_dict = _sign_chem_to_phys(fcimatr_dict, norb)
return fcimatr_dict
def _rccsd_state(ccsd_solver, tol=1e-15):
r"""Construct a wavefunction from PySCF's ``RCCSD`` Solver object.
The generated wavefunction is a dictionary where the keys represent a configuration, which
corresponds to a Slater determinant, and the values are the CI coefficients of the Slater
determinant. Each dictionary key is a tuple of two integers. The binary representation of these
integers correspond to a specific configuration: the first number represents the
configuration of the alpha electrons and the second number represents the configuration of the
beta electrons. For instance, the Hartree-Fock state :math:`|1 1 0 0 \rangle` will be
represented by the flipped binary string ``0011` which is split to ``01`` and ``01`` for
the alpha and beta electrons. The integer corresponding to ``01`` is ``1`` and the dictionary
representation of the Hartree-Fock state will be ``{(1, 1): 1.0}``. The dictionary
representation of a state with ``0.99`` contribution from the Hartree-Fock state and ``0.01``
contribution from the doubly-excited state, i.e., :math:`|0 0 1 1 \rangle`, will be
``{(1, 1): 0.99, (2, 2): 0.01}``.
In the current version, the exponential ansatz :math:`\exp(\hat{T}_1 + \hat{T}_2) \ket{\text{HF}}`
is expanded to second order, with only single and double excitation terms collected and kept.
In the future this will be amended to also collect terms from higher order. The expansion gives
.. math::
\exp(\hat{T}_1 + \hat{T}_2) \ket{\text{HF}} = \left[ 1 + \hat{T}_1 +
\left( \hat{T}_2 + 0.5 * \hat{T}_1^2 \right) \right] \ket{\text{HF}}
The coefficients in this expansion are the CI coefficients used to build the wavefunction
representation.
Args:
ccsd_solver (PySCF RCCSD Class instance): the class object representing the RCCSD calculation in PySCF
tol (float): the tolerance for discarding Slater determinants with small coefficients
Returns:
fcimatr_dict (dict[tuple(int,int),float]): dictionary of the form ``{(int_a, int_b) :coeff}``, with integers ``int_a, int_b``
having binary represention corresponding to the Fock occupation vector in alpha and beta
spin sectors, respectively, and coeff being the CI coefficients of those configurations
**Example**
>>> from pyscf import gto, scf, cc
>>> mol = gto.M(atom=[['Li', (0, 0, 0)], ['Li', (0,0,0.71)]], basis='sto6g', symmetry="d2h")
>>> myhf = scf.RHF(mol).run()
>>> mycc = cc.CCSD(myhf).run()
>>> wf_ccsd = _rccsd_state(mycc, tol=1e-1)
>>> print(wf_ccsd)
{(7, 7): -0.8886969878256522, (11, 11): 0.30584590248164206,
(19, 19): 0.30584590248164145, (35, 35): 0.14507552651170982}
"""
mol = ccsd_solver.mol
norb = mol.nao
nelec = mol.nelectron
nelec_a = int((nelec + mol.spin) / 2)
nelec_b = int((nelec - mol.spin) / 2)
nvir_a, nvir_b = norb - nelec_a, norb - nelec_b
# build the full, unrestricted representation of the coupled cluster amplitudes
t1a = ccsd_solver.t1
t1b = t1a
t2aa = ccsd_solver.t2 - ccsd_solver.t2.transpose(1, 0, 2, 3)
t2ab = ccsd_solver.t2.transpose(0, 2, 1, 3)
t2bb = t2aa
# add in the disconnected part ( + 0.5 T_1^2) of double excitations
t2aa = t2aa - 0.5 * np.kron(t1a, t1a).reshape(nelec_a, nvir_a, nelec_a, nvir_a).transpose(
0, 2, 1, 3
)
t2bb = t2bb - 0.5 * np.kron(t1b, t1b).reshape(nelec_b, nvir_b, nelec_b, nvir_b).transpose(
0, 2, 1, 3
)
# align the entries with how the excitations are ordered when generated by _excited_configurations()
t2ab = t2ab - 0.5 * np.kron(t1a, t1b).reshape(nelec_a, nvir_a, nelec_b, nvir_b)
# numbers representing the Hartree-Fock vector, e.g., bin(ref_a)[::-1] = 1111...10...0
ref_a = int(2**nelec_a - 1)
ref_b = int(2**nelec_b - 1)
fcimatr_dict = dict(zip(list(zip([ref_a], [ref_b])), [1.0]))
# alpha -> alpha excitations
t1a_configs, t1a_signs = _excited_configurations(nelec_a, norb, 1)
fcimatr_dict.update(
dict(zip(list(zip(t1a_configs, [ref_b] * len(t1a_configs))), t1a.ravel() * t1a_signs))
)
# beta -> beta excitations
t1b_configs, t1b_signs = _excited_configurations(nelec_b, norb, 1)
fcimatr_dict.update(
dict(zip(list(zip([ref_a] * len(t1b_configs), t1b_configs)), t1b.ravel() * t1b_signs))
)
# alpha, alpha -> alpha, alpha excitations
if nelec_a > 1 and nvir_a > 1:
t2aa_configs, t2aa_signs = _excited_configurations(nelec_a, norb, 2)
# select only unique excitations, via lower triangle of matrix
ooidx = np.tril_indices(nelec_a, -1)
vvidx = np.tril_indices(nvir_a, -1)
t2aa = t2aa[ooidx][:, vvidx[0], vvidx[1]]
fcimatr_dict.update(
dict(
zip(list(zip(t2aa_configs, [ref_b] * len(t2aa_configs))), t2aa.ravel() * t2aa_signs)
)
)
if nelec_b > 1 and nvir_b > 1:
t2bb_configs, t2bb_signs = _excited_configurations(nelec_b, norb, 2)
# select only unique excitations, via lower triangle of matrix
ooidx = np.tril_indices(nelec_b, -1)
vvidx = np.tril_indices(nvir_b, -1)
t2bb = t2bb[ooidx][:, vvidx[0], vvidx[1]]
fcimatr_dict.update(
dict(
zip(list(zip([ref_a] * len(t2bb_configs), t2bb_configs)), t2bb.ravel() * t2bb_signs)
)
)
# alpha, beta -> alpha, beta excitations
fcimatr_dict.update(
dict(
zip(
list(product(t1a_configs, t1b_configs)),
np.einsum(
"i,j,ij->ij",
t1a_signs,
t1b_signs,
t2ab.reshape(nelec_a * nvir_a, -1),
optimize=True,
).ravel(),
)
)
)
# renormalize, to get the HF coefficient (CC wavefunction not normalized)
norm = np.sqrt(np.sum(np.array(list(fcimatr_dict.values())) ** 2))
fcimatr_dict = {key: value / norm for (key, value) in fcimatr_dict.items()}
# filter based on tolerance cutoff
fcimatr_dict = {key: value for key, value in fcimatr_dict.items() if abs(value) > tol}
# convert sign parity from chemist to physicist convention (interleaving spin operators
# rather than commuting all spin-up operators to the left)
fcimatr_dict = _sign_chem_to_phys(fcimatr_dict, norb)
return fcimatr_dict
def _uccsd_state(ccsd_solver, tol=1e-15):
r"""Construct a wavefunction from PySCF's ``UCCSD`` Solver object.
The generated wavefunction is a dictionary where the keys represent a configuration, which
corresponds to a Slater determinant, and the values are the CI coefficients of the Slater
determinant. Each dictionary key is a tuple of two integers. The binary representation of these
integers correspond to a specific configuration: the first number represents the
configuration of the alpha electrons and the second number represents the configuration of the
beta electrons. For instance, the Hartree-Fock state :math:`|1 1 0 0 \rangle` will be
represented by the flipped binary string ``0011`` which is split to ``01`` and ``01`` for
the alpha and beta electrons. The integer corresponding to ``01`` is ``1`` and the dictionary
representation of the Hartree-Fock state will be ``{(1, 1): 1.0}``. The dictionary
representation of a state with ``0.99`` contribution from the Hartree-Fock state and ``0.01``
contribution from the doubly-excited state, i.e., :math:`|0 0 1 1 \rangle`, will be
``{(1, 1): 0.99, (2, 2): 0.01}``.
In the current version, the exponential ansatz :math:`\exp(\hat{T}_1 + \hat{T}_2) \ket{\text{HF}}`
is expanded to second order, with only single and double excitation terms collected and kept.
In the future this will be amended to also collect terms from higher order. The expansion gives
.. math::
\exp(\hat{T}_1 + \hat{T}_2) \ket{\text{HF}} = \left[ 1 + \hat{T}_1 +
\left( \hat{T}_2 + 0.5 * \hat{T}_1^2 \right) \right] \ket{\text{HF}}
The coefficients in this expansion are the CI coefficients used to build the wavefunction
representation.
Args:
ccsd_solver (PySCF UCCSD Class instance): the class object representing the UCCSD calculation in PySCF
tol (float): the tolerance for discarding Slater determinants with small coefficients
Returns:
fcimatr_dict (dict[tuple(int,int),float]): dictionary of the form `{(int_a, int_b) :coeff}`, with integers `int_a, int_b`
having binary represention corresponding to the Fock occupation vector in alpha and beta
spin sectors, respectively, and coeff being the CI coefficients of those configurations
**Example**
>>> from pyscf import gto, scf, cc
>>> mol = gto.M(atom=[['Li', (0, 0, 0)], ['Li', (0,0,0.71)]], basis='sto6g', symmetry="d2h")
>>> myhf = scf.UHF(mol).run()
>>> mycc = cc.UCCSD(myhf).run()
>>> wf_ccsd = _uccsd_state(mycc, tol=1e-1)
>>> print(wf_ccsd)
{(7, 7): -0.8886970081919591, (11, 11): 0.3058459002168582,
(19, 19): 0.30584590021685887, (35, 35): 0.14507552387854625}
"""
mol = ccsd_solver.mol
norb = mol.nao
nelec = mol.nelectron
nelec_a = int((nelec + mol.spin) / 2)
nelec_b = int((nelec - mol.spin) / 2)
nvir_a, nvir_b = norb - nelec_a, norb - nelec_b
t1a, t1b = ccsd_solver.t1
t2aa, t2ab, t2bb = ccsd_solver.t2
# add in the disconnected part ( + 0.5 T_1^2) of double excitations
t2aa = t2aa - 0.5 * np.kron(t1a, t1a).reshape(nelec_a, nvir_a, nelec_a, nvir_a).transpose(
0, 2, 1, 3
)
t2bb = t2bb - 0.5 * np.kron(t1b, t1b).reshape(nelec_b, nvir_b, nelec_b, nvir_b).transpose(
0, 2, 1, 3
)
# align the entries with how the excitations are ordered when generated by _excited_configurations()
t2ab = t2ab.transpose(0, 2, 1, 3) - 0.5 * np.kron(t1a, t1b).reshape(
nelec_a, nvir_a, nelec_b, nvir_b
)
# numbers representing the Hartree-Fock vector, e.g., bin(ref_a)[::-1] = 1111...10...0
ref_a = int(2**nelec_a - 1)
ref_b = int(2**nelec_b - 1)
fcimatr_dict = dict(zip(list(zip([ref_a], [ref_b])), [1.0]))
# alpha -> alpha excitations
t1a_configs, t1a_signs = _excited_configurations(nelec_a, norb, 1)
fcimatr_dict.update(
dict(zip(list(zip(t1a_configs, [ref_b] * len(t1a_configs))), t1a.ravel() * t1a_signs))
)
# beta -> beta excitations
t1b_configs, t1b_signs = _excited_configurations(nelec_b, norb, 1)
fcimatr_dict.update(
dict(zip(list(zip([ref_a] * len(t1b_configs), t1b_configs)), t1b.ravel() * t1b_signs))
)
# alpha, alpha -> alpha, alpha excitations
if nelec_a > 1 and nvir_a > 1:
t2aa_configs, t2aa_signs = _excited_configurations(nelec_a, norb, 2)
# select only unique excitations, via lower triangle of matrix
ooidx = np.tril_indices(nelec_a, -1)
vvidx = np.tril_indices(nvir_a, -1)
t2aa = t2aa[ooidx][:, vvidx[0], vvidx[1]]
fcimatr_dict.update(
dict(
zip(list(zip(t2aa_configs, [ref_b] * len(t2aa_configs))), t2aa.ravel() * t2aa_signs)
)
)
# beta, beta -> beta, beta excitations
if nelec_b > 1 and nvir_b > 1:
t2bb_configs, t2bb_signs = _excited_configurations(nelec_b, norb, 2)
# select only unique excitations, via lower triangle of matrix
ooidx = np.tril_indices(nelec_b, -1)
vvidx = np.tril_indices(nvir_b, -1)
t2bb = t2bb[ooidx][:, vvidx[0], vvidx[1]]
fcimatr_dict.update(
dict(
zip(list(zip([ref_a] * len(t2bb_configs), t2bb_configs)), t2bb.ravel() * t2bb_signs)
)
)
# alpha, beta -> alpha, beta excitations
fcimatr_dict.update(
dict(
zip(
list(product(t1a_configs, t1b_configs)),
np.einsum(
"i,j,ij->ij",
t1a_signs,
t1b_signs,
t2ab.reshape(nelec_a * nvir_a, -1),
optimize=True,
).ravel(),
)
)
)
# renormalize, to get the HF coefficient (CC wavefunction not normalized)
norm = np.sqrt(np.sum(np.array(list(fcimatr_dict.values())) ** 2))
fcimatr_dict = {key: value / norm for (key, value) in fcimatr_dict.items()}
# filter based on tolerance cutoff
fcimatr_dict = {key: value for key, value in fcimatr_dict.items() if abs(value) > tol}
# convert sign parity from chemist to physicist convention (interleaving spin operators
# rather than commuting all spin-up operators to the left)
fcimatr_dict = _sign_chem_to_phys(fcimatr_dict, norb)
return fcimatr_dict
def _dmrg_state(wavefunction, tol=1e-15):
r"""Construct a wavefunction from the DMRG wavefunction obtained from the Block2 library.
The generated wavefunction is a dictionary where the keys represent a configuration, which
corresponds to a Slater determinant, and the values are the CI coefficients of the Slater
determinant. Each dictionary key is a tuple of two integers. The binary representation of these
integers correspond to a specific configuration: the first number represents the
configuration of the alpha electrons and the second number represents the configuration of the
beta electrons. For instance, the Hartree-Fock state :math:`|1 1 0 0 \rangle` will be
represented by the flipped binary string ``0011`` which is split to ``01`` and ``01`` for
the alpha and beta electrons. The integer corresponding to ``01`` is ``1`` and the dictionary
representation of the Hartree-Fock state will be ``{(1, 1): 1.0}``. The dictionary
representation of a state with ``0.99`` contribution from the Hartree-Fock state and ``0.01``
contribution from the doubly-excited state, i.e., :math:`|0 0 1 1 \rangle`, will be
``{(1, 1): 0.99, (2, 2): 0.01}``.
The determinants and coefficients should be supplied externally. They should be calculated by
using Block2 DMRGDriver's `get_csf_coefficients()` method.
Args:
wavefunction tuple(list[int], array[float]): determinants and coefficients in physicist notation
tol (float): the tolerance for discarding Slater determinants with small coefficients
Returns:
fcimatr_dict (dict[tuple(int,int),float]): dictionary of the form `{(int_a, int_b) : coeff}`, with integers `int_a, int_b`
having binary representation corresponding to the Fock occupation vector in alpha and beta
spin sectors, respectively, and coeff being the CI coefficients of those configurations
**Example**
>>> import numpy as np
>>> wavefunction = ( [[0, 3], [3, 0]], np.array([-0.10660077, 0.9943019 ]))
>>> wf_dmrg = _dmrg_state(wavefunction, tol=1e-1)
>>> print(wf_dmrg)
{(2, 2): -0.10660077, (1, 1): 0.9943019}
"""
dets, coeffs = wavefunction
row, col = [], []
for det in dets:
stra, strb = _sitevec_to_fock(det, format="dmrg")
row.append(stra)
col.append(strb)
# slater determinant sign convention of block2 (physicist,
# interleave spin-up/down operators) is consistent with pennylane
## create the FCI matrix as a dict
fcimatr_dict = dict(zip(list(zip(row, col)), coeffs))
# filter based on tolerance cutoff
fcimatr_dict = {key: value for key, value in fcimatr_dict.items() if abs(value) > tol}
return fcimatr_dict
def _shci_state(wavefunction, tol=1e-15):
r"""Construct a wavefunction from the SHCI wavefunction obtained from the Dice library.
The generated wavefunction is a dictionary where the keys represent a configuration, which
corresponds to a Slater determinant, and the values are the CI coefficients of the Slater
determinant. Each dictionary key is a tuple of two integers. The binary representation of these
integers correspond to a specific configuration: the first number represents the
configuration of the alpha electrons and the second number represents the configuration of the
beta electrons. For instance, the Hartree-Fock state :math:`|1 1 0 0 \rangle` will be
represented by the flipped binary string ``0011`` which is split to ``01`` and ``01`` for
the alpha and beta electrons. The integer corresponding to ``01`` is ``1`` and the dictionary
representation of the Hartree-Fock state will be ``{(1, 1): 1.0}``. The dictionary
representation of a state with ``0.99`` contribution from the Hartree-Fock state and ``0.01``
contribution from the doubly-excited state, i.e., :math:`|0 0 1 1 \rangle`, will be
``{(1, 1): 0.99, (2, 2): 0.01}``.
The determinants and coefficients should be supplied externally. They are typically stored under
SHCI.outputfile.
Args:
wavefunction tuple(list[str], array[float]): determinants and coefficients in chemist notation
tol (float): the tolerance for discarding Slater determinants with small coefficients
Returns:
fcimatr_dict (dict[tuple(int,int),float]): dictionary of the form `{(int_a, int_b) : coeff}`, with integers `int_a, int_b`
having binary representation corresponding to the Fock occupation vector in alpha and beta
spin sectors, respectively, and coeff being the CI coefficients of those configurations
**Example**
>>> import numpy as np
>>> wavefunction = ( ['20', '02'], np.array([-0.9943019036, 0.1066007711]))
>>> wf_shci = _shci_state(wavefunction, tol=1e-1)
>>> print(wf_shci)
{(1, 1): -0.9943019036, (2, 2): 0.1066007711}
"""
dets, coeffs = wavefunction
norb = len(dets[0])
xa = []
xb = []
for det in dets:
bin_a, bin_b = _sitevec_to_fock(list(det), "shci")
xa.append(bin_a)
xb.append(bin_b)
## create the FCI matrix as a dict
fcimatr_dict = dict(zip(list(zip(xa, xb)), coeffs))
# filter based on tolerance cutoff
fcimatr_dict = {key: value for key, value in fcimatr_dict.items() if abs(value) > tol}
# convert sign parity from chemist to physicist convention (interleaving spin operators
# rather than commuting all spin-up operators to the left)
fcimatr_dict = _sign_chem_to_phys(fcimatr_dict, norb)
return fcimatr_dict
def _sitevec_to_fock(det, format):
r"""Convert a Slater determinant from site vector to occupation number vector representation.
Args:
det (list(int) or list(str)): determinant in site vector representation
format (str): the format of the determinant
Returns:
tuple: tuple of integers representing binaries that correspond to occupation vectors in
alpha and beta spin sectors
**Example**
>>> det = [1, 2, 1, 0, 0, 2]
>>> _sitevec_to_fock(det, format = 'dmrg')
(5, 34)
>>> det = ["a", "b", "a", "0", "0", "b"]
>>> _sitevec_to_fock(det, format = 'shci')
(5, 34)
"""
if format == "dmrg":
format_map = {0: "00", 1: "10", 2: "01", 3: "11"}
elif format == "shci":
format_map = {"0": "00", "a": "10", "b": "01", "2": "11"}
strab = [format_map[key] for key in det]
stra = "".join(i[0] for i in strab)
strb = "".join(i[1] for i in strab)
inta = int(stra[::-1], 2)
intb = int(strb[::-1], 2)
return inta, intb
def _sign_chem_to_phys(fcimatr_dict, norb):
r"""Convert the dictionary-form wavefunction from chemist sign convention
for ordering the creation operators by spin (i.e. all spin-up operators
on the left) to the physicist convention native to PennyLane, which
storing spin operators as interleaved for the same spatial orbital index.
Note that convention change in the opposite direction -- starting from physicist
and going to chemist -- can be accomplished with the same function
(the sign transformation is reversible).
Args:
fcimatr_dict (dict[tuple(int, int), float]): dictionary of the form `{(int_a, int_b) :coeff}`, with integers `int_a, int_b`
having binary represention corresponding to the Fock occupation vector in alpha and beta
spin sectors, respectively, and coeff being the CI coefficients of those configurations
norb (int): total number of spatial orbitals of the underlying system
Returns:
signed_dict (dict): the same dictionary-type wavefunction with appropriate signs converted
**Example**
>>> fcimatr_dict = {(3, 1): 0.96, (6, 1): 0.1, \
(3, 4): 0.1, (6, 4): 0.14, (5, 2): 0.19}
>>> _sign_chem_to_phys(fcimatr_dict, 3)
{(3, 1): -0.96, (6, 1): 0.1, (3, 4): 0.1, (6, 4): 0.14, (5, 2): -0.19}
"""
signed_dict = {}
for key, elem in fcimatr_dict.items():
lsta, lstb = bin(key[0])[2:][::-1], bin(key[1])[2:][::-1]
# highest energy state is on the right -- pad to the right
lsta = np.array([int(elem) for elem in lsta] + [0] * (norb - len(lsta)))
lstb = np.array([int(elem) for elem in lstb] + [0] * (norb - len(lstb)))
which_occ = np.where(lsta == 1)[0]
parity = (-1) ** np.sum([np.sum(lstb[: int(ind)]) for ind in which_occ])
signed_dict[key] = parity * elem
return signed_dict
```

_modules/pennylane/qchem/convert

Download Python script

Download Notebook

View on GitHub