void RemoveSingleCells(ref Superposition[,] newSuperpositon, Superposition[,] existingSuperpositions,
Superposition empty, int neighbourLimit, int iterations)
{
for (int k = 0; k < iterations; k++)
{
int removed = 0;
for (int i = 0; i < existingSuperpositions.GetLength(0); i++)
{
for (int j = 0; j < existingSuperpositions.GetLength(1); j++)
{
// If tile is not white - check the neighbours.
if (existingSuperpositions[i, j].state != State.EMPTY)
{
// Count all the neighbours that are not white.
var neighbours = CountNotEmptyNeighbours(i, j, existingSuperpositions);
if (neighbours < neighbourLimit)
{
newSuperpositon[i, j] = empty;
newSuperpositon[i, j].state = State.EMPTY;
removed++;
}
}
}
}
Console.WriteLine("removed: " + removed);
}
}
static void Main(string[] args)
{
int ones = 0;
int zeros = 0;
// Show statistical propability of Superposition
using (var qsim = new QuantumSimulator())
{
for (int k = 0; k < 1000; k++)
{
var result = Superposition.Run(qsim).Result;
if (result == Result.One)
{
ones++;
}
else
{
zeros++;
}
}
}
Console.WriteLine("==============================================");
Console.WriteLine("======== Superposition Calculations ==========");
Console.WriteLine("==============================================");
Console.WriteLine();
Console.WriteLine($"Number of ONES: {ones}, Number of ZEROS: {zeros}");
Console.WriteLine($"With a 50% propability they should have a simular distribution");
Console.WriteLine();
Console.ReadKey();
}
public void SuperpositionManipulationTest()
{
tree = new MediationTree(testDomain, testProblem, pathSuper, false, false, true);
List <VirtualMediationTreeEdge> supers = new List <VirtualMediationTreeEdge>();
foreach (MediationTreeEdge edge in tree.Root.Outgoing)
{
if (edge is VirtualMediationTreeEdge)
{
supers.Add(edge as VirtualMediationTreeEdge);
}
}
Assert.AreEqual(supers.Count, 1);
VirtualMediationTreeNode node = tree.GetNode(tree.Root.Domain, tree.Root.Problem, supers[0]) as VirtualMediationTreeNode;
node = tree.GetNode(node.Domain, node.Problem, node.Outgoing.Find(x => x.Action.Name.Equals("toggle-green"))) as VirtualMediationTreeNode;
node = tree.GetNode(node.Domain, node.Problem, node.Outgoing[0]) as VirtualMediationTreeNode;
Assert.IsTrue(node.Outgoing.Count > 1);
node = tree.GetNode(node.Domain, node.Problem, node.Outgoing.Find(x => x.Action.Name.Equals("toggle-red"))) as VirtualMediationTreeNode;
node = tree.GetNode(node.Domain, node.Problem, node.Outgoing[0]) as VirtualMediationTreeNode;
node = tree.GetNode(node.Domain, node.Problem, node.Outgoing.Find(x => x.Action.Name.Equals("toggle-green"))) as VirtualMediationTreeNode;
node = tree.GetNode(node.Domain, node.Problem, node.Outgoing[0]) as VirtualMediationTreeNode;
Predicate term = new Predicate("used", new List <ITerm> {
new Term("terminal1", true), new Term("boss", true)
}, true);
Predicate term2 = new Predicate("used", new List <ITerm> {
new Term("terminal2", true), new Term("boss", true)
}, true);
Predicate term3 = new Predicate("has", new List <ITerm> {
new Term("snake", true), new Term("c4", true)
}, true);
Predicate bossGear = new Predicate("at", new List <ITerm> {
new Term("boss", true), new Term("gear", true)
}, true);
Superposition super = node.State as Superposition;
Assert.IsTrue(super.IsUndetermined(term));
Assert.IsTrue(super.IsUndetermined(term2));
Assert.IsFalse(super.IsUndetermined(term3));
node = tree.GetNode(node.Domain, node.Problem, node.Outgoing.Find(x => x.Action.Name.Equals("move-location"))) as VirtualMediationTreeNode;
super = node.State as Superposition;
Assert.IsFalse(super.IsUndetermined(term));
if (super.IsFalse(bossGear))
{
Assert.IsTrue(super.IsUndetermined(term2));
}
else
{
Assert.IsFalse(super.IsUndetermined(term2));
}
}
// Create new superpositions that are empty.
Superposition[,] NewCopiedSuperposition(Superposition[,] superpositions, List <Pattern> patterns)
{
var empty = new Superposition[superpositions.GetLength(0), superpositions.GetLength(1)];
{
for (int i = 0; i < superpositions.GetLength(0); i++)
{
for (int j = 0; j < superpositions.GetLength(1); j++)
{
empty[i, j] = new Superposition(superpositions[i, j], patterns);
}
}
}
return(empty);
}
static void Main(string[] args)
{
using (var qsim = new QuantumSimulator())
{
// Each Q# operation generates a C# class with the same name.
// This class has a Run method that asynchronously executes the operation.
// The execution is asynchronous because execution on actual hardware will be asynchronous.
// However, Result blocks execution until task completes; return synchronously
var res = HelloQ.Run(qsim).Result;
}
System.Console.WriteLine("Press any key to continue...");
System.Console.WriteLine("Next up: Superposition: ");
Console.ReadKey();
// work with superposition
using (var qsim = new QuantumSimulator())
{
// Try initial values
Result[] initials = new Result[] { Result.Zero, Result.One };
foreach (Result initial in initials)
{
// '.Result' blocks execution until the task completes and returns the result synchronously.
var res = Superposition.Run(qsim, 1000, initial).Result;
var (numZeros, numOnes) = res;
System.Console.WriteLine(
$"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4}");
}
}
System.Console.WriteLine("Press any key to continue...");
System.Console.WriteLine("Next up: Entanglement: ");
Console.ReadKey();
// work with entanglement
using (var qsim = new QuantumSimulator())
{
Result[] initials = new Result[] { Result.Zero, Result.One };
foreach (Result initial in initials)
{
var res = Entanglement.Run(qsim, 1000, initial).Result;
var (numZeros, numOnes, agree) = res;
System.Console.WriteLine(
$"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4} agree={agree,-4}");
}
}
System.Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
static void Run_Superposition(string[] args)
{
Console.WriteLine("Running: Superposition Test");
// Initialise the quantum simulator
using (var qsim = new QuantumSimulator())
{
Result[] initials = { Result.Zero, Result.One };
foreach (var initial in initials)
{
// Execute the quantum function
var res = Superposition.Run(qsim, 1000, initial).Result;
var(numZeros, numOnes) = res;
Console.WriteLine($"Init:{initial,-4} 0s={numZeros,-4} 1s={numOnes,-4}");
}
}
Console.WriteLine();
}
Superposition FindEmptySuperpositionToReplace(Superposition[,] superpositions, List <Pattern> patterns)
{
Superposition x = new Superposition(superpositions[0, 0], patterns);
for (int i = 0; i < superpositions.GetLength(0); i++)
{
for (int j = 0; j < superpositions.GetLength(1); j++)
{
if (superpositions[i, j].state == State.EMPTY)
{
return(superpositions[i, j]);
}
}
}
return(null);
}
// Given a mediation node, creates an HTML representation of its initial state.
public static void ToHTML(string directory, Superposition super)
{
/*string file = directory + "super.html";
*
* using (StreamWriter writer = new StreamWriter(file, false))
* {
* writer.WriteLine("<html>");
* writer.WriteLine("<head><style>td { text-align:center }</style></head>");
* writer.WriteLine("<body>");
* writer.WriteLine("<table text-align=\"center\">");
* foreach (IPredicate key in super.Table.Keys)
* {
* writer.WriteLine("<tr><th colspan=\"2\">" + key + "</th><th colspan=\"2\">(not " + key + ")</th></tr><tr><th>TRUE</th><th>FALSE</th><th>TRUE</th><th>FALSE</th></tr>");
* List<IPredicate> tt = super.GetContents(key, super.TrueTrue);
* List<IPredicate> tf = super.GetContents(key, super.TrueFalse);
* List<IPredicate> ft = super.GetContents(key, super.FalseTrue);
* List<IPredicate> ff = super.GetContents(key, super.FalseFalse);
*
* int max = Math.Max(tt.Count, Math.Max(tf.Count, Math.Max(ft.Count, ff.Count)));
*
* for (int i = 0; i < max; i++)
* {
* writer.WriteLine("<tr>");
* if (i < tt.Count) writer.WriteLine("<td>" + tt[i] + "</td>");
* else writer.WriteLine("<td> </td>");
* if (i < tf.Count) writer.WriteLine("<td>" + tf[i] + "</td>");
* else writer.WriteLine("<td> </td>");
* if (i < ft.Count) writer.WriteLine("<td>" + ft[i] + "</td>");
* else writer.WriteLine("<td> </td>");
* if (i < ff.Count) writer.WriteLine("<td>" + ff[i] + "</td>");
* else writer.WriteLine("<td> </td>");
* writer.WriteLine("</tr>");
* }
* }
* writer.WriteLine("</table>");
* writer.WriteLine("</body>");
* writer.WriteLine("</html>");
* }*/
}
Superposition[,] RemoveNoiseFromImage(WaveCollapseHistoryElement wfc, PatternFromSampleElement p)
{
var patterns = p.Patterns;
// Original image superpositions
var superpositions = wfc.Superpositions;
// Create new copied superpositions[,].
Superposition[,] superpositionsWithoutNoise = NewCopiedSuperposition(superpositions, patterns);
// Find superposition to replace once colorful cells should be changed to empty.
Superposition emptySuperpositiontoReplace = FindEmptySuperpositionToReplace(superpositions, patterns);
RemoveSingleCells(ref superpositionsWithoutNoise, superpositions, emptySuperpositiontoReplace, 2, 1);
RemoveSingleCells(ref superpositionsWithoutNoise, superpositions, emptySuperpositiontoReplace, 1, 1);
RemoveSingleCells(ref superpositionsWithoutNoise, superpositions, emptySuperpositiontoReplace, 2, 1);
RemoveSingleCells(ref superpositionsWithoutNoise, superpositions, emptySuperpositiontoReplace, 1, 1);
//RemoveSingleCells(ref superpositionsWithoutNoise, superpositions, emptySuperpositiontoReplace, 2, 1);
//RemoveSingleCells(ref superpositionsWithoutNoise, superpositions, emptySuperpositiontoReplace, 1, 1);
//RemoveSingleCells(ref superpositionsWithoutNoise, superpositions, emptySuperpositiontoReplace, 2, 1);
//RemoveSingleCells(ref superpositionsWithoutNoise, superpositions, emptySuperpositiontoReplace, 1, 1);
return(superpositionsWithoutNoise);
}
// Finds all possible actions for the given character and state.
public static List <Operator> GetActions(string character, Domain domain, Problem problem, Superposition superposition)
{
List <Operator> satisfiedActions = new List <Operator>();
foreach (State state in superposition.States)
{
satisfiedActions.AddRange(GetActions(character, domain, problem, state));
}
return(satisfiedActions.Distinct <Operator>().ToList <Operator>());
}
