OpenFermion

https://quantumai.google/openfermion
Admin
OpenFermion is an open source library for compiling and analyzing quantum algorithms to simulate...
Tokens:57,253
Snippets:431
Trust Score:9.8
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install OpenFermion-FQE

Source: https://quantumai.google/openfermion/fqe/tutorials/fermi_hubbard

Installs the OpenFermion-FQE library. Use `pip install fqe --quiet` when FQE>0.1.0 is released.

```python
try:
    import fqe
except ImportError:
    # TODO: Change to `pip install fqe --quiet` when FQE>0.1.0 is released.
    !pip install git+https://github.com/quantumlib/OpenFermion-FQE --quiet
```

--------------------------------

### Install OpenFermion Package

Source: https://quantumai.google/openfermion/tutorials/bosonic_operators

Installs the OpenFermion package. Use this if the package is not already installed.

```python
try:
    import openfermion
except ImportError:
    !pip install git+https://github.com/quantumlib/OpenFermion.git@main#egg=openfermion
```

--------------------------------

### Install and Import FQE

Source: https://quantumai.google/openfermion/fqe/guide/introduction

Install the fqe package if not present and import the necessary modules.

```python
try:
    import fqe
except ImportError:
    !pip install fqe --quiet
```

```python
import fqe
import numpy as np
```

--------------------------------

### Library Install of OpenFermion

Source: https://quantumai.google/openfermion/install

Install the latest PyPI release of OpenFermion as a library in user mode. This is the recommended way to use OpenFermion for general purposes.

```bash
python3 -m pip install --user openfermion
```

--------------------------------

### Install OpenFermion

Source: https://quantumai.google/openfermion/tutorials/binary_code_transforms

Installs the OpenFermion package from its GitHub repository. This is useful if the package is not found in the current environment.

```python
try:
    import openfermion
except ImportError:
    !pip install git+https://github.com/quantumlib/OpenFermion.git@main#egg=openfermion

```

--------------------------------

### Install FQE dependency

Source: https://quantumai.google/openfermion/fqe/tutorials/fqe_vs_openfermion_quadratic_hamiltonians

Ensures the FQE library is installed in the environment.

```python
try:
    import fqe
except ImportError:
    !pip install fqe --quiet
```

--------------------------------

### Install OpenFermion dependencies

Source: https://quantumai.google/openfermion/tutorials/intro_workshop_exercises

Check for and install the required OpenFermion and OpenFermion-PySCF packages.

```python
try:
    import openfermion as of
    import openfermionpyscf as ofpyscf
except ImportError:
    print("Installing OpenFermion and OpenFermion-PySCF...")
    !pip install openfermion openfermionpyscf --quiet
```

--------------------------------

### Install tensorflow-docs for API Reference

Source: https://quantumai.google/openfermion/install

Install the `tensorflow-docs` package to use the API docs generator library. This is required for building the API reference Markdown files from your local repository.

```bash
python3 -m pip install -U --user git+https://github.com/tensorflow/docs
```

--------------------------------

### Developer Install of OpenFermion

Source: https://quantumai.google/openfermion/install

Install the latest version of OpenFermion in development mode. This requires cloning the repository and then installing it with pip in editable mode.

```bash
git clone https://github.com/quantumlib/OpenFermion
cd OpenFermion
python3 -m pip install -e .
```

--------------------------------

### Prepare Gaussian State Circuit

Source: https://quantumai.google/openfermion/tutorials/intro_to_openfermion

Generates a circuit description and starting orbitals for preparing the ground state of a quadratic Hamiltonian.

```python
from openfermion.circuits import gaussian_state_preparation_circuit

circuit_description, start_orbitals = gaussian_state_preparation_circuit(quadratic_hamiltonian)
for parallel_ops in circuit_description:
    print(parallel_ops)
print('')
print(start_orbitals)
```

--------------------------------

### Jellium Hamiltonian Output Example

Source: https://quantumai.google/openfermion/tutorials/intro_to_openfermion

Example output showing the qubit operator representations and the spectral difference between the momentum and position basis Hamiltonians.

```text
19.50047638754088 [] +
-9.71044945799746 [Z0] +
-0.07957747154594767 [Z0 Z1] +
-0.07957747154594767 [Z0 Z2] +
0.15915494309189535 [Z1] +
-0.07957747154594767 [Z1 Z2] +
-9.71044945799746 [Z2]

19.500476387540854 [] +
-3.289868133696451 [X0 X1] +
-3.289868133696454 [X0 Z1 X2] +
-3.289868133696451 [Y0 Y1] +
-3.289868133696454 [Y0 Z1 Y2] +
-6.420581324301009 [Z0] +
-0.07957747154594766 [Z0 Z1] +
-0.07957747154594763 [Z0 Z2] +
-3.289868133696451 [X1 X2] +
-3.289868133696451 [Y1 Y2] +
-6.4205813243010095 [Z1] +
-0.07957747154594766 [Z1 Z2] +
-6.420581324301009 [Z2]

[2.75474088e-14 2.66175970e-14 2.84217094e-14 7.10542736e-15
 2.84217094e-14 2.13162821e-14 1.42108547e-14 7.10542736e-15]
```

