public void OrbitalIntegralEnumerateOrbitalSymmetriesTest(int i, int j, int k, int l, int elements)
{
OrbitalIntegral orbitalIntegral = new OrbitalIntegral(new int[] { i, j, k, l });
var orbitalIntegrals = orbitalIntegral.EnumerateOrbitalSymmetries();
Assert.Equal(elements, orbitalIntegrals.Length);
}
public void OrbitalIntegralEnumerateOrbitalSymmetriesTest(Int64 i, Int64 j, Int64 k, Int64 l, Int64 elements)
{
OrbitalIntegral orbitalIntegral = new OrbitalIntegral(new Int64[] { i, j, k, l });
var orbitalIntegrals = orbitalIntegral.EnumerateOrbitalSymmetries();
Assert.Equal(elements, orbitalIntegrals.Length);
}
public void OrbitalIntegralIndexTest()
{
var orb0 = new OrbitalIntegral(1.0);
var orb1 = new OrbitalIntegral(2.0);
var orb2 = new OrbitalIntegral(new[] { 1, 2, 3, 4 }, 0.5);
Assert.True(orb0 == orb1);
Assert.False(orb0 == orb2);
}
public void HydrogenOrbitalIntegrals()
{
// These orbital integrals represent terms in molecular Hydrogen
var orbitalIntegrals = new OrbitalIntegral[]
{
new OrbitalIntegral(new[] { 0, 0 }, -1.252477495),
new OrbitalIntegral(new[] { 1, 1 }, -0.475934275),
new OrbitalIntegral(new[] { 0, 0, 0, 0 }, 0.674493166),
new OrbitalIntegral(new[] { 0, 1, 0, 1 }, 0.181287518),
new OrbitalIntegral(new[] { 0, 1, 1, 0 }, 0.663472101),
new OrbitalIntegral(new[] { 1, 1, 1, 1 }, 0.697398010)
};
}
static void MakeHamiltonian()
{
// These orbital integrals are represented using the OrbitalIntegral
// data structure.
var energyOffset = 0.713776188;
var nElectrons = 2;
var orbitalIntegrals = new OrbitalIntegral[]
{
new OrbitalIntegral(new[] { 0, 0 }, -1.252477495),
new OrbitalIntegral(new[] { 1, 1 }, -0.475934275),
new OrbitalIntegral(new[] { 0, 0, 0, 0 }, 0.674493166),
new OrbitalIntegral(new[] { 0, 1, 0, 1 }, 0.181287518),
new OrbitalIntegral(new[] { 0, 1, 1, 0 }, 0.663472101),
new OrbitalIntegral(new[] { 1, 1, 1, 1 }, 0.697398010),
// Add the identity term
new OrbitalIntegral(new int[] { }, energyOffset)
};
// We initialize a fermion Hamiltonian data structure and add terms to it.
var fermionHamiltonian = new OrbitalIntegralHamiltonian(orbitalIntegrals).ToFermionHamiltonian();
// The Jordan–Wigner encoding converts the fermion Hamiltonian,
// expressed in terms of Fermionic operators, to a qubit Hamiltonian,
// expressed in terms of Pauli matrices. This is an essential step
// for simulating our constructed Hamiltonians on a qubit quantum
// computer.
var jordanWignerEncoding = fermionHamiltonian.ToPauliHamiltonian(Paulis.QubitEncoding.JordanWigner);
// We also need to create an input quantum state to this Hamiltonian.
// Let us use the Hartree–Fock state.
var fermionWavefunction = fermionHamiltonian.CreateHartreeFockState(nElectrons);
// This Jordan–Wigner data structure also contains a representation
// of the Hamiltonian and wavefunction made for consumption by the Q# algorithms.
var qSharpHamiltonianData = jordanWignerEncoding.ToQSharpFormat();
var qSharpWavefunctionData = fermionWavefunction.ToQSharpFormat();
var qSharpData = QSharpFormat.Convert.ToQSharpFormat(qSharpHamiltonianData, qSharpWavefunctionData);
Assert.True(fermionWavefunction.MCFData.Excitations.Keys.Single()
.ToIndices().SequenceEqual(new[] { 0, 1 })
);
}
void CheckTermPresent()
{
var hamiltonian = new OrbitalIntegralHamiltonian();
var addTerms0 = orbitalIntegrals.Select(o => (o, o.Coefficient.ToDoubleCoeff())).ToList();
hamiltonian.AddRange(addTerms0);
// Check that all terms present.
foreach (var term in addTerms0)
{
Assert.Equal(term.Item2, hamiltonian.GetTerm(term.o));
}
// Now check that indexing is by value and not by reference.
var newTerms0Copy = new[] {
new[] { 0, 0 },
new[] { 1, 1 },
new[] { 0, 0, 0, 0 },
new[] { 0, 1, 0, 1 },
new[] { 0, 1, 1, 0 },
new[] { 1, 1, 1, 1 }
}.Select(o => new OrbitalIntegral(o, 0.123));
foreach (var term in addTerms0.Zip(newTerms0Copy, (a, b) => (a.Item2.Value, b)))
{
Assert.Equal(term.Item1, hamiltonian.GetTerm(term.b).Value);
}
var orb = new OrbitalIntegral(new[] { 0, 1, 1, 0 }, 4.0);
Assert.Equal(new[] { 0, 1, 1, 0 }, orb.OrbitalIndices);
Assert.Equal(addTerms0[4].o.OrbitalIndices, orb.OrbitalIndices);
Debug.WriteLine($"Term type is { orb.TermType.ToString()}");
Debug.WriteLine($"Coefficient is { hamiltonian.Terms[orb.TermType][new OrbitalIntegral(orb.OrbitalIndices, orb.Coefficient)]}");
Debug.WriteLine($"Coefficient is { hamiltonian.Terms[orb.TermType][addTerms0[4].o]}");
Assert.True(0.663472101 == hamiltonian.Terms[orb.TermType][new OrbitalIntegral(orb.OrbitalIndices, orb.Coefficient)]);
}
static void Main(string[] args)
{
//////////////////////////////////////////////////////////////////////////
// Introduction //////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// In this example, we will create a spin-orbital representation of the molecular
// Hydrogen Hamiltonian `H`, given overlap coefficients for its one- and
// two - electron integrals.
// We when perform quantum phase estimation to obtain an estimate of
// the molecular Hydrogen ground state energy.
#region Building the Hydrogen Hamiltonian through orbital integrals
// One of the simplest representations of Hydrogen uses only two
// molecular orbitals indexed by `0` and `1`.
var nOrbitals = 2;
// This representation also has two occupied spin-orbitals.
var nElectrons = 2;
// The Coulomb repulsion energy between nuclei is
var energyOffset = 0.713776188;
// One-electron integrals are listed below
// <0|H|0> = -1.252477495
// <1|H|1> = -0.475934275
// Two-electron integrals are listed below
// <00|H|00> = 0.674493166
// <01|H|01> = 0.181287518
// <01|H|10> = 0.663472101
// <11|H|11> = 0.697398010
// Note that orbitals are assumed to be real. Moreover, indistinguishability
// of electrons means that the following integrals are equal.
// <PQ|H|RS> = <PR|H|QS> = <SQ|H|RP> = <SR|H|QP>
// = <QP|H|SR> = <RP|H|SQ> = <QS|H|PR> = <RS|H|PQ>
// Thus it suffices to specify just any one of these terms from each symmetry
// group.
// These orbital integrals are represented using the OrbitalIntegral
// data structure.
var orbitalIntegrals = new OrbitalIntegral[]
{
new OrbitalIntegral(new[] { 0, 0 }, -1.252477495),
new OrbitalIntegral(new[] { 1, 1 }, -0.475934275),
new OrbitalIntegral(new[] { 0, 0, 0, 0 }, 0.674493166),
new OrbitalIntegral(new[] { 0, 1, 0, 1 }, 0.181287518),
new OrbitalIntegral(new[] { 0, 1, 1, 0 }, 0.663472101),
new OrbitalIntegral(new[] { 1, 1, 1, 1 }, 0.697398010),
// Add the identity term
new OrbitalIntegral(new int[] { }, energyOffset)
};
// We initialize a fermion Hamiltonian data structure and add terms to it
var fermionHamiltonian = new OrbitalIntegralHamiltonian(orbitalIntegrals).ToFermionHamiltonian();
// These orbital integral terms are automatically expanded into
// spin-orbitals. We may print the Hamiltonian to see verify what it contains.
Console.WriteLine("----- Print Hamiltonian");
Console.Write(fermionHamiltonian);
Console.WriteLine("----- End Print Hamiltonian \n");
// We also need to create an input quantum state to this Hamiltonian.
// Let us use the Hartree–Fock state.
var fermionWavefunction = fermionHamiltonian.CreateHartreeFockState(nElectrons);
#endregion
#region Jordan–Wigner representation
// The Jordan–Wigner encoding converts the fermion Hamiltonian,
// expressed in terms of Fermionic operators, to a qubit Hamiltonian,
// expressed in terms of Pauli matrices. This is an essential step
// for simulating our constructed Hamiltonians on a qubit quantum
// computer.
Console.WriteLine("----- Creating Jordan–Wigner encoding");
var jordanWignerEncoding = fermionHamiltonian.ToPauliHamiltonian(Paulis.QubitEncoding.JordanWigner);
Console.WriteLine("----- End Creating Jordan–Wigner encoding \n");
// Print the Jordan–Wigner encoded Hamiltonian to see verify what it contains.
Console.WriteLine("----- Print Hamiltonian");
Console.Write(jordanWignerEncoding);
Console.WriteLine("----- End Print Hamiltonian \n");
#endregion
#region Performing the simulation
// We are now ready to run a quantum simulation of molecular Hydrogen.
// We will use this to obtain an estimate of its ground state energy.
// Here, we make an instance of the simulator used to run our Q# code.
using (var qsim = new QuantumSimulator())
{
// This Jordan–Wigner data structure also contains a representation
// of the Hamiltonian and wavefunction made for consumption by the Q# algorithms.
var qSharpHamiltonianData = jordanWignerEncoding.ToQSharpFormat();
var qSharpWavefunctionData = fermionWavefunction.ToQSharpFormat();
var qSharpData = QSharpFormat.Convert.ToQSharpFormat(qSharpHamiltonianData, qSharpWavefunctionData);
// We specify the bits of precision desired in the phase estimation
// algorithm
var bits = 7;
// We specify the step-size of the simulated time-evolution
var trotterStep = 0.4;
// Choose the Trotter integrator order
Int64 trotterOrder = 1;
// As the quantum algorithm is probabilistic, let us run a few trials.
// This may be compared to true value of
Console.WriteLine("Exact molecular Hydrogen ground state energy: -1.137260278.\n");
Console.WriteLine("----- Performing quantum energy estimation by Trotter simulation algorithm");
for (int i = 0; i < 5; i++)
{
// EstimateEnergyByTrotterization
// Name should make clear that it does it by trotterized
var(phaseEst, energyEst) = GetEnergyByTrotterization.Run(qsim, qSharpData, bits, trotterStep, trotterOrder).Result;
Console.WriteLine($"Rep #{i+1}/5: Energy estimate: {energyEst}; Phase estimate: {phaseEst}");
}
Console.WriteLine("----- End Performing quantum energy estimation by Trotter simulation algorithm\n");
Console.WriteLine("----- Performing quantum energy estimation by Qubitization simulation algorithm");
for (int i = 0; i < 1; i++)
{
// EstimateEnergyByTrotterization
// Name should make clear that it does it by trotterized
var(phaseEst, energyEst) = GetEnergyByQubitization.Run(qsim, qSharpData, bits).Result;
Console.WriteLine($"Rep #{i+1}/1: Energy estimate: {energyEst}; Phase estimate: {phaseEst}");
}
Console.WriteLine("----- End Performing quantum energy estimation by Qubitization simulation algorithm\n");
}
Console.WriteLine("Press Enter to continue...");
if (System.Diagnostics.Debugger.IsAttached)
{
Console.ReadLine();
}
#endregion
}
static void MolecularHydrogenTest()
{
//////////////////////////////////////////////////////////////////////////
// Introduction //////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
// In this example, we will create a spin-orbital representation of the molecular
// Hydrogen Hamiltonian `H`, given ovelap coefficients for its one- and
// two - electron integrals.
// We when perform quantum phase estimation to obtain an estimate of
// the molecular Hydrogen ground state energy.
#region Building the Hydrogen Hamiltonian through orbital integrals
// One of the simplest representations of Hydrogen uses only two
// molecular orbitals indexed by `0` and `1`.
var nOrbitals = 2;
// This representation also has two occupied spin-orbitals.
var nElectrons = 2;
// The Coulomb repulsion energy between nuclei is
var energyOffset = 0.713776188;
// One-electron integrals are listed below
// <0|H|0> = -1.252477495
// <1|H|1> = -0.475934275
// Two-electron integrals are listed below
// <00|H|00> = 0.674493166
// <01|H|01> = 0.181287518
// <01|H|10> = 0.663472101
// <11|H|11> = 0.697398010
// Note that orbitals are assumed to be real. Moreover, indistinguishability
// of electrons means that the following integrals are equal.
// <PQ|H|RS> = <PR|H|QS> = <SQ|H|RP> = <SR|H|QP>
// = <QP|H|SR> = <RP|H|SQ> = <QS|H|PR> = <RS|H|PQ>
// Thus it sufficies to specify just any one of these terms from each symmetry
// group.
// These orbital integrals are represented using the OrbitalIntegral
// data structure.
var orbitalIntegrals = new OrbitalIntegral[]
{
new OrbitalIntegral(new[] { 0, 0 }, -1.252477495),
new OrbitalIntegral(new[] { 1, 1 }, -0.475934275),
new OrbitalIntegral(new[] { 0, 0, 0, 0 }, 0.674493166),
new OrbitalIntegral(new[] { 0, 1, 0, 1 }, 0.181287518),
new OrbitalIntegral(new[] { 0, 1, 1, 0 }, 0.663472101),
new OrbitalIntegral(new[] { 1, 1, 1, 1 }, 0.697398010),
// Add the identity term
new OrbitalIntegral(new int[] { }, energyOffset)
};
// We initialize a fermion Hamiltonian data structure and add terms to it
var fermionHamiltonian = new OrbitalIntegralHamiltonian(orbitalIntegrals).ToFermionHamiltonian();
// These orbital integral terms are automatically expanded into
// spin-orbitals. We may print the Hamiltonian to see verify what it contains.
Console.WriteLine("----- Print Hamiltonian");
Console.Write(fermionHamiltonian);
Console.WriteLine("----- End Print Hamiltonian \n");
// We also need to create an input quantum state to this Hamiltonian.
// Let us use the Hartree–Fock state.
var fermionWavefunction = fermionHamiltonian.CreateHartreeFockState(nElectrons);
#endregion
#region Jordan–Wigner representation
// The Jordan–Wigner encoding converts the fermion Hamiltonian,
// expressed in terms of Fermionic operators, to a qubit Hamiltonian,
// expressed in terms of Pauli matrices. This is an essential step
// for simulating our constructed Hamiltonians on a qubit quantum
// computer.
Console.WriteLine("----- Creating Jordan–Wigner encoding");
var jordanWignerEncoding = fermionHamiltonian.ToPauliHamiltonian(Paulis.QubitEncoding.JordanWigner);
Console.WriteLine("----- End Creating Jordan–Wigner encoding \n");
#endregion
#region Performing the simulation
// We are now ready to run a quantum simulation of molecular Hydrogen.
// We will use this to obtain an estimate of its ground state energy.
// This Jordan–Wigner data structure also contains a representation
// of the Hamiltonian and wavefunction made for consumption by the Q# algorithms.
var qSharpHamiltonianData = jordanWignerEncoding.ToQSharpFormat();
var qSharpWavefunctionData = fermionWavefunction.ToQSharpFormat();
var qSharpData = QSharpFormat.Convert.ToQSharpFormat(qSharpHamiltonianData, qSharpWavefunctionData);
Console.WriteLine("Press Enter to continue...");
if (System.Diagnostics.Debugger.IsAttached)
{
Console.ReadLine();
}
#endregion
}
public void BuildFromOrbitalIntegrals(
OrbitalIntegral orbitalIntegral,
TermType.Fermion termType,
(int, int[], double)[] termsRaw)
public void LoadFromLiquidTest(string line, TermType.OrbitalIntegral termType, OrbitalIntegral term)
{
//var test = terms.Item1;
//string[] lines, FermionTermType termType, FermionTerm[] terms
var hamiltonian = LiQuiDSerializer.DeserializeSingleProblem(line).OrbitalIntegralHamiltonian;
Assert.True(hamiltonian.Terms.ContainsKey(termType));
// Check that expected terms are found
var orb = hamiltonian.Terms[termType].Keys.First();
// Check index
//Assert.True(term == orb);
// Check coefficient
Assert.Equal(term.Coefficient, hamiltonian.Terms[termType][term.ToCanonicalForm()].Value);
}