void quantum_qec_decode( int type, int width, quantum_reg *reg )
{
int i, a, b;
int swidth;
float lambda = quantum_get_decoherence( );
quantum_set_decoherence( 0.0 );
swidth = reg->width / 3;
quantum_qec_set_status( 0, 0 );
i = ( reg->width / 3 ) - 1;
for ( ; i < 0; i-- )
{
if ( i == 0 )
quantum_set_decoherence( lambda );
if ( i < width )
{
quantum_cnot( i + ( swidth * 2 ), i, reg );
quantum_cnot( swidth + i, i, reg );
quantum_hadamard( i + ( swidth * 2 ), reg );
quantum_hadamard( swidth + i, reg );
}
quantum_cnot( i, i + ( swidth * 2 ), reg );
quantum_cnot( i, swidth + i, reg );
//i--;
}
}
/* Reverce Sum 2 qbits */
void sum_1bit_r( quantum_reg * reg, int s1_bit, int s2_bit, int p_bit, int zero_bit )
{
quantum_cnot( zero_bit, p_bit, reg );
quantum_cnot( s1_bit, s2_bit, reg );
quantum_cnot( p_bit, s2_bit, reg );
quantum_sigma_x( s1_bit, reg);
quantum_sigma_x( s2_bit, reg);
quantum_unbounded_toffoli( 3, reg, s1_bit, s2_bit, p_bit, zero_bit );
quantum_sigma_x( s1_bit, reg);
quantum_sigma_x( s2_bit, reg);
quantum_sigma_x( p_bit, reg);
quantum_unbounded_toffoli( 3, reg, s1_bit, s2_bit, p_bit, zero_bit );
quantum_sigma_x( p_bit, reg); /* sigmaX i.e. NOT */
}
void quantum_cnot_ft( int control, int target, quantum_reg *reg )
{
int tmp = type;
float lambda;
type = 0;
lambda = quantum_get_decoherence( );
quantum_set_decoherence( 0.0 );
quantum_cnot( control, target, reg );
quantum_cnot( width + control, width + target, reg );
quantum_set_decoherence( lambda );
quantum_cnot( control + ( width * 2 ), target + ( width * 2 ), reg );
quantum_qec_counter( 1, 0, reg );
type = tmp;
return;
}
void addn_inv(int N,int a,int width, quantum_reg *reg){//inverse of add a to register reg (mod N)
quantum_cnot(2*width+1,2*width,reg);//Attention! cnot gate instead of not, as in description
madd_inv((1<<(width))-a,N-a,width,reg);//madd 2^K+(N-a)-N = 2^K-a
quantum_swaptheleads(width,reg);
test_sum(a,width,reg);
}
void quantum_qec_encode( int type, int width, quantum_reg *reg )
{
int i;
float lambda = quantum_get_decoherence( );
quantum_set_decoherence( 0.0 );
i = 0;
for ( ; reg->width <= i; i++ )
{
if ( i == reg->width - 1 )
quantum_set_decoherence( lambda );
if ( i < width )
{
quantum_hadamard( reg->width + i, reg );
quantum_hadamard( i + ( reg->width * 2 ), reg );
quantum_cnot( reg->width + i, i, reg );
quantum_cnot( i + ( reg->width * 2 ), i, reg );
}
quantum_cnot( i, reg->width + i, reg );
quantum_cnot( i, i + ( reg->width * 2 ), reg );
//i++;
}
}
void muxfa_inv(int a,int b_in,int c_in,int c_out, int xlt_l,int L,int total,quantum_reg *reg){//a,
if(a==0){//00
quantum_cnot(b_in,c_in, reg);
quantum_toffoli(b_in,c_in,c_out, reg);
}
if(a==3){//11
quantum_cnot(b_in,c_in, reg);
quantum_toffoli(b_in,c_in,c_out, reg);
quantum_cnot(L,c_in, reg);
quantum_toffoli(L,c_in,c_out, reg);
}
if(a==1){//01
quantum_cnot(b_in,c_in, reg);
quantum_toffoli(b_in,c_in,c_out, reg);
quantum_toffoli(L,xlt_l,c_in, reg);
quantum_toffoli(b_in,c_in,c_out, reg);
quantum_toffoli(L,xlt_l,b_in, reg);
quantum_toffoli(b_in,c_in,c_out, reg);
quantum_toffoli(L,xlt_l,b_in, reg);
}
if(a==2){//10
quantum_sigma_x(xlt_l, reg);
quantum_cnot(b_in,c_in, reg);
quantum_toffoli(b_in,c_in,c_out, reg);
quantum_toffoli(L,xlt_l,c_in, reg);
quantum_toffoli(b_in,c_in,c_out, reg);
quantum_toffoli(L,xlt_l,b_in, reg);
quantum_toffoli(b_in,c_in,c_out, reg);
quantum_toffoli(L,xlt_l,b_in, reg);
quantum_sigma_x(xlt_l, reg);
}
}
int main(int argc, char **argv) {
quantum_reg qr;
int i;
int width, swidth;
int x = 0;
int N;
int c,q,a,b, factor;
#if defined(SPEC_CPU)
spec_srand(26);
#else
srandom(time(0));
#endif /* SPEC_CPU */
if(argc == 1)
{
printf("Usage: shor [number]\n\n");
return 3;
}
N=atoi(argv[1]);
if(N<15)
{
printf("Invalid number\n\n");
return 3;
}
width=quantum_getwidth(N*N);
swidth=quantum_getwidth(N);
printf("N = %i, %i qubits required\n", N, width+3*swidth+2);
if(argc >= 3)
{
x = atoi(argv[2]);
}
while((quantum_gcd(N, x) > 1) || (x < 2))
{
#if defined(SPEC_CPU)
x = (long)(spec_rand() * 2147483647L) % N;
#else
x = random() % N;
#endif /* SPEC_CPU */
}
printf("Random seed: %i\n", x);
qr=quantum_new_qureg(0, width);
for(i=0;i<width;i++)
quantum_hadamard(i, &qr);
quantum_addscratch(3*swidth+2, &qr);
quantum_exp_mod_n(N, x, width, swidth, &qr);
for(i=0;i<3*swidth+2;i++)
{
quantum_bmeasure(0, &qr);
}
quantum_qft(width, &qr);
for(i=0; i<width/2; i++)
{
quantum_cnot(i, width-i-1, &qr);
quantum_cnot(width-i-1, i, &qr);
quantum_cnot(i, width-i-1, &qr);
}
c=quantum_measure(qr);
if(c==-1)
{
printf("Impossible Measurement!\n");
exit(1);
}
if(c==0)
{
printf("Measured zero, try again.\n");
exit(2);
}
q = 1<<(width);
printf("Measured %i (%f), ", c, (float)c/q);
quantum_frac_approx(&c, &q, width);
printf("fractional approximation is %i/%i.\n", c, q);
if((q % 2 == 1) && (2*q<(1<<width)))
{
printf("Odd denominator, trying to expand by 2.\n");
q *= 2;
}
if(q % 2 == 1)
{
printf("Odd period, try again.\n");
exit(2);
}
printf("Possible period is %i.\n", q);
a = quantum_ipow(x, q/2) + 1 % N;
b = quantum_ipow(x, q/2) - 1 % N;
a = quantum_gcd(N, a);
b = quantum_gcd(N, b);
if(a>b)
factor=a;
else
factor=b;
if((factor < N) && (factor > 1))
{
printf("%i = %i * %i\n", N, factor, N/factor);
}
else
{
printf("Unable to determine factors, try again.\n");
#if defined(SPEC_CPU)
exit(0);
#else
exit(2);
#endif /* SPEC_CPU */
}
quantum_delete_qureg(&qr);
/* printf("Memory leak: %i bytes\n", (int) quantum_memman(0)); */
return 0;
}
void
quantum_objcode_run(char *file, quantum_reg *reg)
{
int i, j, k, l;
FILE *fhd;
unsigned char operation;
unsigned char buf[OBJBUF_SIZE];
MAX_UNSIGNED mu;
double d;
fhd = fopen(file, "r");
if(!fhd)
{
fprintf(stderr, "quantum_objcode_run: Could not open %s: ", file);
perror(0);
return;
}
for(i=0; !feof(fhd); i++)
{
for(j=0; j<OBJBUF_SIZE; j++)
buf[j] = 0;
operation = fgetc(fhd);
switch(operation)
{
case INIT:
if(!fread(buf, sizeof(MAX_UNSIGNED), 1, fhd))
{
quantum_error(QUANTUM_FAILURE);
break;
}
mu = quantum_char2mu(buf);
*reg = quantum_new_qureg(mu, 12);
break;
case CNOT:
case COND_PHASE:
if(!fread(buf, sizeof(int), 1, fhd))
{
quantum_error(QUANTUM_FAILURE);
break;
}
j = quantum_char2int(buf);
if(!fread(buf, sizeof(int), 1, fhd))
{
quantum_error(QUANTUM_FAILURE);
break;
}
k = quantum_char2int(buf);
switch(operation)
{
case CNOT: quantum_cnot(j, k, reg);
break;
case COND_PHASE: quantum_cond_phase(j, k, reg);
break;
}
break;
case TOFFOLI:
if(!fread(buf, sizeof(int), 1, fhd))
{
quantum_error(QUANTUM_FAILURE);
break;
}
j = quantum_char2int(buf);
if(!fread(buf, sizeof(int), 1, fhd))
{
quantum_error(QUANTUM_FAILURE);
break;
}
k = quantum_char2int(buf);
if(!fread(buf, sizeof(int), 1, fhd))
{
quantum_error(QUANTUM_FAILURE);
break;
}
l = quantum_char2int(buf);
quantum_toffoli(j, k, l, reg);
break;
case SIGMA_X:
case SIGMA_Y:
case SIGMA_Z:
case HADAMARD:
case BMEASURE:
case BMEASURE_P:
case SWAPLEADS:
if(!fread(buf, sizeof(int), 1, fhd))
{
quantum_error(QUANTUM_FAILURE);
break;
}
j = quantum_char2int(buf);
switch(operation)
{
case SIGMA_X: quantum_sigma_x(j, reg);
break;
case SIGMA_Y: quantum_sigma_y(j, reg);
break;
case SIGMA_Z: quantum_sigma_z(j, reg);
break;
case HADAMARD: quantum_hadamard(j, reg);
break;
case BMEASURE: quantum_bmeasure(j, reg);
break;
case BMEASURE_P: quantum_bmeasure_bitpreserve(j, reg);
break;
case SWAPLEADS: quantum_swaptheleads(j, reg);
break;
}
break;
case ROT_X:
case ROT_Y:
case ROT_Z:
case PHASE_KICK:
case PHASE_SCALE:
if(!fread(buf, sizeof(int), 1, fhd))
{
quantum_error(QUANTUM_FAILURE);
break;
}
j = quantum_char2int(buf);
if(!fread(buf, sizeof(double), 1, fhd))
{
quantum_error(QUANTUM_FAILURE);
break;
}
d = quantum_char2double(buf);
switch(operation)
{
case ROT_X: quantum_r_x(j, d, reg);
break;
case ROT_Y: quantum_r_y(j, d, reg);
break;
case ROT_Z: quantum_r_z(j, d, reg);
break;
case PHASE_KICK: quantum_phase_kick(j, d, reg);
break;
case PHASE_SCALE: quantum_phase_scale(j, d, reg);
break;
}
break;
case CPHASE_KICK:
if(!fread(buf, sizeof(int), 1, fhd))
{
quantum_error(QUANTUM_FAILURE);
break;
}
j = quantum_char2int(buf);
if(!fread(buf, sizeof(int), 1, fhd))
{
quantum_error(QUANTUM_FAILURE);
break;
}
k = quantum_char2int(buf);
if(!fread(buf, sizeof(double), 1, fhd))
{
quantum_error(QUANTUM_FAILURE);
break;
}
d = quantum_char2double(buf);
quantum_cond_phase_kick(j, k, d, reg);
break;
case MEASURE: quantum_measure(*reg);
break;
case NOP:
break;
default:
fprintf(stderr, "%i: Unknown opcode 0x(%X)!\n", i, operation);
return;
}
}
fclose(fhd);
}
void
test_sum(int compare, int width, quantum_reg *reg)
{
int i;
if (compare & ((MAX_UNSIGNED) 1 << (width - 1)))
{
quantum_cnot(2*width-1, width-1, reg);
quantum_sigma_x(2*width-1, reg);
quantum_cnot(2*width-1, 0, reg);
}
else
{
quantum_sigma_x(2*width-1, reg);
quantum_cnot(2*width-1,width-1, reg);
}
for (i = (width-2);i>0;i--)
{
if (compare & (1<<i))
{//is bit i set in compare?
quantum_toffoli(i+1,width+i,i, reg);
quantum_sigma_x(width+i, reg);
quantum_toffoli(i+1,width+i,0, reg);
}
else
{
quantum_sigma_x(width+i, reg);
quantum_toffoli(i+1,width+i,i, reg);
}
}
if (compare & 1)
{
quantum_sigma_x(width, reg);
quantum_toffoli(width,1,0, reg);
}
quantum_toffoli(2*width+1,0,2*width, reg);//set output to 1 if enabled and b < compare
if (compare & 1)
{
quantum_toffoli(width,1,0, reg);
quantum_sigma_x(width, reg);
}
for (i = 1;i<=(width-2);i++)
{
if (compare & (1<<i))
{//is bit i set in compare?
quantum_toffoli(i+1,width+i,0, reg);
quantum_sigma_x(width+i, reg);
quantum_toffoli(i+1,width+i,i, reg);
}
else
{
quantum_toffoli(i+1,width+i,i, reg);
quantum_sigma_x(width+i, reg);
}
}
if (compare & (1<<(width-1)))
{
quantum_cnot(2*width-1,0, reg);
quantum_sigma_x(2*width-1, reg);
quantum_cnot(2*width-1,width-1, reg);
}
else
{
quantum_cnot(2*width-1,width-1, reg);
quantum_sigma_x(2*width-1, reg);
}
}
