Program.cs

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using Microsoft.Quantum.Simulation.Core;
using Microsoft.Quantum.Simulation.Simulators;

namespace Microsoft.Quantum.Samples.SimpleIsing
{
    class Program
    {
        static void Main(string[] args)
        {

            #region Basic Definitions

            // We start by loading the simulator that we will use to run our Q# operations.
            var qsim = new QuantumSimulator();

            // For this example, we'll consider a chain of twelve sites, each one of which
            // is simulated using a single qubit.
            var nSites = 12;

            // We'll sweep from the transverse to the final Hamiltonian in time t = 10.0,
            // where the units are implicitly fixed by the units of the Hamiltonian itself.
            var sweepTime = 10.0;

            // Finally, we'll then decompose the time evolution down into small steps.
            // During each step, we'll perform each term in the Hamiltonian individually.
            // By the Trotter–Suzuki decomposition (also implemented in the canon), this
            // approximates the complete Hamiltonian for the entire sweep time.
            //
            // If we choose the evolution time carefully, we should prepare the ground
            // state of our final Hamiltonian (see the references in README.md for more
            // details).
            var timeStep = 0.1;

            // For diagnostic purposes, before we proceed to the next step, we'll print
            // out a description of the parameters we just defined.
            Console.WriteLine("Ising model ground state preparation:");
            Console.WriteLine($"\t{nSites} sites\n\t{sweepTime} sweep time\n\t{timeStep} time step");

            #endregion

            #region Calling into Q#

            // Now that we've defined everything we need, let's proceed to
            // actually call the simulator. Since there's a finite chance of successfully
            // preparing the ground state, we will call our new operation through
            // the simulator several times, reporting the magnetization after each attempt.

            foreach (var idxAttempt in Enumerable.Range(0, 100))
            {
                // Each operation has a static method called Run which takes a simulator as
                // an argument, along with all the arguments defined by the operation itself.
                var task = Ising.Run(qsim, nSites, sweepTime, timeStep);

                // Since this method is asynchronous, we need to explicitly
                // wait for the result back from the simulator. We do this by
                // getting the Result property. To turn the result back into a
                // conventional .NET array, we finish by calling ToArray() and
                // using a C# lambda function to convert each Result into a
                // floating point number representing the observed spin.
                var data = task.Result.ToArray().Select((result) => result == Result.One ? 0.5 : -0.5);

                // We can now compute the magnetization entirely in C# code,
                // since data is an array of the classical measurement results
                // observed back from our simulation.
                var magnetization = data.Sum();

                Console.WriteLine($"Magnetization observed in attempt {idxAttempt}: {magnetization}");

            }

            #endregion

            Console.WriteLine("Press Enter to continue...");
            Console.ReadLine();
        }
    }
}