ToDo list

[RichRick1]

Programs:

1. TriQS
2. Wannier90

Output formats:

1. FciDump <-- write a function
2. Triqs <--
3. Numpy arrays
4. Sparse arrays

API:
Super class --> HamiltonianInterface
methods:

1. to_fcidmp
2. to_triqs
3. to_array
4. to_sparse
5. dense_output
   All need to support different integrals

---

HamiltonianInterface:

1. Zero, one, two body integrals (three separate methods in different representations)
   a. Overlap
   b. Split to kinetic and potential (optional)
2. Full output and/or p<q and r<s <-- have an option to support symmetry (2-fold, 4-fold, 8-fold)
3. Transformation between occupation and spinorbital basis
4. Build a system constructor for the input in HamiltonianInterface | for later

---

Tests:

1. Take a look for systems that have exact solutions/numerical solution/just known
2. Use exact diagonalization

---

Transformation between occupation and spinorbital basis

[PaulWAyers]

Other important quantum chemistry codes: Psi4 and PySCF. This would be sort of like supporting TRIQS, in terms of flavor. For TRIQS, it looks like the most explicit generalized 2-electron term can used directly.

[RichRick1]

1. Create a HamiltonianPPP that inherits (HamiltonianAPI) class
2. Copy all of the methods from abstract class (except the line @abstractmethod)
3. Start working on to_fcidump
4. Create an abstract method called to_dense

[RichRick1]

1. Tweak an API + Writing Output (Rick and Addison)
2. Share symmetry converting (Michael)
3. Start working on Spin Hamiltonian
4. Write for converting basis (Gabby + Ayse)

---

Do a research in Rauk's dictionary

[msricher]

Symmetry for one-particle integrals:
1-fold: [(i, j)]
2-fold: [(i, j) == (j, i)]

Symmetry for two-particle integrals:
1-fold: [(i, j, k, l)]
2-fold: [(i, j, k, l) == (k, l, i, j)]
4-fold: [(i, j, k, l) == (j, i, l, k) == (k, l, i, j) == (l, k, j, i)]
8-fold: [(i, j, k, l) == (j, i, k, l) == (i, j, l, k) == (j, i, l, k) == (k, l, i, j) == (l, k, i, j) == (k, l, j, i) == (l, k, j, i)]

So, when you're generating the sparse arrays, you only need those unique elements.
Output formats like FCIDUMP also only require the unique elements, so it's good to have this.

[PaulWAyers]

Important to note here that depending on notation, in the 8-fold symmetry half the integrals have a minus sign. (specifically (j,i,k,l); (i,j,l,k), (l,k,i,j), (k,l,j,i)). If the idea is matrix elements of creator/annhilators (as opposed to just functions) this happens.

[RichRick1]

1. Convert to chemical notation before writing to fcidump and reduce_sym
2. Rewrite to_fcidump without iterating through indices
3. Rewrite to_dense function so that user don't need to insert size. Size can be taken from connectivity matrix.shape[0] * 2

[RichRick1]

1. Have a connectivity matrix
2. Add function convert_inices() that convert index from 4d to 2d in utils.py
3. Every time when we work with 2body integral we should call this function and than deal as regular numpy array

[RichRick1]

1. Rewrite an API so that it has attribute sym
2. Create a PPP class and start working on populating one and two body integral

[RichRick1]

1. Add support of symmetry to one body term (@RichRick1 )
2. Add support of symmetry and basis (using @gabrielasd code) for two body term (@adsrichards)
3. Start writing documentation @msricher

Test:

• 2 Hubbard model @RichRick1
• Lieb Wu formula for 1d chain @adsrichards
• Add the PPP Hamiltonian and the DMGR Method @RichRick1
• Try to use the hybridization-expansion solver from here @gabrielasd