add support for register-sized boolean computation + fix bugs

Author: at2005

data/deutsch_jozsa.hodl

@@ -26,9 +26,9 @@ function deutsch_josza(super inputs) {
 # main function, i.e., body of program
 
 function main() {
-	# initialize superposition to 5 qubits
+	# initialize superposition to 2 qubits
 	# this should serve as the input for our function
-	super stuff = 4;
+	super stuff = 16;
 
 	# apply deutsch-josza function
 	# if the function is balanced, i.e, half of all inputs return 1 and the other half return 0,

src/compiler/comops.h

@@ -200,9 +200,7 @@ void compile_instructions(Circuit& qc, vector<INSTRUCTION> instructions, SymbolT
 				else if (type == "-=") {
 					subtract_append(qc, *qvar1, *qvar2, instruction.get_controls());
 
-				}
-
-			
+				}	
 
 				// check if our operation is relational (comparison)
 				if (isCompOp(type)) {
@@ -221,21 +219,6 @@ void compile_instructions(Circuit& qc, vector<INSTRUCTION> instructions, SymbolT
 
 					qc.add_qregister(*ancilla);
 
-
-				/*	
-					// reuse garbage register
-					QuantumVariable* ancilla = Garbage::get_garbage()->get_garbage_register(num_qubits_ancilla);
-
-					if(ancilla == nullptr) {
-						// create ancillary register
-						table->ADD_ANCILLA_REGISTER(num_qubits_ancilla);
-						// get ancillary register
-						QuantumVariable* ancilla = table->search_qtable(table->GET_ANCILLA_REGISTER());
-					}
-
-*/
-
-					// add ancillary register to circuit
 
 					// compile equality operator
 					if (type == "==") {
@@ -276,57 +259,134 @@ void compile_instructions(Circuit& qc, vector<INSTRUCTION> instructions, SymbolT
 				}
 
 				// compile AND operator
+
 				else if (type == "&") {
+					if (qvar1->get_num_qubits() > 1 || qvar2->get_num_qubits() > 1) {
+						// n qubit OR gate, loop through all qubit pairs, eval or on ancilla, then X all of them, multi-controlled gate
+						QuantumVariable* max_reg_and = qvar1;
+						QuantumVariable* min_reg_and = qvar2;
+						// get min and max qubits
+						unsigned int max_qubits_and = qvar1->get_num_qubits();
+						unsigned int min_qubits_and = qvar2->get_num_qubits();
+						if(max_qubits_and < min_qubits_and) {
+							swap(max_qubits_and, min_qubits_and);
+							swap(max_reg_and, min_reg_and);
+						}
+
+						// check if single qubit OR required or register-wide or
+						QuantumVariable* ancilla_nbit_and = result_reg;
+						
+						if(result_reg->get_num_qubits() == 1) {
+							ancilla_nbit_and = alloc_ancilla(qc, max_qubits_and, table);
+						
+						}	
+				
+						unsigned int diff = max_qubits_and - min_qubits_and;
+						// and all common qubits
+						for(int qbit_pair = diff; qbit_pair < max_qubits_and; qbit_pair++) {
+							qc.ccx(max_reg_and->get_qreg(), qbit_pair, min_reg_and->get_qreg(), qbit_pair-diff, ancilla_nbit_and->get_qreg(), qbit_pair-diff);
+						}
+						
+						
+						// continue if not in if statement						
+						if(result_reg->get_num_qubits() > 1) continue;
+					
+
+						// ELSE multi-controlled NOT onto single qubit
+
+						qc.x(ancilla_nbit_and->get_qreg());
+						qc.x(result_reg->get_qreg());
+						
+
+						QuantumVariable* ancilla_mcgate = alloc_ancilla(qc, ancilla_nbit_and->get_num_qubits()-1, table);
+						multi_ctrl_gate(qc, &Circuit::cx, ancilla_nbit_and, result_reg, ancilla_mcgate);
+						
+
+						// uncomputation
+						qc.x(ancilla_nbit_and->get_qreg());
+							
+						for(int qbit_pair = max_qubits_and - min_qubits_and; qbit_pair < max_qubits_and; qbit_pair++) {
+							qc.ccx(qvar1->get_qreg(), qbit_pair, qvar2->get_qreg(), qbit_pair, ancilla_nbit_and->get_qreg(), qbit_pair);
+						}
+						
+						Garbage::get_garbage()->add_garbage(ancilla_mcgate);		
+						Garbage::get_garbage()->add_garbage(ancilla_nbit_and);						
+						continue;
+					}
+
+
+					
 					qc.ccx(qvar1->get_qreg(), 0, qvar2->get_qreg(), 0, result_reg->get_qreg(), 0);
-				}
+				}	
 
 				// compile OR operator
 				else if (type == "|") {
 					if(qvar1->get_num_qubits() > 1 || qvar2->get_num_qubits() > 1) {
 						// n qubit OR gate, loop through all qubit pairs, eval or on ancilla, then X all of them, multi-controlled gate
 
 						QuantumVariable* max_reg_or = qvar1;
+						QuantumVariable* min_reg_or = qvar2;
 						// get min and max qubits
 						unsigned int max_qubits_or = qvar1->get_num_qubits();
 						unsigned int min_qubits_or = qvar2->get_num_qubits();
 						if(max_qubits_or < min_qubits_or) {
 							swap(max_qubits_or, min_qubits_or);
-							max_reg_or = qvar2;
+							swap(max_reg_or, min_reg_or);
 						}
 
-						QuantumVariable* ancilla_nbit_or = alloc_ancilla(qc, max_qubits_or, table);
+						// check if single qubit OR required or register-wide or
+						QuantumVariable* ancilla_nbit_or = result_reg;
+						
+						if(result_reg->get_num_qubits() == 1) {
+							ancilla_nbit_or = alloc_ancilla(qc, max_qubits_or, table);
 
+						}	
+	
+						unsigned int diff = max_qubits_or - min_qubits_or;	
 						// OR common bits
-						for(int qbit_pair = max_qubits_or - min_qubits_or; qbit_pair < max_qubits_or; qbit_pair++) {
-							bitwise_or(qc, qvar1, qbit_pair, qvar2, qbit_pair, ancilla_nbit_or, qbit_pair);
+						for(int qbit_pair = max_qubits_or - 1; qbit_pair >= diff; qbit_pair--) {
+							bitwise_or(qc, max_reg_or, qbit_pair, min_reg_or, qbit_pair-diff, ancilla_nbit_or, qbit_pair);
 						}
 
 						// OR uncommon bits (case where one register is larger than the other, then OR with zero is simply copying the bit value
-						for(int qbit_cutoff = 0; qbit_cutoff < max_qubits_or - min_qubits_or; qbit_cutoff++) {
+						for(int qbit_cutoff = 0; qbit_cutoff < diff; qbit_cutoff++) {
 							qc.cx(max_reg_or->get_qreg(), qbit_cutoff, ancilla_nbit_or->get_qreg(), qbit_cutoff); 
 						}
 
+
+						// continue if not in if statement						
+						if(result_reg->get_num_qubits() > 1) continue;
+						
+
+						// Following block only for if statement bool
+
 						// NOT entire register
 						qc.x(ancilla_nbit_or->get_qreg());
 
+						// NOT result register
+						qc.x(result_reg->get_qreg());
+
 						QuantumVariable* ancilla_mcgate = alloc_ancilla(qc, ancilla_nbit_or->get_num_qubits()-1, table);
 						multi_ctrl_gate(qc, &Circuit::cx, ancilla_nbit_or, result_reg, ancilla_mcgate);
 
 						// Uncompute NOT
 						qc.x(ancilla_nbit_or->get_qreg());
 
-						// Uncompute OR operation on ancilla
-
+						// Uncompute OR operation on ancilla - START	
 						// OR common bits
-						for(int qbit_pair = max_qubits_or - min_qubits_or; qbit_pair < max_qubits_or; qbit_pair++) {
-							bitwise_or(qc, qvar1, qbit_pair, qvar2, qbit_pair, ancilla_nbit_or, qbit_pair);
+						for(int qbit_pair = max_qubits_or - 1; qbit_pair >= diff; qbit_pair--) {
+							bitwise_or(qc, max_reg_or, qbit_pair, min_reg_or, qbit_pair-diff, ancilla_nbit_or, qbit_pair);
 						}
 
 						// OR uncommon bits (case where one register is larger than the other, then OR with zero is simply copying the bit value
-						for(int qbit_cutoff = 0; qbit_cutoff < max_qubits_or - min_qubits_or; qbit_cutoff++) {
+						for(int qbit_cutoff = 0; qbit_cutoff < diff; qbit_cutoff++) {
 							qc.cx(max_reg_or->get_qreg(), qbit_cutoff, ancilla_nbit_or->get_qreg(), qbit_cutoff); 
 						}
+						// END UNCOMPUTATION
 
+//						Garbage::get_garbage()->add_garbage(ancilla_mcgate);		
+//						Garbage::get_garbage()->add_garbage(ancilla_nbit_or);						
+						
 						continue;
 
 					}
@@ -342,7 +402,6 @@ void compile_instructions(Circuit& qc, vector<INSTRUCTION> instructions, SymbolT
 
 				}
 
-
 			}
 
 			else {
@@ -459,7 +518,37 @@ void compile_instructions(Circuit& qc, vector<INSTRUCTION> instructions, SymbolT
 
 				}
 
+				// compile range operator
+				else if (type == ":") {
+					// get number or right operand
+					long long number = stoll(reg1);
+
+					// initialize number of qubits to zero
+					int num_qubits = 0;
+
+					// check if range is a power-of-two
+					// in other words, check if log2(number) is an element of the set consisting natural numbers
+					if (reg0 == "0" && ceil(log2(number)) == floor(log2(number))) {
+						// set number of qubits
+						// the reason for this is to only create a superposition of the range desired.
+						// e.g., a register of 5 qubits but we want a superposition of 0:4
+						// Therefore, we have to only put the last 2 qubits into superposition
+						int num_qubits = floor(log2(number));
+
+						// Apply HADAMARD Gate to each qubit we want to be in superpositon
+						for (int i = (result_reg->get_num_qubits() - num_qubits); i < result_reg->get_num_qubits(); i++) {
+							qc.h(result_reg->get_qreg(), i);
+						}
 
+					}
+
+					// this should be implemented in later versions
+					// to allow programmer to specify custom range, e.g. (1:100)
+					else {
+						int num_qubits = floor(log2(number)) + 1;
+						//apply operation to procure such a state
+					}
+				}
 			}
 		}
 

src/compiler/compiler.h

@@ -68,12 +68,12 @@ int compile(int num_args, char** args) {
 	//lexical analysis -> stored in vector of token-values
 	vector<Pair> TokenValues = execute_lex(program_file).get_lex().dict_output;
 
-	/*for(int i = 0; i < TokenValues.size(); i++) {
+/*	for(int i = 0; i < TokenValues.size(); i++) {
 		cout << TokenValues[i].getToken() << endl;
 
 
 	}	
-	*/
+*/	
 
 
 	// get circuit object

src/compiler/estimation_funcs.h

@@ -6,7 +6,7 @@
 #include <map>
 
 
- unsigned long long eval_resources(SyntaxTree* tree, SymbolTable* table, QuantumVariable* dependency = nullptr, Node* expr_node = nullptr, bool is_right_child = false, map<string, string> parameter_map = {});
+ unsigned long long eval_resources(SyntaxTree* tree, SymbolTable* table, QuantumVariable* dependency = nullptr, Node* expr_node = nullptr, bool is_right_child = false, map<string, string> parameter_map = {}, bool is_if_statement=false);
 
  std::map<string, string> number_to_word() {
 	std::map<std::string, std::string> numbers;
@@ -246,6 +246,16 @@ unsigned int long long eval_id_resources(Node* node, string left, string right,
 		return 0;
 	}
 
+	if(node->getTValue() == "|") {
+		return max(qvar1.get_num_qubits(), qvar2.get_num_qubits());
+
+	}
+
+	if(node->getTValue() == "&") {
+		return min(qvar1.get_num_qubits(), qvar2.get_num_qubits());
+
+	}
+
 
 	return 0;
 }
@@ -281,7 +291,6 @@ unsigned long long eval_id_num_resources(Node* node, string left, string right,
 		estimate_subtraction_append(qvar, number);
 	}
 
-
 	return 0;
 }
 
@@ -290,7 +299,7 @@ unsigned long long eval_id_num_resources(Node* node, string left, string right,
 
 void eval_operator_child(Node* node, SymbolTable* table, int& total_resources, Node* expr_node, QuantumVariable* dependency, map<string, string> parameter_map = {}) {
 	int value;
-	//dependency = nullptr;
+	//dependency = nullptr;	
 
 	SyntaxTree left_tree(node->getLeftChild());
 	SyntaxTree right_tree(node->getRightChild());
@@ -310,13 +319,22 @@ void eval_operator_child(Node* node, SymbolTable* table, int& total_resources, N
 		total_resources += value;
 	}
 
+	else if (node->getTValue() == "|") {
+		value = max(eval_resources(&left_tree, table, dependency, expr_node, false, parameter_map), eval_resources(&right_tree, table, dependency, expr_node, true, parameter_map));
+		total_resources += value;
+	}
 
+	else if (node->getTValue() == "&") {
+		value = min(eval_resources(&left_tree, table, dependency, expr_node, false, parameter_map), eval_resources(&right_tree, table, dependency, expr_node, true, parameter_map));
+		total_resources += value;
+	}
 
 	else if (node->getTValue() == ":") {
 		total_resources += estimate_range(eval_resources(&right_tree, table, dependency, expr_node, false, parameter_map));
 
 	}
 
+
 	table->search_qtable(node->get_result_register())->set_num_qubits(value);
 
 

src/compiler/resources.h

@@ -7,7 +7,8 @@
 // THIS FUNCTION COMPUTES SIZE OF EACH REGISTER REQUIRED AND CREATES THEM
 
 
-unsigned long long eval_resources(SyntaxTree* tree, SymbolTable* table, QuantumVariable* dependency, Node* expr_node, bool is_right_child, map<string, string> parameter_map) {
+
+unsigned long long eval_resources(SyntaxTree* tree, SymbolTable* table, QuantumVariable* dependency, Node* expr_node, bool is_right_child, map<string, string> parameter_map, bool is_if_statement) {
 	// Root node for expression parsing
 	//cout << tree;
 	Node* node = tree->getRoot();
@@ -162,7 +163,7 @@ unsigned long long eval_resources(SyntaxTree* tree, SymbolTable* table, QuantumV
 
 
 		//case for operators
-		else if (node->getTToken() == "OPERATOR") {
+		else if (node->getTToken() == "OPERATOR" || (node->getTToken() == "BOOL_EXPR" && !is_if_statement)) {
 			// get left value
 			string left = node->getLeftChild()->getTValue();
 
@@ -350,7 +351,7 @@ unsigned long long eval_resources(SyntaxTree* tree, SymbolTable* table, QuantumV
 			SyntaxTree tree_left(node->getLeftChild());
 
 			// evaluate resources for condition
-			eval_resources(&tree_left, table, nullptr, nullptr, false, parameter_map);
+			eval_resources(&tree_left, table, nullptr, nullptr, false, parameter_map, true);
 			// add CMP register
 			table->ADD_CMP_REGISTER();
 
@@ -370,7 +371,7 @@ unsigned long long eval_resources(SyntaxTree* tree, SymbolTable* table, QuantumV
 			// evaluate resources for left and right child
 			eval_resources(&tree_left, table, nullptr, nullptr, false, parameter_map);
 			eval_resources(&tree_right, table, nullptr, nullptr, false, parameter_map);
-
+				
 			// create a CMP register to store boolean result
 			table->ADD_CMP_REGISTER();