/// <summary>
/// Default configuration constructor;
/// </summary>
public Config()
{
UseIndexConvention = IndexConvention.UpDown;
QubitEncoding UseQubitEncoding = QubitEncoding.JordanWigner;
UseTruncationThreshold = 1e-8;
}
// Takes in a standard Q# format and outputs interpretable data to text
// Input: Problem, state, indexConvention (default), qubitEncoding (default)
// Output: No output, see ToPauliHamiltonian for generated filed
public static void ToQSharpFormat(
ProblemDescription problem,
string state = "",
IndexConvention indexConvention = IndexConvention.UpDown,
QubitEncoding qubitEncoding = QubitEncoding.JordanWigner
)
{
var fermionHamiltonian = problem
.OrbitalIntegralHamiltonian
.ToFermionHamiltonian(indexConvention);
Auxiliary.ToPauliHamiltonian(fermionHamiltonian, qubitEncoding);
}
// Creates the file with fermion terms
// Input: FermionHamiltonian, encoding type (default)
// Output: Writes the fermion terms to a file
public static void ToPauliHamiltonian(
FermionHamiltonian sourceHamiltonian,
QubitEncoding encoding = QubitEncoding.JordanWigner)
{
var lines = new List <String>();
foreach (var termType in sourceHamiltonian.Terms)
{
foreach (var term in termType.Value)
{
lines.Add(Auxiliary.ToJordanWignerPauliTerms(term.Key, termType.Key, term.Value.Value));
}
}
System.IO.File.WriteAllLines("./_temp/_FermionTerms.txt", lines);
}
/// <summary>
/// Method for constructing a Pauli Hamiltonian from a fermion Hamiltonina.
/// </summary>
/// <param name="sourceHamiltonian">Input orbital integral Hamiltonian.</param>
/// <param name="encoding">Identifies how the terms should be encoded on the qubits.</param>
/// <returns>Fermion Hamiltonian constructed from orbital integrals.</returns>
public static PauliHamiltonian ToPauliHamiltonian(
this FermionHamiltonian sourceHamiltonian,
QubitEncoding encoding = QubitEncoding.JordanWigner)
{
var nFermions = sourceHamiltonian.SystemIndices.Max() + 1;
var hamiltonian = new PauliHamiltonian();
Func <FermionTerm, TermType.Fermion, double, IEnumerable <(PauliTerm, PauliTermValue)> > conversion =
(fermionTerm, termType, coeff)
=> (fermionTerm.ToJordanWignerPauliTerms(termType, coeff));
foreach (var termType in sourceHamiltonian.Terms)
{
foreach (var term in termType.Value)
{
hamiltonian.AddRange(conversion(term.Key, termType.Key, term.Value.Value));
}
}
// Create a copy of fermion indices hash set.
hamiltonian.SystemIndices = new HashSet <int>(sourceHamiltonian.SystemIndices.ToList());
return(hamiltonian);
}
/// <summary>
/// Converts an electronic structure problem description
/// into a format consumable by Q# using default settings.
/// </summary>
/// <param name="problem">Input electronic structure problem description.</param>
/// <param name="state">Selected wavefunction ansatz. This uses the Hartree–Fock state by default.</param>
/// <param name="indexConvention">Convention for mapping spin-orbit indices to integer indices.</param>
/// <param name="qubitEncoding">Scheme for mapping fermions to qubits.</param>
/// <returns>
/// A representation of <paramref name="problem" /> suitable for passing to Q# simulation operations.
/// </returns>
public static JordanWignerEncodingData ToQSharpFormat(
this ProblemDescription problem,
string state = "",
IndexConvention indexConvention = IndexConvention.UpDown,
QubitEncoding qubitEncoding = QubitEncoding.JordanWigner
)
{
var fermionHamiltonian = problem
.OrbitalIntegralHamiltonian
.ToFermionHamiltonian(indexConvention);
var wavefunction = problem.Wavefunctions.ContainsKey(state) ?
problem.Wavefunctions[state].ToIndexing(indexConvention) :
fermionHamiltonian.CreateHartreeFockState(problem.NElectrons);
var pauliHamiltonian = fermionHamiltonian.ToPauliHamiltonian(qubitEncoding);
var pauliHamiltonianQSharpFormat = pauliHamiltonian.ToQSharpFormat();
var wavefunctionQSharpFormat = wavefunction.ToQSharpFormat();
return(QSharpFormat.Convert.ToQSharpFormat(pauliHamiltonianQSharpFormat, wavefunctionQSharpFormat));
}