--------------------------------

### Construct Bose-Hubbard Hamiltonian

Source: https://quantumai.google/openfermion/tutorials/bosonic_operators

Example of constructing a Bose-Hubbard Hamiltonian on a 2x2 grid.

```python
from openfermion.hamiltonians import bose_hubbard, fermi_hubbard
bose_hubbard(2, 2, 1, 1)
```

```python
-1 [0 1^] +
-1 [0 2^] +
-0.5 [0^ 0] +
0.5 [0^ 0 0^ 0] +
-1 [0^ 1] +
-1 [0^ 2] +
-1 [1 3^] +
-0.5 [1^ 1] +
0.5 [1^ 1 1^ 1] +
-1 [1^ 3] +
-1 [2 3^] +
-0.5 [2^ 2] +
0.5 [2^ 2 2^ 2] +
-1 [2^ 3] +
-0.5 [3^ 3] +
0.5 [3^ 3 3^ 3]
```

--------------------------------

### Example Hamiltonian Output

Source: https://quantumai.google/openfermion/tutorials/binary_code_transforms

Displays the output of the fermionic Hamiltonian and its Jordan-Wigner transformed version.

```text
Fermionic Hamiltonian
-6.7698132180879735 [] +
-0.7952726864779313 [0^ 0] +
0.04614563473199314 [0^ 2] +
-0.4977908053255035 [1^ 0^ 1 0] +
-0.046145652803099894 [1^ 0^ 2 1] +
0.046145652803099894 [1^ 0^ 3 0] +
-0.011731985763800887 [1^ 0^ 3 2] +
-0.7952726864779313 [1^ 1] +
0.04614563473199314 [1^ 3] +
0.04614563473199324 [2^ 0] +
-0.21652178317319534 [2^ 0^ 2 0] +
-0.04614565280309991 [2^ 1^ 1 0] +
-0.22825376893699628 [2^ 1^ 2 1] +
0.011731985763800913 [2^ 1^ 3 0] +
0.005497504431583474 [2^ 1^ 3 2] +
-0.36549257026798354 [2^ 2] +
0.04614565280309991 [3^ 0^ 1 0] +
0.011731985763800913 [3^ 0^ 2 1] +
-0.22825376893699628 [3^ 0^ 3 0] +
-0.005497504431583474 [3^ 0^ 3 2] +
0.04614563473199324 [3^ 1] +
-0.21652178317319534 [3^ 1^ 3 1] +
-0.011731985763800917 [3^ 2^ 1 0] +
0.005497504431583467 [3^ 2^ 2 1] +
-0.005497504431583467 [3^ 2^ 3 0] +
-0.33918438174683924 [3^ 2^ 3 2] +
-0.36549257026798354 [3^ 3]
The eigenspectrum
[-7.86277316 -7.78339621 -7.78339621 -7.71405669 -7.71405669 -7.71405669
 -7.70047584 -7.56998474 -7.56998474 -7.51199971 -7.51199971 -7.36481744
 -7.15152548 -7.13040696 -7.13040696 -6.76981322]

-----

Jordan-Wigner transformed Hamiltonian
-7.498946902010707 [] +
-0.002932996440950227 [X0 X1 Y2 Y3] +
0.002932996440950227 [X0 Y1 Y2 X3] +
0.012910780273117489 [X0 Z1 X2] +
-0.0013743761078958677 [X0 Z1 X2 Z3] +
0.011536413200774975 [X0 X2] +
0.002932996440950227 [Y0 X1 X2 Y3] +
-0.002932996440950227 [Y0 Y1 X2 X3] +
0.012910780273117489 [Y0 Z1 Y2] +
-0.0013743761078958677 [Y0 Z1 Y2 Z3] +
0.011536413200774975 [Y0 Y2] +
0.1619947538800418 [Z0] +
0.011536413200774975 [Z0 X1 Z2 X3] +
0.011536413200774975 [Z0 Y1 Z2 Y3] +
0.12444770133137588 [Z0 Z1] +
0.054130445793298836 [Z0 Z2] +
0.05706344223424907 [Z0 Z3] +
0.012910780273117489 [X1 Z2 X3] +
-0.0013743761078958677 [X1 X3] +
0.012910780273117489 [Y1 Z2 Y3] +
-0.0013743761078958677 [Y1 Y3] +
0.1619947538800418 [Z1] +
0.05706344223424907 [Z1 Z2] +
0.054130445793298836 [Z1 Z3] +
-0.013243698330265952 [Z2] +
0.08479609543670981 [Z2 Z3] +
-0.013243698330265966 [Z3]
the eigenspectrum of the transformed hamiltonian
```

--------------------------------

### Simulate circuit with Cirq

Source: https://quantumai.google/openfermion/tutorials/circuits_1_basis_change

Executes a quantum circuit using the Cirq simulator starting from a specific initial state.

```python
simulator = cirq.Simulator()
result = simulator.simulate(circuit, qubit_order=qubits,
                            initial_state=initial_state)
simulated_state = result.final_state_vector
```

--------------------------------

