// Checks if any errors occur while building Hamiltonian for both index conventions.
public void BuildFermionHamiltonian()
{
var sourceHamiltonian = new OrbitalIntegralHamiltonian();
sourceHamiltonian.Add(orbitalIntegrals);
var targetHamiltonian0 = sourceHamiltonian.ToFermionHamiltonian(IndexConvention.HalfUp);
var targetHamiltonian1 = sourceHamiltonian.ToFermionHamiltonian(IndexConvention.UpDown);
}
static void SimulateHubbardHamiltonianTest()
{
//////////////////////////////////////////////////////////////////////////
// Introduction //////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// In this example, we will estimate the ground state energy of
// 1D Hubbard Hamiltonian using the quantum chemistry library.
// The 1D Hubbard model has `n` sites. Let `i` be the site index,
// `s` = 1,0 be the spin index, where 0 is up and 1 is down, `t` be the
// hopping coefficient, `u` the repulsion coefficient, and aᵢₛ the fermionic
// annihilation operator on the fermion indexed by `(i,s)`. The Hamiltonian
// of this model is
//
// H ≔ - t Σᵢ (a†ᵢₛ aᵢ₊₁ₛ + a†ᵢ₊₁ₛ aᵢₛ) + u Σᵢ a†ᵢ₀ a†ᵢ₁ aᵢ₁ aᵢ₀
//
// Note that we use closed boundary conditions.
#region Building the Hubbard Hamiltonian through orbital integrals
var t = 0.2; // hopping coefficient
var u = 1.0; // repulsion coefficient
var nSites = 6; // number of sites;
// Construct Hubbard Hamiltonian
var hubbardOrbitalIntegralHamiltonian = new OrbitalIntegralHamiltonian();
foreach (var i in Enumerable.Range(0, nSites))
{
hubbardOrbitalIntegralHamiltonian.Add(new OrbitalIntegral(new[] { i, (i + 1) % nSites }, -t));
hubbardOrbitalIntegralHamiltonian.Add(new OrbitalIntegral(new[] { i, i, i, i }, u));
}
// Create fermion representation of Hamiltonian
// In this case, we use the spin-orbital to integer
// indexing convention `x = orbitalIdx + spin * nSites`; as it
// minimizes the length of Jordan–Wigner strings
var hubbardFermionHamiltonian = hubbardOrbitalIntegralHamiltonian.ToFermionHamiltonian(IndexConvention.HalfUp);
#endregion
#region Estimating energies by simulating quantum phase estimation
// Create Jordan–Wigner representation of Hamiltonian
var jordanWignerEncoding = hubbardFermionHamiltonian.ToPauliHamiltonian();
// Create data structure to pass to QSharp.
var qSharpData = jordanWignerEncoding.ToQSharpFormat().Pad();
Console.WriteLine($"Estimate Hubbard Hamiltonian energy:");
#endregion
}
/// <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 void JsonEncoding()
{
var filename = "Broombridge/broombridge_v0.2.yaml";
Data broombridge = Deserializers.DeserializeBroombridge(filename);
var problemData = broombridge.ProblemDescriptions.First();
OrbitalIntegralHamiltonian orbitalIntegralHamiltonian = problemData.OrbitalIntegralHamiltonian;
FermionHamiltonian original = orbitalIntegralHamiltonian.ToFermionHamiltonian(IndexConvention.HalfUp);
var json = JsonConvert.SerializeObject(original);
File.WriteAllText("fermion.original.json", json);
var serialized = JsonConvert.DeserializeObject <FermionHamiltonian>(json);
File.WriteAllText("fermion.serialized.json", JsonConvert.SerializeObject(serialized));
Assert.Equal(original.SystemIndices.Count, serialized.SystemIndices.Count);
Assert.Equal(original.Terms.Count, serialized.Terms.Count);
Assert.Equal(original.Norm(), serialized.Norm());
Assert.Equal(original.ToString(), serialized.ToString());
}
/// <summary>
/// Loads a FermionHamiltonian from either a .yaml file with a Broombridge definition,
/// or from a ProblemDescription.
/// If the fileName is specified, that will be used and the problemDescription will be ignored.
/// </summary>
public Task <ExecutionResult> Run(string input, IChannel channel)
{
if (string.IsNullOrWhiteSpace(input))
{
channel.Stderr("Please provide the name of a Broombridge file or a problem description to load the fermion Hamiltonian from.");
return(Task.FromResult(ExecuteStatus.Error.ToExecutionResult()));
}
// Identify the ProblemDescription with the hamiltonian from the arguments.
var args = JsonConvert.DeserializeObject <Arguments>(input);
var problemData = SelectProblemDescription(args);
// 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(args.IndexConvention);
return(Task.FromResult(fermionHamiltonian.ToExecutionResult()));
}
static void Main(string[] args)
{
//////////////////////////////////////////////////////////////////////////
// Introduction //////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// In this example, we will estimate the ground state energy of
// 1D Hubbard Hamiltonian using the quantum chemistry library.
// The 1D Hubbard model has `n` sites. Let `i` be the site index,
// `s` = 1,0 be the spin index, where 0 is up and 1 is down, `t` be the
// hopping coefficient, `u` the repulsion coefficient, and aᵢₛ the fermionic
// annihilation operator on the fermion indexed by `(i,s)`. The Hamiltonian
// of this model is
//
// H ≔ - t Σᵢ (a†ᵢₛ aᵢ₊₁ₛ + a†ᵢ₊₁ₛ aᵢₛ) + u Σᵢ a†ᵢ₀ a†ᵢ₁ aᵢ₁ aᵢ₀
//
// Note that we use closed boundary conditions.
#region Building the Hubbard Hamiltonian through orbital integrals
var t = 0.2; // hopping coefficient
var u = 1.0; // repulsion coefficient
var nSites = 6; // number of sites;
// Construct Hubbard Hamiltonian
var hubbardOrbitalIntegralHamiltonian = new OrbitalIntegralHamiltonian();
foreach (var i in Enumerable.Range(0, nSites))
{
hubbardOrbitalIntegralHamiltonian.Add(new OrbitalIntegral(new[] { i, (i + 1) % nSites }, -t));
hubbardOrbitalIntegralHamiltonian.Add(new OrbitalIntegral(new[] { i, i, i, i }, u));
}
// Create fermion representation of Hamiltonian
// In this case, we use the spin-orbital to integer
// indexing convention `x = orbitalIdx + spin * nSites`; as it
// minimizes the length of Jordan–Wigner strings
var hubbardFermionHamiltonian = hubbardOrbitalIntegralHamiltonian.ToFermionHamiltonian(IndexConvention.HalfUp);
#endregion
#region Estimating energies by simulating quantum phase estimation
// Create Jordan–Wigner representation of Hamiltonian
var jordanWignerEncoding = hubbardFermionHamiltonian.ToPauliHamiltonian();
// Create data structure to pass to QSharp.
var qSharpData = jordanWignerEncoding.ToQSharpFormat().Pad();
Console.WriteLine($"Estimate Hubbard Hamiltonian energy:");
// Bits of precision in phase estimation.
var bits = 7;
// Repetitions to find minimum energy.
var reps = 5;
// Trotter step size
var trotterStep = 0.5;
using (var qsim = new QuantumSimulator())
{
for (int i = 0; i < reps; i++)
{
// EstimateEnergyByTrotterization
// Name should make clear that it does it by trotterized
var(phaseEst, energyEst) = GetEnergy.Run(qsim, qSharpData, bits, trotterStep).Result;
Console.WriteLine($"Rep #{i}: Energy estimate: {energyEst}; Phase estimate: {phaseEst}");
}
}
Console.WriteLine("Press Enter to continue...");
if (System.Diagnostics.Debugger.IsAttached)
{
Console.ReadLine();
}
#endregion
}