/// <summary>
/// Sample implementation of end-to-end electronic structure problem simulation.
/// </summary>
/// <param name="filename"></param>
public static void SampleWorkflow(
string filename,
string wavefunctionLabel,
IndexConvention indexConvention
)
{
// Deserialize Broombridge from file.
Data broombridge = Deserializers.DeserializeBroombridge(filename);
// A single file can contain multiple problem descriptions. Let us pick the first one.
var problemData = broombridge.ProblemDescriptions.First();
#region Create electronic structure Hamiltonian
// Electronic structure Hamiltonians are usually represented compactly by orbital integrals. Let us construct
// such a Hamiltonian from broombridge.
OrbitalIntegralHamiltonian orbitalIntegralHamiltonian = problemData.OrbitalIntegralHamiltonian;
// We can obtain the full fermion Hamiltonian from the more compact orbital integral representation.
// This transformation requires us to pick a convention for converting a spin-orbital index to a single integer.
// Let us pick one according to the formula `integer = 2 * orbitalIndex + spinIndex`.
FermionHamiltonian fermionHamiltonian = orbitalIntegralHamiltonian.ToFermionHamiltonian(indexConvention);
// We target a qubit quantum computer, which requires a Pauli representation of the fermion Hamiltonian.
// A number of mappings from fermions to qubits are possible. Let us choose the Jordan–Wigner encoding.
PauliHamiltonian pauliHamiltonian = fermionHamiltonian.ToPauliHamiltonian(QubitEncoding.JordanWigner);
#endregion
#region Create wavefunction Ansatzes
// A list of trial wavefunctions can be provided in the Broombridge file. For instance, the wavefunction
// may be a single-reference Hartree--Fock state, a multi-reference state, or a unitary coupled-cluster state.
// In this case, Broombridge indexes the fermion operators with spin-orbitals instead of integers.
Dictionary <string, FermionWavefunction <SpinOrbital> > inputStates = problemData.Wavefunctions ?? new Dictionary <string, FermionWavefunction <SpinOrbital> >();
// If no states are provided, use the Hartree--Fock state.
// As fermion operators the fermion Hamiltonian are already indexed by, we now apply the desired
// spin-orbital -> integer indexing convention.
FermionWavefunction <int> inputState = inputStates.ContainsKey(wavefunctionLabel)
? inputStates[wavefunctionLabel].ToIndexing(indexConvention)
: fermionHamiltonian.CreateHartreeFockState(problemData.NElectrons);
#endregion
#region Pipe to QSharp and simulate
// We now convert this Hamiltonian and a selected state to a format that than be passed onto the QSharp component
// of the library that implements quantum simulation algorithms.
var qSharpHamiltonian = pauliHamiltonian.ToQSharpFormat();
var qSharpWavefunction = inputState.ToQSharpFormat();
var qSharpData = QSharpFormat.Convert.ToQSharpFormat(qSharpHamiltonian, qSharpWavefunction);
#endregion
}
public async Task <ExecutionResult> Run(string input, IChannel channel)
{
var args = JsonConvert.DeserializeObject <Arguments>(input);
// We target a qubit quantum computer, which requires a Pauli representation of the fermion Hamiltonian.
// A number of mappings from fermions to qubits are possible. Let us choose the Jordan-Wigner encoding.
PauliHamiltonian pauliHamiltonian = args.Hamiltonian.ToPauliHamiltonian(QubitEncoding.JordanWigner);
// We now convert this Hamiltonian and a selected state to a format that than be passed onto the QSharp component
// of the library that implements quantum simulation algorithms.
var qSharpHamiltonian = pauliHamiltonian.ToQSharpFormat();
var qSharpWavefunction = args.Wavefunction.ToQSharpFormat();
var qSharpData = Microsoft.Quantum.Chemistry.QSharpFormat.Convert.ToQSharpFormat(qSharpHamiltonian, qSharpWavefunction);
return(qSharpData.ToExecutionResult());
}
// Creates the typical JordanWignerEncodingData given the JSON input + the index of the interaction to use
// Input: full JSON, index of interaction to use
// Output: JordanWignerEncodingData to use with Q#
public static JordanWignerEncodingData ConvertOneToJWED(
JObject OptimizedHamiltonian,
int index
)
{
// begin initial converstion to Q# files
PauliHamiltonian hamiltonianQSharpFormat = CallQSharpPipeline(OptimizedHamiltonian, index);
var inputState = CreateJWInputState(OptimizedHamiltonian);
// convert to refined Q# format
var pauliHamiltonianQSharpFormat = hamiltonianQSharpFormat.ToQSharpFormat();
var(energyOffset, trash, trash2) = pauliHamiltonianQSharpFormat;
return(QSharpFormat.Convert.ToQSharpFormat(pauliHamiltonianQSharpFormat, inputState));
}