### Jordan-Wigner Transform Example

Source: https://quantumai.google/openfermion/tutorials/jordan_wigner_and_bravyi_kitaev_transforms

Demonstrates mapping FermionOperators to QubitOperators using the Jordan-Wigner transform and verifying anticommutation relations.

```python
from openfermion import *

# Create some ladder operators
annihilate_2 = FermionOperator('2')
create_2 = FermionOperator('2^')
annihilate_5 = FermionOperator('5')
create_5 = FermionOperator('5^')

# Construct occupation number operators
num_2 = create_2 * annihilate_2
num_5 = create_5 * annihilate_5

# Map FermionOperators to QubitOperators using the JWT
annihilate_2_jw = jordan_wigner(annihilate_2)
create_2_jw = jordan_wigner(create_2)
annihilate_5_jw = jordan_wigner(annihilate_5)
create_5_jw = jordan_wigner(create_5)
num_2_jw = jordan_wigner(num_2)
num_5_jw = jordan_wigner(num_5)

# Create QubitOperator versions of zero and identity
zero = QubitOperator()
identity = QubitOperator(())

# Check the canonical anticommutation relations
assert anticommutator(annihilate_5_jw, annihilate_2_jw) == zero
assert anticommutator(annihilate_5_jw, annihilate_5_jw) == zero
assert anticommutator(annihilate_5_jw, create_2_jw) == zero
assert anticommutator(annihilate_5_jw, create_5_jw) == identity

```

--------------------------------

### Initialize BosonOperator with Coefficient

Source: https://quantumai.google/openfermion/tutorials/bosonic_operators

Shows the preferred method for initializing a BosonOperator with a coefficient, which is to provide it as an argument. The alternative method using multiplication creates a copy and is less efficient. Examples also demonstrate initializing the identity and zero operators.

```python
good_way_to_initialize = BosonOperator('3^ 1', -1.7)
print(good_way_to_initialize)

bad_way_to_initialize = -1.7 * BosonOperator('3^ 1')
print(bad_way_to_initialize)

identity = BosonOperator('')
print(identity == BosonOperator.identity())
print(identity)

zero_operator = BosonOperator()
print(zero_operator == BosonOperator.zero())
print(zero_operator)
```

--------------------------------

### Example One-Particle Density Matrix (OPDM)

Source: https://quantumai.google/openfermion/fqe/tutorials/fqe_vs_openfermion_quadratic_hamiltonians

A sample output of a one-particle density matrix (OPDM) calculated using Cirq and OpenFermion.

```text
[[ 0.89779286+0.j         -0.07524962+0.13954963j  0.1006792 +0.03293365j
   0.12542128-0.19918035j]
 [-0.07524962-0.13954963j  0.72635602+0.j         -0.08961216+0.2461997j
   0.32180163-0.03775482j]
 [ 0.1006792 -0.03293365j -0.08961216-0.2461997j   0.12342215+0.j
  -0.05137394-0.16026316j]
 [ 0.12542128+0.19918035j  0.32180163+0.03775482j -0.05137394+0.16026316j
   0.25242897+0.j        ]]
```

--------------------------------

### Initialize Wavefunction and Get Basis Rotation Circuit

Source: https://quantumai.google/openfermion/fqe/tutorials/fqe_vs_openfermion_quadratic_hamiltonians

This snippet initializes a Full Quantum Eigensolver (FQE) wavefunction to the Hartree-Fock state and obtains the basis rotation circuit using Givens decomposition.

```python
# Get the basis rotation circuit
rotations, diagonal = givens_decomposition_square(u.conj().T)

# Reinitialize the wavefunction to Hartree-Fock
fqe_wfn = fqe.Wavefunction([[norbs // 2, norbs // 2, norbs]])
hf_wf = np.zeros((int(binom(norbs, norbs // 2)), 1),
                 dtype=np.complex128)
hf_wf[0, 0] = 1  # right most bit is zero orbital.
fqe_wfn.set_wfn(strategy='from_data',
                raw_data={(norbs // 2, norbs // 2): hf_wf})
```

--------------------------------

### Initialize Environment and Imports

Source: https://quantumai.google/openfermion/fqe/tutorials/hamiltonian_time_evolution_and_expectation_estimation

Configures numpy settings and imports necessary modules for OpenFermion and FQE.

```python
Print = True
from openfermion import FermionOperator, MolecularData
from openfermion.utils import hermitian_conjugated
import numpy
import fqe

numpy.set_printoptions(floatmode='fixed', precision=6, linewidth=80, suppress=True)
numpy.random.seed(seed=409)
```

--------------------------------

### Initialize Wavefunctions with Utility Methods

Source: https://quantumai.google/openfermion/fqe/guide/introduction

Use helper functions to create wavefunctions with specific particle, spin, and orbital constraints.

```python
wfn_fqe = fqe.get_wavefunction(4, -2, 10)
```

```python
wfn_fqe1, wfn_fqe2 = fqe.get_wavefunction_multiple([[4, 0, 10], [5, -5, 10]])
```

