QC lojs integration demo

Integration test: lojs

This is an active QC simulator, set up specifically to serve as an experiment for interacting with the lojs simulator.
It's not finished yet, but you're welcome to browse. Please give feedback to qc@machinelevel.com!
©2000-2015 All rights reserved. For more information, please send email to qc@machinelevel.com

Welcome! To try this out, choose one of the program samples (or try your own QCEngine program), and then follow the steps below.

Sample Programs:

Step 1 After you've edited the program above, this will run it using the QCEngine simulation, and also build the quantum gates we'll need. If this doesn't work, try pressing ctrl-shift-J to check the console for errors in the program.	Step 2 If there are any gates in the program with two or more conditions, this will break them down into single-condition gates so they'll work in a photonic device.	Step 3 This splits each qubit into two tracks, in order to use spatial encoding as required by the quantum photonic devices we're building.	Step 3b This replaces the idealised QC gates with functional beam splitters, changing the logic and complexity as little as possible.
Step 4 Photon tracks need to be adjacent to perform logic, so this step swaps the tracks to place required photons next to each other for each gate.	Step 5 Use this to check for errors. You'll know them when you see them.	Step 6 Transfer the program into lojs or IPKISS so that it can be simulated or etched in silicon.

// Note: < and > must be next to each other, so they
//       only differ by the 1 bit.
var instruction_symbols = ['<', '>', '[', ']', '-', '+', ',', '.']
function translateInstruction(inst)
{
  for (var i = 0; i < instruction_symbols.length; ++i)
    if (inst == instruction_symbols[i])
      return i;
  return 0; // We'd like a noop, but there are't enough bits.
}

qc.clearOutput();     // Clear the output window
qc.enableRecording(); // So we can see the QC gates

