static void Main(string[] args)
{
using (var qsim = new QuantumSimulator())
{
System.Console.WriteLine("Sum of 4 and 5 is");
var result = GetSum.Run(qsim, 4, 5).Result;
System.Console.WriteLine(result);
}
}
static void Main(string[] args)
{
using (var qsim = new QuantumSimulator())
{
var res = doTeleport.Run(qsim, Result.Zero, true, 1000).Result;
Console.WriteLine($"Did we succeed? {res}");
}
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
/// <summary>
/// Logs the seed used for the test run
/// </summary>
private void LogSimulatorSeed(TestOperation opData, QuantumSimulator sim)
{
// Frequently tests include measurement and randomness.
// To reproduce the failed test it is useful to record seed that has been used
// for the random number generator inside the simulator.
string msg = $"The seed, operation pair is (\"{ opData.fullClassName}\",{ sim.Seed})";
output.WriteLine(msg);
Debug.WriteLine(msg);
}
static void Main(string[] args)
{
using (var simulator = new QuantumSimulator())
{
var results = Measurement.Run(simulator).Result;
Console.WriteLine($"Measured result states: {results}.");
}
Console.ReadKey();
}
static void Main(string[] args)
{
using (var sim = new QuantumSimulator())
{
var result = Teleport.Run(sim).Result;
Console.WriteLine(result);
}
Console.ReadLine();
}
public void TestTarget(TestOperation op)
{
using (var sim = new QuantumSimulator())
{
// OnLog defines action(s) performed when Q# test calls function Message
sim.OnLog += (msg) => { output.WriteLine(msg); };
sim.OnLog += (msg) => { Debug.WriteLine(msg); };
op.TestOperationRunner(sim);
}
}
// Call quantum classification on the given training data for the given model parameter
// and return its success rate.
static double GetClassificationSuccessRate(double[] data, long[] labels, double angle)
{
double s = 0;
using (var qsim = new QuantumSimulator(true, 123))
{
s = QuantumClassifier_SuccessRate_Easy.Run(qsim, angle, new QArray <double>(data), new QArray <long>(labels)).Result;
}
return(s);
}
static void Main(string[] args)
{
using (var qsim = new QuantumSimulator())
{
var measured = random.Run(qsim).Result;
System.Console.WriteLine(
$"Measurement: {measured, 0}.");
}
}
static void Main(string[] args)
{
using (var sim = new QuantumSimulator())
{
var res = Add.Run(sim, 20, 10).Result;
Console.WriteLine(res);
}
Console.WriteLine("Press any key...");
Console.ReadKey();
}
static void Main(string[] args)
{
using (var qsim = new QuantumSimulator())
{
var res = CoinFlip.Run(qsim, 1000).Result;
var(numZeros, numOnes) = res;
System.Console.WriteLine(
$"0s={numZeros} 1s={numOnes}");
}
}
public void OperationTypes()
{
var op = new QuantumSimulator().Get <Intrinsic.H>();
Assert.Equal("H", op.GetNonQubitArgumentsAsString());
var op2 = new QuantumSimulator().Get <Intrinsic.CNOT>();
Assert.Equal("CNOT", op2.GetNonQubitArgumentsAsString());
}
static void Main(string[] args)
{
var sim = new QuantumSimulator(throwOnReleasingQubitsNotInZeroState: true);
var ones = Enumerable.Range(0, 1000).Where(w =>
TestState.Run(sim, 1).Result == Result.One).Count();
Console.WriteLine($"Ones: {ones}/1000");
Console.Read();
}
public void Run(QuantumSimulator qsim)
{
var initials = new Result[] { Result.Zero, Result.One };
foreach (var initial in initials)
{
var res = MakeTeleport.Run(qsim, initial).Result;
Console.WriteLine($"{initial} = {res}");
}
}
// tag::main[]
static void Main(string[] args)
{
System.Console.WriteLine("Pick a win probability for Morgana: ");
var winProbability = Double.Parse(System.Console.ReadLine());
using (var qsim = new QuantumSimulator())
{
PlayMorganasGame.Run(qsim, winProbability).Wait();
}
}
async public Task ProblemA4_1()
{
string dumpPath = Modules.GetTempFilepath();
using var sim = new QuantumSimulator();
long expect = 1;
long actual = await QSharpCodingContestSummer2020Warmup.ProblemA4.Driver.Run(sim, expect, dumpPath);
actual.Should().Be(expect);
}
async public Task ProblemG3_2()
{
var bits = new QArray <bool>(new bool[] { true, false, true, false });
string dumpPath = Modules.GetTempFilepath();
using var sim = new QuantumSimulator();
bool res = await QSharpCodingContestWinter2019Warmup.ProblemG3.Driver.Run(sim, bits, dumpPath);
res.Should().Be(false);
}
static void Main(string[] args)
{
var sim = new QuantumSimulator(throwOnReleasingQubitsNotInZeroState: true);
//データベースのサイズ(databaseSize)Nに対する
//必要な量子ビット数(nDatabaseQubits)n. N=2^n
var nDatabaseQubits = 8;
var databaseSize = Math.Pow(2.0, nDatabaseQubits);
//探索対象のビットのIndex。IndexはdatabaseSizeより小さい必要がある。
var markedElements = new QArray <long>()
{
0, 39, 101, 234
};
var nMarkedElements = markedElements.Length;
//振幅増幅を繰り返す回数k。
//確率をほぼ1にするためには PI/4*Sqrt(N)-1/2なので、N=2^8なら12回程度必要。
var nIterations = 3;
// データベースに対する問い合わせ数
var queries = nIterations * 2 + 1;
// 期待される確率を計算して、実際の結果と比較する
// 古典アルゴリズムでの確率は、N個から1つ探す確率なので
var classicalSuccessProbability = (double)(nMarkedElements) / databaseSize;
// Groverアルゴリズムでの確率sin^2[(2*k+1)θ]。ただしsinθ=Sqrt(1/N)
var quantumSuccessProbability = Math.Pow(Math.Sin((2.0 * (double)nIterations + 1.0) * Math.Asin(Math.Sqrt(nMarkedElements) / Math.Sqrt(databaseSize))), 2.0);
var repeats = 10;
var successCount = 0;
Console.Write(
$@"
Quantum search for marked element in database.
データベースのサイズ: {databaseSize}
古典アルゴリズムでの確率: {classicalSuccessProbability}
1回当たりの問い合わせ数: {queries}
量子アルゴリズムでの確率: {quantumSuccessProbability}
");
foreach (var idxAttempt in Enumerable.Range(0, repeats))
{
var(markedQubit, databaseRegister) = ApplyGroverSearch.Run(sim, markedElements, nIterations, nDatabaseQubits).GetAwaiter().GetResult();
successCount += markedQubit == Result.One ? 1 : 0;
var empiricalSuccessProbability = Math.Round((double)successCount / ((double)idxAttempt + 1), 3);
var speedupFactor = Math.Round(empiricalSuccessProbability / classicalSuccessProbability / (double)queries, 3);
Console.WriteLine($"試行回数 {idxAttempt}. 成功: {markedQubit}, 確率: {empiricalSuccessProbability} 高速化比: {speedupFactor} 検出したインデックス {databaseRegister}");
}
}
static void Main(string[] args)
{
using (var qsim = new QuantumSimulator())
{
var watch = System.Diagnostics.Stopwatch.StartNew();
//Uncomment the following for Deutsch Josze
System.Console.WriteLine("Result for Deutsch Josze Algorithm:");
Run_DeutschJozsa_Algorithm.Run(qsim).Wait();
//Uncomment the following for Bernstein Vazirani
/*
* int n = 10;
* long[] a = new long[n];
* Random r = new Random();
* for(int i = 0; i < n; i++) {
* a[i] = r.Next(0, 2);
* }
* var res = Run_BernsteinVazirani_Algorithm.Run(qsim, new QArray<long>(a)).Result;
* if(res.Equals("Success!")) {
* System.Console.WriteLine("Result for Bernstein Vazirani Algorithm:");
* for(int i = 0; i < n; i++) {
* System.Console.Write(a[i] + " ");
* }
* System.Console.WriteLine();
* } else {
* System.Console.WriteLine("incorrect");
* }
*/
//Uncomment the following for Simon's
/*
* var res = Run_Simon_Algorithm.Run(qsim).Result;
* System.Console.WriteLine("Result for Simon's Algorithm:");
* System.Console.WriteLine(res);
*/
//Uncomment the following for Grover's
/*
* var res = Run_Grovers_Algorithm.Run(qsim).Result;
* System.Console.WriteLine("Result for Grover's Algorithm:");
* System.Console.WriteLine(res);
*/
watch.Stop();
double totalTime = watch.ElapsedMilliseconds / 1000.0;
System.Console.WriteLine("Time elapsed: " + totalTime);
}
}
static void Main(string[] args)
{
var numberOfSameState = 0;
var numberOfDifferentStates = 0;
var numberOfOnes = 0;
var numberOfZeros = 0;
using (var qsim = new QuantumSimulator())
{
for (int k = 0; k < 1000; k++)
{
// Compare two Qubits colapsed state after entanglement
var(qubitOneResult, qubitTwoResult) = Entanglement.Run(qsim).Result;
if (qubitOneResult == qubitTwoResult)
{
numberOfSameState++;
}
else
{
numberOfDifferentStates++;
}
if (qubitOneResult == Result.One)
{
numberOfOnes++;
}
else
{
numberOfZeros++;
}
if (qubitTwoResult == Result.One)
{
numberOfOnes++;
}
else
{
numberOfZeros++;
}
}
}
Console.WriteLine("==============================================");
Console.WriteLine("========= Entanglement Calculations ==========");
Console.WriteLine("==============================================");
Console.WriteLine();
Console.WriteLine($"Number of ONES: {numberOfOnes}, Number of ZEROS: {numberOfZeros}");
Console.WriteLine($"Entangled matched: {numberOfSameState} Entangled mismatched: {numberOfDifferentStates}");
Console.WriteLine($"Even though the value might be different we expect ALL entagled Qubits to match.");
Console.WriteLine();
Console.ReadKey();
}
static void Main(string[] args)
{
using (var qsim = new QuantumSimulator())
{
Result[] init = new Result[] { Result.Zero, Result.One };
var res = Bells.Run(qsim, 1000).Result;
var(z, o) = res;
Console.WriteLine("Valores O: " + z);
Console.WriteLine("Valores 1: " + o);
}
}
static string PerformEstimation(int[] uValues)
{
using (var qsim = new QuantumSimulator())
{
var phase = ApplyPhaseEstimation.Run(qsim, new QArray <Result>(uValues.Cast <Result>()))
.Result
.Cast <int>()
.ToArray();
return(string.Join("", phase));
}
}
static void Main(string[] args)
{
using (var sim = new QuantumSimulator())
{
var res = WuhanJiaYou.Run(sim).Result;
System.Console.WriteLine(
$"{res}");
}
System.Console.WriteLine("一键删除所有新冠病毒...");
System.Console.ReadKey();
}
static async Task Main(string[] args)
{
var tau = 5.31;
var qspResult = QSP.JacobiAngerExpansion(1.0e-20, tau);
var dirs = new QArray <double>(QSP.ConvertToAnglesForParity01(qspResult));
using var qsim = new QuantumSimulator();
await SampleHamiltonianEvolutionByQSP.Run(qsim, tau, dirs);
Console.WriteLine("JacobiAnger QSP Done.");
}
public void Test()
{
using (var qsim = new QuantumSimulator())
{
TestBell(qsim);
TestEntanglement(qsim);
}
System.Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
static void Main(string[] args)
{
// We start by loading the simulator that we will use to run our Q# operations.
using (var qsim = new QuantumSimulator())
{
Console.WriteLine("Starting simulation\n");
// Define the costs of journey segments
double[] segmentCosts = { 4.70, 9.09, 9.03, 5.70, 8.02, 1.71 };
// Define the penalty for constraint violation
double penalty = 20.0;
// Here are some magic QAOA parameters that we got by lucky guessing.
// Theoretically, they should yield the optimal solution in 70.6% of trials.
double[] dtx = { 0.619193, 0.742566, 0.060035, -1.568955, 0.045490 };
double[] dtz = { 3.182203, -1.139045, 0.221082, 0.537753, -0.417222 };
// Convert parameters to QArray<Double> to pass them to Q#
var tx = new QArray <Double>(dtx);
var tz = new QArray <Double>(dtz);
var costs = new QArray <Double>(segmentCosts);
var bestCost = 100.0 * penalty;
var bestItinerary = new bool[6];
var successNumber = 0;
for (int trial = 0; trial < 20; trial++)
{
var result = QAOA_santa.Run(qsim, costs, penalty, tx, tz, 5).Result;
var tmp = result.ToArray <bool>();
var cost = Cost(segmentCosts, tmp);
var sat = Satisfactory(tmp);
Console.WriteLine($"result = {result}, cost = {cost}, satisfactory = {sat}");
if (sat)
{
if (cost < bestCost - 1E-6)
{
// New best cost found - update
bestCost = cost;
Array.Copy(tmp, bestItinerary, 6);
successNumber = 1;
}
else if (Math.Abs(cost - bestCost) < 1E-6)
{
successNumber++;
}
}
}
Console.WriteLine("Simulation is complete\n");
Console.WriteLine($"Best itinerary found: {bestItinerary}, cost = {bestCost}");
Console.WriteLine($"{successNumber * 100.0 / 20}% of runs found the best itinerary\n");
Console.WriteLine("Press any key to continue\n");
Console.ReadKey();
}
}
static void Main(string[] args)
{
/*using (var qsim = new QuantumSimulator()) // Only for hello quantum
* {
* HelloQ.Run(qsim).Wait();
* }*/
using (var qsim = new QuantumSimulator())
{
Entanglement.Run(qsim).Wait();
}
}
private static string RunManyTimes <T>(this QuantumSimulator sim, Func <QuantumSimulator, Task <T> > op, int count, Func <T, string> format)
{
var results =
from i in Enumerable.Range(0, count)
let result = op(sim).Result
let pattern = format(result)
group pattern by pattern into g
select new { Ket = $"|{g.Key}>", Count = g.Count() };
return($"[\n\t{String.Join(",\n\t", results)}\n]");
}
static void Main(string[] args)
{
using (var sim = new QuantumSimulator())
{
var res = FuckYouGithub.Run(sim).Result;
System.Console.WriteLine(
$"{res}");
}
System.Console.WriteLine("Press any key to continue...");
System.Console.ReadKey();
}
static void Main(string[] args)
{
using (var sim = new QuantumSimulator())
{
var s1 = test.Run(sim).Result;
Console.WriteLine(s1);
}
Console.WriteLine("按任意键继续...");
Console.ReadKey();
}
static void Main(string[] args)
{
using (var sim = new QuantumSimulator())
{
var result = Hadamard.Run(sim).Result;
(long a, long b) = result;
Console.WriteLine(a);
Console.WriteLine(b);
Console.ReadKey();
}
}