```python
# Get a spin conserving wavefunction.
spin_conserving_wfn = fqe.get_spin_conserving_wavefunction(2, 4)

# Get a number conserving wavefunction.
number_conserving_wfn = fqe.get_number_conserving_wavefunction(2, 4)
```

--------------------------------

### Initialize FQE wavefunction

Source: https://quantumai.google/openfermion/fqe/tutorials/fqe_vs_openfermion_quadratic_hamiltonians

Sets up the FQE wavefunction object and populates it with initial data.

```python
# initialize the FQE wavefunction [n-elec, sz, norbs]
fqe_wfn = fqe.Wavefunction([[norbs // 2, norbs//2, norbs]])
hf_wf = np.zeros((int(binom(norbs, norbs // 2)), 1), dtype=np.complex128)
hf_wf[0, 0] = 1  # right most bit is zero orbital.
fqe_wfn.set_wfn(strategy='from_data',
                raw_data={(norbs//2, norbs//2): hf_wf})
fqe_wfn.print_wfn()
```

--------------------------------

### Instantiate and Print BinaryCode

Source: https://quantumai.google/openfermion/tutorials/binary_code_transforms

Demonstrates how to create a BinaryCode instance with a given encoder matrix and decoder components, and then prints its properties and contents. Ensure the encoder and decoder inputs are valid for their respective constructors.

```python
from openfermion.ops import BinaryCode

code_1 = BinaryCode([[1, 0, 0], [0, 1, 0]], ['w0', 'w1', 'w0 + w1 + 1' ])

print(code_1)
print('number of qubits: ', code_1.n_qubits, '  number of Fermion modes: ', code_1.n_modes )
print('encoding matrix: \n', code_1.encoder.toarray())
print('decoder: ', code_1.decoder)
```

--------------------------------

### Compare FQE and OpenFermion bit ordering

Source: https://quantumai.google/openfermion/fqe/tutorials/fqe_vs_openfermion_quadratic_hamiltonians

Demonstrates the difference in bit indexing between FQE and OpenFermion.

```python
# initialize wavefunction [n-elec, sz, norbs]
fqe_wfn = fqe.Wavefunction([[norbs // 2, norbs//2, norbs]])
hf_wf = np.zeros((int(binom(norbs, norbs // 2)), 1), dtype=np.complex128)
hf_wf[0, 0] = 1  # right most bit is zero orbital. 2-alpha electron HF is 0011.  This is the first element of our particle conserved Hilbert space
fqe_wfn.set_wfn(strategy='from_data',
                raw_data={(norbs//2, norbs//2): hf_wf})
fqe_wfn.print_wfn()

# OpenFermion indexes from the left as zero.  The RHF state is 1100
wfn[int("".join([str(x) for x in [1] * (norbs//2) + [0] * (norbs//2)]), 2), 0] = 1

print("\nHF-Vector-OpenFermion ", bin(int("".join([str(x) for x in [1] * (norbs//2) + [0] * (norbs//2)]), 2)))
```

--------------------------------

### Initialize and Print BinaryPolynomial

Source: https://quantumai.google/openfermion/tutorials/binary_code_transforms

Demonstrates initializing a BinaryPolynomial using a string, printing its equivalent forms, and showing its native data structure. It also shows how to evaluate the polynomial for a given binary vector.

```python
from openfermion.ops import BinaryPolynomial

binary_1 = BinaryPolynomial('w0 w1 + w1 + 1')

print("These three expressions are equivalent: \n", binary_1)
print(BinaryPolynomial('w0') * BinaryPolynomial('w1 + 1') + BinaryPolynomial('1'))
print(BinaryPolynomial([(1, 0), (1, ), ('one', )]))

print('The native data type structure can be seen here:')
print(binary_1.terms)
print('We can always evaluate the expression for instance by the vector (w0, w1, w2) = (1, 0, 0):',
      binary_1.evaluate('100'))

```

--------------------------------

### Initialize MolecularData instance

Source: https://quantumai.google/openfermion/tutorials/intro_to_openfermion

Demonstrates creating a MolecularData object with specific geometry, basis, and charge parameters.

```python
from openfermion.chem import MolecularData

# Set parameters to make a simple molecule.
diatomic_bond_length = .7414
geometry = [('H', (0., 0., 0.)), ('H', (0., 0., diatomic_bond_length))]
basis = 'sto-3g'
multiplicity = 1
charge = 0
description = str(diatomic_bond_length)

# Make molecule and print out a few interesting facts about it.
molecule = MolecularData(geometry, basis, multiplicity,
                         charge, description)
print('Molecule has automatically generated name {}'.format(
    molecule.name))
print('Information about this molecule would be saved at:\n{}\n'.format(
    molecule.filename))
print('This molecule has {} atoms and {} electrons.'.format(
    molecule.n_atoms, molecule.n_electrons))
for atom, atomic_number in zip(molecule.atoms, molecule.protons):
    print('Contains {} atom, which has {} protons.'.format(
        atom, atomic_number))
```

--------------------------------

### FQE Wavefunction Output

Source: https://quantumai.google/openfermion/fqe/tutorials/diagonal_coulomb_evolution

Example output showing the evolved wavefunction state in the N=4 sector.