function QQFSM(program, data_bytes, bits_per_byte, branch_hist_length,
               input_stash_length, output_stash_length)
{
  this.program = program;
  this.num_data_bytes = 4;
  this.inst_tape = new QQTape('inst', program.length, 3);
  this.data_tape = new QQTape('data', data_bytes, bits_per_byte);
  if (branch_hist_length == 0)
  {
    this.branch_clobber = true;
    branch_hist_length = 2;
  }
  this.branch_hist = new QQTape('branch_hist', branch_hist_length, 1);

if (input_stash_length == 0)
  {
    this.input_clobber = true;
    this.input_tape = new QQTape('input_clock', 1, 1);
  }
  else
    this.input_tape = new QQTape('input', input_stash_length, bits_per_byte);

if (output_stash_length == 0)
  {
    this.output_clobber = true;
    this.output_tape = new QQTape('output_clock', 1, 1);
  }
  else
    this.output_tape = new QQTape('output', output_stash_length, bits_per_byte);

this.tick_count = 0;

this.total_qubits = 2; // nop_dir and scratch_zero
  this.total_qubits += this.inst_tape.qubitsRequired();
  this.total_qubits += this.data_tape.qubitsRequired();
  this.total_qubits += this.branch_hist.qubitsRequired();
  this.total_qubits += this.input_tape.qubitsRequired();
  this.total_qubits += this.output_tape.qubitsRequired();
  this.total_qubits += 2; // util
  qc.reset(this.total_qubits);
  qc.print('Using ' + this.total_qubits + ' qubits.\n' +
           'RAM est: ' + Math.pow(2, this.total_qubits + 3 - 20) + ' MB.\n');

qint.new(1, '(util)');
  this.branch_hist.activate();
  this.nop_dir = qint.new(1, 'nop_dir');
  this.scratch_zero = qint.new(1, 'scratch_zero');
  this.inst_tape.activate();
  this.data_tape.activate();
  this.input_tape.activate();
  this.output_tape.activate();
  qint.new(1, '(util)');

qc.codeLabel('zero mem');
  qc.write(0);

qc.codeLabel('[' + program + ']');
  for (var i = 0; i < this.program.length; ++i)
    this.inst_tape.storage[i].write(translateInstruction(this.program[i]));

// Get the instruction values for use as condition bits
  this.inst_incd = translateInstruction('+');
  this.inst_decd = translateInstruction('-');
  this.inst_incp = translateInstruction('>');
  this.inst_decp = translateInstruction('<');
  this.inst_jmp1 = translateInstruction('[');
  this.inst_jmp2 = translateInstruction(']');
  this.inst_in   = translateInstruction(',');
  this.inst_out  = translateInstruction('.');
  // Set up some bits for knowing when to roll the ptr
  this.ptr_roll = this.inst_incp & this.inst_incd & 0x6;
  this.ptr_roll_not = this.ptr_roll ^ 0x6;

this.print = function()
  {
    qc.print('------ FSM tick ' + this.tick_count + '\n');
    this.inst_tape.print(instruction_symbols);
    this.data_tape.print(null);
    qc.print('  nop: ' + this.branch_hist.head().read() + 
              ' nop_dir: ' + this.nop_dir.read() + '\n');
    this.input_tape.print(null);
    this.output_tape.print(null);
  }

this.tick = function()
  {
    // Get references to the qubytes at the tape heads
    var inst = this.inst_tape.head();
    var data = this.data_tape.head();
    var nop_flag = this.branch_hist.head();

qc.codeLabel('"+" ' + this.tick_count); ////////////////////////////////////
    data.add( 1, qintMask([inst, this.inst_incd]),
                 qintMask([inst, ~this.inst_incd, nop_flag, 1]));

qc.codeLabel('"-" ' + this.tick_count); ////////////////////////////////////
    data.add(-1, qintMask([inst, this.inst_decd]),
                 qintMask([inst, ~this.inst_decd, nop_flag, 1]));

qc.codeLabel('"< >" ' + this.tick_count); //////////////////////////////////
    this.data_tape.roll(qintMask([inst, this.ptr_roll]),
                        qintMask([inst, this.ptr_roll_not, nop_flag, 1]),
                        qintMask([inst, this.inst_incp]),
                        qintMask([inst, ~this.inst_incp, nop_flag, 1]),
                        qintMask([inst, this.inst_decp]),
                        qintMask([inst, ~this.inst_decp, nop_flag, 1]));
  
    qc.codeLabel('in ' + this.tick_count); /////////////////////////////////
    if (this.input_clobber) // Just flip the clock to let the host know we're ready for data
    {                 // Just flip the clock to let the host we're ready for data
      this.input_tape.head().cnot(null, -1, qintMask([inst, this.inst_in]),
                                            qintMask([inst, ~this.inst_in, nop_flag, 1]));
    }
    else
    {
      this.input_tape.rollFwd(qintMask([inst, this.inst_in]),
                               qintMask([inst, ~this.inst_in, nop_flag, 1]));
      this.input_tape.head().exchange(data, -1, qintMask([inst, this.inst_in]),
                                             qintMask([inst, ~this.inst_in, nop_flag, 1]));
    }

qc.codeLabel('out ' + this.tick_count); /////////////////////////////////
    if (this.output_clobber)
    {                 // Just flip the clock to let the host know data is ready
      this.output_tape.head().cnot(null, -1, qintMask([inst, this.inst_out]),
                                             qintMask([inst, ~this.inst_out, nop_flag, 1]));
    }
    else
    {
      this.output_tape.rollFwd(qintMask([inst, this.inst_out]),
                               qintMask([inst, ~this.inst_out, nop_flag, 1]));
      this.output_tape.head().cnot(data, -1, qintMask([inst, this.inst_out]),
                                             qintMask([inst, ~this.inst_out, nop_flag, 1]));
    }

qc.codeLabel('"[" ' + this.tick_count); ////////////////////////////////////
    if (this.branch_clobber)
      this.branch_hist.storage[1].write(0); // Clobber mode loses superposition, but can run forever.
    this.branch_hist.rollFwd(qintMask([inst, this.inst_jmp1]),
                             qintMask([inst, ~this.inst_jmp1]));
    nop_flag.cnot(    null, 1, qintMask([inst, this.inst_jmp1]),
                               qintMask([data, -1, inst, ~this.inst_jmp1]));
    this.nop_dir.cnot(null, 1, qintMask([inst, this.inst_jmp1]),
                               qintMask([inst, ~this.inst_jmp1]));

qc.codeLabel('"]" ' + this.tick_count); ////////////////////////////////////
    nop_flag.cnot(    null, 1, qintMask([inst, this.inst_jmp2]),
                               qintMask([inst, ~this.inst_jmp2]));
    this.nop_dir.cnot(null, 1, qintMask([inst, this.inst_jmp2]),
                               qintMask([inst, ~this.inst_jmp2]));

qc.codeLabel('roll inst tape ' + this.tick_count); /////////////////////////
    var reverse = this.scratch_zero;
    reverse.cnot(nop_flag, 1, 0, qintMask([this.nop_dir, 1]));
    var reverse_mask = qintMask([reverse, 1]);
    this.inst_tape.roll(0, 0, 0, reverse_mask, reverse_mask, 0);
    reverse.cnot(nop_flag, 1, 0, qintMask([this.nop_dir, 1]));

this.tick_count++;
  }
}

////////////////////////////////////////////
// Here's where we run the program:

qc.codeLabel('inititalize');
var data_bytes = 4;
var bits_per_byte = 4;
var branch_stash_length = 4;
var input_stash_length = 0;
var output_stash_length = 0;
var qqfsm = new QQFSM('+++.', data_bytes, bits_per_byte, branch_stash_length,
                      input_stash_length, output_stash_length);

//qqfsm.print();
for (var t = 0; t < 1; ++t)
{
  qqfsm.tick();
//  qqfsm.print();
}