```text
Evolved wavefunction
Sector N = 4 : S_z = 0
a'000011'b'000011' (-0.06369656945822004+0.053318678376629104j)
a'000011'b'000101' (-0.026642637033258806-0.050787346451542904j)
a'000011'b'001001' (0.015753077225267302+0.00202067194487536j)
a'000011'b'010001' (0.019754242826717904-0.019195729614169293j)
a'000011'b'100001' (0.009897500907589979-0.01292329679120121j)
a'000011'b'000110' (-0.017446553111208317-0.06074410504477305j)
a'000011'b'001010' (0.1022369185128597+0.1473386991168148j)
a'000011'b'010010' (0.005671837707488691-0.012663827168646615j)
a'000011'b'100010' (0.021242869440785947+0.05123345303030723j)
a'000011'b'001100' (-0.04740475354048914-0.04321457669383536j)
a'000011'b'010100' (0.025654158054339286-0.061091517407494356j)
a'000011'b'100100' (0.05518179623030716+0.0738152828670925j)
a'000011'b'011000' (-0.010697860785657284+0.030191569028484747j)
a'000011'b'101000' (-0.020966441035788486+0.0068951632900445675j)
a'000011'b'110000' (0.06720886480265931+0.013935221645616627j)
a'000101'b'000011' (0.02194772529762672-0.03673496335896566j)
a'000101'b'000101' (-0.062365111624790324-0.08046225274521765j)
a'000101'b'001001' (0.026099347701378957+0.053478797127949146j)
a'000101'b'010001' (-0.054289720547847475-0.06477059347405224j)
a'000101'b'100001' (0.02517114095863555-0.01113733881235165j)
a'000101'b'000110' (-0.04249540511404855+0.03292805594787379j)
a'000101'b'001010' (0.008522478170231083-0.024419302576603127j)
a'000101'b'010010' (-0.04570938634569113+0.049961876550059965j)
a'000101'b'100010' (0.021143747660758994+0.03308073913044155j)
a'000101'b'001100' (-0.044569748433943984+0.01030390795644423j)
a'000101'b'010100' (0.017986038942503654-0.02820957877790961j)
a'000101'b'100100' (0.004808275513667711-0.03810242023336621j)
a'000101'b'011000' (-0.08297994494882563-0.019529207624415297j)
a'000101'b'101000' (-0.00447140269605294+0.07193969905807782j)
a'000101'b'110000' (0.018825460413560764-0.04159084971205938j)
a'001001'b'000011' (-0.04315277484041129-0.026572677985858904j)
a'001001'b'000101' (-0.0005391891790733836-0.0568275800059527j)
a'001001'b'001001' (-0.030170799092016923-0.056469369589714574j)
a'001001'b'010001' (0.014883404769102932+0.028501149958770823j)
a'001001'b'100001' (-0.0019489732234766115-0.04379743922855316j)
a'001001'b'000110' (-0.021355434887517254+0.005289919243469144j)
a'001001'b'001010' (-0.025785828411700736-0.06906093037754608j)
a'001001'b'010010' (0.05125456462150961+0.001412814309753716j)
a'001001'b'100010' (0.009680163883398742+0.08395308173844873j)
a'001001'b'001100' (-0.04185530733485095-0.04788625333305742j)
a'001001'b'010100' (-0.030272786944762476+0.04326216495133751j)
a'001001'b'100100' (0.062106487906446906+0.0398735695124582j)
a'001001'b'011000' (-0.05786343181612021+0.010425307654349741j)
a'001001'b'101000' (-0.0272112139251754-0.036927895121117146j)
a'001001'b'110000' (-0.09664255317781564+0.02014667889130704j)
a'010001'b'000011' (0.011494071844283573+0.092968861456681j)
a'010001'b'000101' (-0.023560058469986444+0.0016659784825892128j)
a'010001'b'001001' (0.06605018652397125-0.008215053084263629j)
a'010001'b'010001' (-0.0037208223226267182+0.018141346700910957j)
a'010001'b'100001' (0.07093642052006344+0.05622366674507075j)
a'010001'b'000110' (0.051632923439964895-0.029201820074659244j)
a'010001'b'001010' (-0.005614204332054068-0.00847159660218714j)
a'010001'b'010010' (0.051964330954037796-0.0008526745557391537j)
a'010001'b'100010' (0.05742672349298214+0.027521861121484113j)
a'010001'b'001100' (-0.07374214108649041+0.015363479749411562j)
a'010001'b'010100' (-0.054499560802402654-0.0676143406198719j)
a'010001'b'100100' (0.030006734007336427+0.031083893330464366j)
a'010001'b'011000' (-0.007542764679154869-0.03635836298606515j)
a'010001'b'101000' (0.02836879104546726-0.12362586092195663j)
a'010001'b'110000' (0.016568344726737707-0.05961570435731416j)
a'100001'b'000011' (0.004661499910900825-0.04503516203145685j)
a'100001'b'000101' (-0.026354017834463353-0.06503340996712166j)
a'100001'b'001001' (0.03823340847117693-0.14304947141244162j)
a'100001'b'010001' (0.01683543958539248-0.03352791168340522j)
a'100001'b'100001' (-0.060536418913587145+0.02067442232363083j)
a'100001'b'000110' (-0.0008741746826225941-0.013566382930045522j)
a'100001'b'001010' (0.031397467084181806-0.11798508393987849j)
a'100001'b'010010' (-0.07038820593889111+0.06130411180459422j)
a'100001'b'100010' (0.04482196413418091+0.004399243953261921j)
a'100001'b'001100' (-0.05490334206892905+0.07073608893305461j)
a'100001'b'010100' (0.002894226076100593+0.0818781514677145j)
a'100001'b'100100' (0.00478254921151285-0.0038576614389235616j)
a'100001'b'011000' (-0.049078000983790386+0.045929546474513194j)
a'100001'b'101000' (0.034060084772380476-0.04384209257092813j)
```

--------------------------------

### Build OpenFermion API Docs

Source: https://quantumai.google/openfermion/install

Run the OpenFermion documentation build script to generate Markdown files for the API reference. These files can then be previewed in GitHub.

```bash
python3 dev_tools/docs/build_api_docs.py --output_dir=docs/api_docs
```

--------------------------------

### OpenFermion Basic Operations

Source: https://quantumai.google/openfermion

Demonstrates constructing a fermion operator, building a molecule, creating a Hubbard model Hamiltonian, and obtaining the ground state energy and vector using OpenFermion.

```python
from openfermion import FermionOperator, MolecularData
from openfermion import fermi_hubbard, get_ground_state, get_sparse_operator

# Construct a fermion operators
my_first_fermion = FermionOperator(‘1^ 0 2^ 3’)
print(my_first_fermion)

# Build a Molecule
geometry = [[‘H’, [0, 0, 0]], [‘H’, [0, 0, 1.4]]]
multiplicity = 1
basis = ‘cc-pvdz’
charge = 0
molecule = MolecularData(geometry, basis, multiplicity, charge)

# Create model hamiltonians on a 1 x 10 lattice
hubbard = fermi_hubbard(1, 10, tunneling=1, coulomb=4, periodic=True)
print(hubbard)

# Get ground states
gs_energy, gs_eigvec = get_ground_state(get_sparse_operator(hubbard))
```

--------------------------------

### Initialize Wavefunction

Source: https://quantumai.google/openfermion/fqe/tutorials/fermi_hubbard

Sets up the initial wavefunction in the FQE representation using a Hartree-Fock strategy.

```python
init_wfn = fqe.Wavefunction([[nsites // 2, 0, nsites]])
init_wfn.set_wfn(strategy='hartree-fock')
init_wfn.print_wfn()
```

--------------------------------

### CircuitOperations with use_repetition_ids=True

Source: https://quantumai.google/openfermion/tutorials/circuits_1_basis_change

This example shows how to explicitly set `use_repetition_ids=True` to preserve the current behavior in Cirq 1.6 and beyond. This is a workaround for a FutureWarning.

```python
CircuitOperations(..., use_repetition_ids=True)
```

--------------------------------

### Evolve Dense Quadratic Hamiltonian

Source: https://quantumai.google/openfermion/fqe/tutorials/hamiltonian_time_evolution_and_expectation_estimation

Performs exact time evolution for a dense quadratic Hamiltonian. This example uses a spin-restricted Hamiltonian and a number-conserving wavefunction.

```python
norb = 4 
h1e = numpy.zeros((norb, norb), dtype=numpy.complex128) 
for i in range(norb):
    for j in range(norb):
        h1e[i, j] += (i+j) * 0.02
    h1e[i, i] += i * 2.0 

hamil = fqe.get_restricted_hamiltonian((h1e,))
wfn = fqe.Wavefunction([[4, 0, norb]])
wfn.set_wfn(strategy='random')
initial_energy = wfn.expectationValue(hamil)
print('Initial Energy: {}'.format(initial_energy))

# Assuming 'time' is defined elsewhere
evolved = wfn.time_evolve(time, hamil)
final_energy = evolved.expectationValue(hamil)
print('Final Energy:   {}'.format(final_energy))


```

--------------------------------

### Import OpenFermion

Source: https://quantumai.google/openfermion/tutorials/circuits_3_arbitrary_basis_trotter

Initial import statement required to begin working with OpenFermion tools.

```python
import openfermion
```

--------------------------------

### Trotterized Fidelity Output

Source: https://quantumai.google/openfermion/fqe/tutorials/fermi_hubbard

Example output showing the calculated fidelity for a Trotterized simulation. Higher values indicate better agreement with the exact evolution.

```text
Trotterized fidelity: 0.9983245612277033
```

--------------------------------

### Initialize Random Wavefunction

Source: https://quantumai.google/openfermion/fqe/tutorials/diagonal_coulomb_evolution

Sets up a random wavefunction for a system with 6 orbitals and 4 electrons.

```python
norbs = 6
tedim = norbs * (norbs + 1) // 2
if (norbs // 2) % 2 == 0:
    n_elec = norbs // 2
else:
    n_elec = (norbs // 2) + 1
sz = 0
fqe_wfn = fqe.Wavefunction([[n_elec, sz, norbs]])
fqe_wfn.set_wfn(strategy='random')
initial_coeffs = fqe_wfn.get_coeff((n_elec, sz)).copy()
print("Random initial wavefunction")
fqe_wfn.print_wfn()
```

--------------------------------

### Map Wavefunction to Cirq and Get OPDM

Source: https://quantumai.google/openfermion/fqe/tutorials/fqe_vs_openfermion_quadratic_hamiltonians

Maps a wavefunction to a Cirq wavefunction and calculates the one-particle density matrix (OPDM). Asserts the result against a pre-calculated value. Requires OpenFermion and NumPy.

```python
# map the wavefunction to a cirq wavefunction and get the opdm
crq_wfn = fqe.to_cirq(fqe_wfn).reshape((-1, 1))
crq_opdm = get_opdm(crq_wfn, 2 * norbs)
print(crq_opdm[::2, ::2])

# check if it is the same as our other 1-RDMs
assert np.allclose(final_opdm, crq_opdm[::2, ::2])
```

--------------------------------

### Import OpenFermion and dependencies

Source: https://quantumai.google/openfermion/tutorials/intro_workshop_exercises

Standard imports for working with OpenFermion, NumPy, SciPy, and Cirq.

```python
import numpy as np
from scipy.sparse import linalg

import cirq
import openfermion as of
import openfermionpyscf as ofpyscf
```

--------------------------------

### Prepare Fermi-Hubbard Initial State

Source: https://quantumai.google/openfermion/fqe/tutorials/fermi_hubbard

Sets up parameters and constructs the spin-up and spin-down Hamiltonians for the Fermi-Hubbard experiment. These Hamiltonians include hopping and onsite potential terms.

```python
# Parameters used in the Fermi-Hubbard experiment.
nsites = 8
l_up = 4
m_up = 4.5
sigma_up = 1

# For convenience.
site_index = np.arange(1, nsites + 1)

# Creating the spin-up and spin-down Hamiltonians.
spin_up_ham = np.diag([-1.] * (nsites - 1), k=1) + np.diag([-1.] * (nsites - 1), k=-1)
spin_up_ham += np.diag(-l_up * np.exp(-0.5 * (site_index - m_up)**2) / sigma_up**2)
spin_down_ham = np.diag([-1.] * (nsites - 1), k=1) + np.diag([-1.] * (nsites - 1), k=-1)
```

--------------------------------

### Construct Linear Swap Network Trotter Step

Source: https://quantumai.google/openfermion/tutorials/circuits_2_diagonal_coulomb_trotter

Constructs a circuit for a Trotter step using the LINEAR_SWAP_NETWORK algorithm. The output circuit is then simplified by dropping negligible operations. This example shows the default behavior where the qubit order is reversed.

```python
swap_network_trotter_step = cirq.Circuit(
    openfermion.simulate_trotter(
        qubits, hamiltonian, time, n_steps, order,
        algorithm=trotter.LINEAR_SWAP_NETWORK),
    strategy=cirq.InsertStrategy.EARLIEST)
swap_network_trotter_step=cirq.drop_negligible_operations(swap_network_trotter_step)
print(swap_network_trotter_step.to_text_diagram(transpose=True))
```

--------------------------------

### Simulate Circuit with Split-Operator Method

Source: https://quantumai.google/openfermion/tutorials/circuits_2_diagonal_coulomb_trotter

Construct a quantum circuit by combining a state preparation circuit with a split-operator Trotter step, then simulate it using a specified initial state. Finally, calculate the expectation value of the Hamiltonian for the resulting state vector.

```python
circuit = state_preparation_circuit + split_operator_trotter_step
result = simulator.simulate(circuit, initial_state=initial_state)
final_state = result.final_state_vector

print('Energy of state obtained with split-operator method: {}'.format(
    openfermion.expectation(hamiltonian_sparse, final_state).real))
```

--------------------------------

### Construct a Trotter circuit with LINEAR_SWAP_NETWORK

Source: https://quantumai.google/openfermion/tutorials/circuits_2_diagonal_coulomb_trotter

Demonstrates how to configure and construct a quantum circuit for Hamiltonian simulation using the LINEAR_SWAP_NETWORK algorithm.

```python
from openfermion.circuits import trotter

# Set algorithm parameters.
time = 1.0
n_steps = 1
order = 1

# Construct circuit
swap_network_trotter_step = cirq.Circuit(
    openfermion.simulate_trotter(
        qubits, hamiltonian, time, n_steps, order,
        algorithm=trotter.LINEAR_SWAP_NETWORK),
    strategy=cirq.InsertStrategy.EARLIEST)
```

--------------------------------

### Import required libraries

Source: https://quantumai.google/openfermion/fqe/tutorials/fqe_vs_openfermion_quadratic_hamiltonians

Imports necessary modules for Hamiltonian construction, linear algebra, and quantum circuit simulation.

```python
from typing import Union
from itertools import product
import fqe
from fqe.hamiltonians.restricted_hamiltonian import RestrictedHamiltonian

import numpy as np
import cirq

import openfermion as of
from openfermion.testing.testing_utils import random_quadratic_hamiltonian
from openfermion.ops import QuadraticHamiltonian
from openfermion.linalg.givens_rotations import givens_decomposition_square
from openfermion.circuits.primitives import optimal_givens_decomposition

from scipy.sparse import csc_matrix
from scipy.linalg import expm
from scipy.special import binom
import scipy as sp
```

--------------------------------

### Initialize full Hilbert space wavefunction

Source: https://quantumai.google/openfermion/fqe/tutorials/fqe_vs_openfermion_quadratic_hamiltonians

Sets up a computational basis state corresponding to a Slater determinant.

```python
# set up initial full Hilbert space wavefunction
wfn = np.zeros((2**(norbs), 1), dtype=np.complex128)
wfn[int("".join([str(x) for x in [1] * (norbs//2) + [0] * (norbs//2)]), 2), 0] = 1  # alpha1-alpha2 Hartree-Fock state
```

--------------------------------

### Initialize Hartree-Fock Wavefunction

Source: https://quantumai.google/openfermion/fqe/tutorials/diagonal_coulomb_evolution

Sets up a Hartree-Fock wavefunction for 4 orbitals and 2 electrons with Sz=0.

```python
norbs = 4
tedim = norbs * (norbs + 1) // 2
if (norbs // 2) % 2 == 0:
    n_elec = norbs // 2
else:
    n_elec = (norbs // 2) + 1
sz = 0
fqe_wfn = fqe.Wavefunction([[n_elec, sz, norbs]])
fci_data = fqe_wfn.sector((n_elec, sz))
fci_graph = fci_data.get_fcigraph()
hf_wf = np.zeros((fci_data.lena(), fci_data.lenb()), dtype=np.complex128)
hf_wf[0, 0] = 1  # right most bit is zero orbital.
fqe_wfn.set_wfn(strategy='from_data',
                raw_data={(n_elec, sz): hf_wf})
fqe_wfn.print_wfn()
```

--------------------------------

### Initialize and Manipulate QubitOperators

Source: https://quantumai.google/openfermion/tutorials/intro_to_openfermion

Shows how to initialize QubitOperators and perform arithmetic operations, noting that terms are automatically sorted by tensor factor.

```python
from openfermion.ops import QubitOperator

my_first_qubit_operator = QubitOperator('X1 Y2 Z3')
print(my_first_qubit_operator)
print(my_first_qubit_operator.terms)

operator_2 = QubitOperator('X3 Z4', 3.17)
operator_2 -= 77. * my_first_qubit_operator
print('')
print(operator_2)
```

--------------------------------

### Simulate Time Evolution with Matrix Exponentiation

Source: https://quantumai.google/openfermion/tutorials/intro_workshop_exercises

Applies time evolution to an initial state using direct matrix exponentiation of the Hamiltonian. This method is suitable for smaller systems where matrix exponentiation is feasible. Requires NumPy and OpenFermion.

```python
# Create a random initial state
initial_state = of.haar_random_vector(2**n_qubits)

# Set evolution time
time = 1.0

# Apply exp(-i H t) to the state
final_state = linalg.expm_multiply(-1j * quad_ham_sparse * time, initial_state)
```

--------------------------------

### Initialize BosonOperator with Tuple and String

Source: https://quantumai.google/openfermion/tutorials/bosonic_operators

Demonstrates two ways to initialize a BosonOperator: using a tuple of tuples representing operators and modes, and using a string-based syntax. The printed output shows the sorted order of operators due to their commutation relations.

```python
from openfermion.ops import BosonOperator

my_term = BosonOperator(((3, 1), (5, 0), (4, 1), (1, 0)))
print(my_term)

my_term = BosonOperator('3^ 5 4^ 1')
print(my_term)
```

--------------------------------

### Import Required Libraries

Source: https://quantumai.google/openfermion/fqe/tutorials/diagonal_coulomb_evolution

Imports necessary modules for FQE, OpenFermion, and numerical operations.

```python
from itertools import product
import fqe
from fqe.hamiltonians.diagonal_coulomb import DiagonalCoulomb

import numpy as np

import openfermion as of

from scipy.linalg import expm
```

--------------------------------

### Utilize FermionOperator Utility Methods

Source: https://quantumai.google/openfermion/tutorials/intro_to_openfermion

Demonstrates common utility functions such as Hermitian conjugation, normal ordering, and commutator calculation.

```python
from openfermion.utils import commutator, count_qubits, hermitian_conjugated
from openfermion.transforms import normal_ordered

# Get the Hermitian conjugate of a FermionOperator, count its qubit, check if it is normal-ordered.
term_1 = FermionOperator('4^ 3 3^', 1. + 2.j)
print(hermitian_conjugated(term_1))
print(term_1.is_normal_ordered())
print(count_qubits(term_1))

# Normal order the term.
term_2 = normal_ordered(term_1)
print('')
print(term_2)
print(term_2.is_normal_ordered())

# Compute a commutator of the terms.
print('')
print(commutator(term_1, term_2))
```
Tokens:
Raw