quantum-circuit/lib/quantum-circuit.js

Quantum Circuit Simulator

/**
 * @license
 *
 * Copyright (c) 2016, Petar Korponaić <petar.korponaic@gmail.com>
 *
 * This source code is licensed under the MIT License, found in
 * the LICENSE.txt file in the root directory of this source tree.
 */

var math = require("mathjs");

var QASMImport = require("./qasm_import/QASMImport.js");


var formatComplex2 = function(re, im, options) {
	options = options || {};

	var sre = formatFloat(re, options);

	var opt = JSON.parse(JSON.stringify(options));
	opt.plusChar = "+";
	var sim = formatFloat(im, opt);
	return sre + sim + (options.iotaChar ? options.iotaChar : "i");
};

var formatFloat = function(f, options) {
	options = options || {};

	if(options.decimalPlaces) {
		f = math.round(f, options.decimalPlaces);
	}

	var s = f + "";

	if(options.fixedWidth) {
		s = f.toFixed(options.decimalPlaces || 14);
	}

	var plusChar = options.plusChar;
	if(options.fixedWidth && !plusChar) {
		plusChar = " ";
	}

	if(plusChar && f >= 0) {
		s = plusChar + s;
	}

	return s;
};

var zeroesMatrix = function(n) {
	var matrix = [];
	for(var i = 0; i < n; i++) {
		matrix[i] = [];
		for(var j = 0; j < n; j++) {
			matrix[i][j] = 0;
		}
	}
	return matrix;
};

var identityMatrix = function(n) {
	var matrix = [];
	for(var i = 0; i < n; i++) {
		matrix[i] = [];
		for(var j = 0; j < n; j++) {
			matrix[i][j] = j == i ? 1 : 0;
		}
	}
	return matrix;
};


var makeControlled = function(U) {
	var m = U.length;
	var C = identityMatrix(m * 2);
	for (var i = 0; i < m; i++) {
		for (var j = 0; j < m; j++) {
			C[i + m][j + m] = U[i][j];
		}
	}
	return C;
};

var uniqueArray = function(array) {
  return array.filter(function(value, index, self) {
	return self.indexOf(value) === index;
  });
};

var qubitLetter = function(n, max) {
	maxN = max || (n + 1);

	if(maxN > 0) {
		maxN = maxN - 1;
	}

	maxLen = maxN.toString(26).length;

	var nStr = n.toString(26);
	while(nStr.length < maxLen) {
		nStr = "0" + nStr;
	}

	var res = "";
	for(var i = 0; i < nStr.length; i++) {
		var code = nStr.charCodeAt(i);
		res += String.fromCharCode(code < 97 ? code + 49 : code + 10);
	}

	return res;
};

var QuantumCircuit = function(numQubits) {
	this.basicGates = {
		id: {
			description: "Single qubit identity gate",
			matrix: [
				[1, 0],
				[0, 1]
			],
			params: [],
			drawingInfo: {
				connectors: ["box"],
				label: "ID"
			},
			exportInfo: {
				quil: {
					name: "I"
				},
				cirq: {
					name: "I",
					notTfqSupported: true
				},
				quest: {
					name: "compactUnitary",
					params: { alpha: "(Complex) { .real = 1, .imag = 0 }",
							beta: "(Complex) {.real = 0, .imag = 0}"}
				},
				qsharp: {
					name: "I"
				},
				qiskit: {
					name: "id"
				},
				braket: {
					name: "i"
				},
				aqasm: {
					name: "I"
				},
				cudaq: {
					name: "i",
					matrix: "[[1, 0], [0, 1]]"
				},
				quirk: {
					name: "…",
					controlQubits: 0,
					targetQubits: 1
				}
			}
		},

		x: {
			description: "Pauli X (PI rotation over X-axis) aka \"NOT\" gate",
			matrix: [
				[0,1],
				[1,0]
			],
			params: [],
			drawingInfo: {
				connectors: ["box"],
				label: "X"
			},
			exportInfo: {
				quil: {
					name: "X"
				},
				cirq: {
					name: "X"
				},
				quest: {
					name: "pauliX"
				},
				qsharp: {
					name: "X"
				},
				quirk: {
					name: "X",
					controlQubits: 0,
					targetQubits: 1
				},
				braket: {
					name: "x"
				},
				aqasm: {
					name: "X"
				},
				ionq: {
					names: [ "x", "not" ],
				},
				cudaq: {
					name: "x"
				}
			}
		},

		y: {
			description: "Pauli Y (PI rotation over Y-axis)",
			matrix: [
				[0,"-i"],
				["i",0]
			],
			params: [],
			drawingInfo: {
				connectors: ["box"],
				label: "Y"
			},
			exportInfo: {
				quil: {
					name: "Y"
				},
				cirq: {
					name: "Y"
				},
				quest: {
					name: "pauliY"
				},
				qsharp: {
					name: "Y"
				},
				quirk: {
					name: "Y",
					controlQubits: 0,
					targetQubits: 1
				},
				braket: {
					name: "y"
				},
				aqasm: {
					name: "Y"
				},
				ionq: {
					name: "y"
				},
				cudaq: {
					name: "y"
				}
			}
		},

		z: {
			description: "Pauli Z (PI rotation over Z-axis)",
			matrix: [
				[1,0],
				[0,-1]
			],
			params: [],
			drawingInfo: {
				connectors: ["box"],
				label: "Z"
			},
			exportInfo: {
				quil: {
					name: "Z"
				},
				cirq: {
					name: "Z"
				},
				quest: {
					name: "pauliZ"
				},
				qsharp: {
					name: "Z"
				},
				quirk: {
					name: "Z",
					controlQubits: 0,
					targetQubits: 1
				},
				braket: {
					name: "z"
				},
				aqasm: {
					name: "Z"
				},
				ionq: {
					name: "z"
				},
				cudaq: {
					name: "z"
				}
			}
		},

		h: {
			description: "Hadamard gate",
			matrix: [
				["1 / sqrt(2)","1 / sqrt(2)"],
				["1 / sqrt(2)","-1 / sqrt(2)"]
			],
			params: [],
			drawingInfo: {
				connectors: ["box"],
				label: "H"
			},
			exportInfo: {
				quil: {
					name: "H"
				},
				cirq: {
					name: "H"
				},
				quest: {
					name: "hadamard"
				},
				qsharp: {
					name: "H"
				},
				quirk: {
					name: "H",
					controlQubits: 0,
					targetQubits: 1
				},
				braket: {
					name: "h"
				},
				aqasm: {
					name: "H"
				},
				ionq: {
					name: "h"
				},
				cudaq: {
					name: "h"
				}
			}
		},

		srn: {
			description: "Square root of NOT",
			matrix: [
				["0.5+0.5i","0.5-0.5i"],
				["0.5-0.5i","0.5+0.5i"]
			],
			params: [],
			drawingInfo: {
				connectors: ["box"],
				label: "&#x221A;X"
			},
			exportInfo: {
				quil: {
					name: "srn",
					defgate: "DEFGATE srn:\n    0.5+0.5i, 0.5-0.5i\n    0.5-0.5i, 0.5+0.5i"
				},
				pyquil: {
					name: "srn",
					array: "[[0.5+0.5j, 0.5-0.5j], [0.5-0.5j, 0.5+0.5j]]"
				},
				cirq: {
					name: "X**(1/2)"
				},
				quest: {
					name: "unitary",
					matrix: [[["0.5", "0.5"], ["0.5", "-0.5"]],
						[["0.5", "-0.5"],["0.5", "0.5"]]]
				},
				qasm: {
					equivalent: [
						{ name: "h", wires: [0] },
						{ name: "u3", params: { theta: 0, phi: 0, lambda: "pi/2" }, wires: [0] },
						{ name: "h", wires: [0] }
					]
				},
				qiskit: {
					name: "sx"
				},
				braket: {
					name: "v"
				},
				aqasm: {
					matrix: [["0.5+0.5i","0.5-0.5i"],["0.5-0.5i","0.5+0.5i"]],
					array: "[[0.5+0.5j, 0.5-0.5j], [0.5-0.5j, 0.5+0.5j]]"
				},
				ionq: {
					name: "v"
				},
				cudaq: {
					equivalent: [
						{ name: "h", wires: [0] },
						{ name: "u3", params: { theta: 0, phi: 0, lambda: "pi/2" }, wires: [0] },
						{ name: "h", wires: [0] }
					]
				},
				quirk: {
					name: "X^½",
					controlQubits: 0,
					targetQubits: 1
				}
			}
		},

		srndg: {
			description: "Inverse square root of NOT",
			matrix: [
				["0.5-0.5i","0.5+0.5i"],
				["0.5+0.5i","0.5-0.5i"]
			],
			params: [],
			drawingInfo: {
				connectors: ["box"],
				label: "&#x221A;X&#8224;"
			},
			exportInfo: {
				quil: {
					name: "srndg",
					defgate: "DEFGATE srndg:\n    0.5-0.5i, 0.5+0.5i\n    0.5+0.5i, 0.5-0.5i"
				},
				pyquil: {
					name: "srndg",
					array: "[[0.5-0.5j, 0.5+0.5j], [0.5+0.5j, 0.5-0.5j]]"
				},
				cirq: {
					name: "X**(-1/2)"
				},
				quest: {
					name: "unitary",
					matrix: [[["0.5", "-0.5"], ["0.5", "0.5"]],
						[["0.5", "0.5"],["0.5", "-0.5"]]]
				},
				qasm: {
					equivalent: [
						{ name: "h", wires: [0] },
						{ name: "u3", params: { theta: 0, phi: 0, lambda: "-pi/2" }, wires: [0] },
						{ name: "h", wires: [0] }
					]
				},
				qiskit: {
					name: "sxdg"
				},
				braket: {
					name: "vi"
				},
				aqasm: {
					matrix: [["0.5-0.5i","0.5+0.5i"],["0.5+0.5i","0.5-0.5i"]],
					array: "[[0.5-0.5j, 0.5+0.5j], [0.5+0.5j, 0.5-0.5j]]"
				},
				ionq: {
					name: "vi"
				},
				cudaq: {
					equivalent: [
						{ name: "h", wires: [0] },
						{ name: "u3", params: { theta: 0, phi: 0, lambda: "-pi/2" }, wires: [0] },
						{ name: "h", wires: [0] }
					]
				},
				quirk: {
					name: "X^-½",
					controlQubits: 0,
					targetQubits: 1
				}
			}
		},

		r2: {
			description: "PI/2 rotation over Z-axis aka \"Phase PI/2\"",
			matrix: [
				[1,0],
				[0,"exp(i * pi / 2)"]
			],
			params: [],
			drawingInfo: {
				connectors: ["box"],
				label: "Z&#x1D6D1;/2"
			},

			exportInfo: {
				quil: {
					replacement: {
						name: "s"
					}
				},
				cirq: {
					replacement: {
						name: "s"
					}
				},
				quest: {
					name: "sGate"
				},
				qsharp: {
					replacement: {
						name: "s",
					}
				},
				qasm: {
					replacement: [
						{ name: "s", params: {} }
				   ]
				},
				qiskit: {
					replacement: [
						{ name: "s", params: {} }
				   ]
				},
				quirk: {
					name: "Z^½",
					controlQubits: 0,
					targetQubits: 1
				},
				braket: {
					name: "s"
				},
				aqasm: {
					name: "S"
				},
				cudaq: {
					name: "s"
				}
			}
		},

		r4: {
			description: "PI/4 rotation over Z-axis aka \"Phase PI/4\"",
			matrix: [
				[1,0],
				[0,"exp(i * pi / 4)"]
			],
			params: [],
			drawingInfo: {
				connectors: ["box"],
				label: "Z&#x1D6D1;/4"
			},
			exportInfo: {
				quil: {
					replacement: {
						name: "t"
					}
				},
				cirq: {
					replacement: {
						name: "t"
					}
				},
				quest: {
					name: "tGate"
				},
				qsharp: {
					replacement: {
						name: "t"
					}
				},
				qasm: {
					replacement: [
						{ name: "t", params: {} }
				   ]
				},
				qiskit: {
					replacement: [
						{ name: "t", params: {} }
				   ]
				},
				quirk: {
					name: "Z^¼",
					controlQubits: 0,
					targetQubits: 1
				},
				braket: {
					name: "t"
				},
				aqasm: {
					name: "T"
				},
				cudaq: {
					name: "t"
				}
			}
		},

		r8: {
			description: "PI/8 rotation over Z-axis aka \"Phase PI/8\"",
			matrix: [
				[1,0],
				[0,"exp(i * pi / 8)"]
			],
			params: [],
			drawingInfo: {
				connectors: ["box"],
				label: "Z&#x1D6D1;/8"
			},
			exportInfo: {
				quil: {
					replacement: {
						name: "u1",
						params: {
							lambda: "pi/8"
						}
					}
				},
				cirq: {
					replacement: {
						name: "u1",
						params: {
							lambda: "pi/8"
						}
					}
				},
				quest: {
					name: "phaseShift",
					params: {theta: "M_PI/8"}
				},
				qsharp: {
					replacement: {
						name: "u1",
						params: {
							lambda: "pi/8"
						}
					}
				},
				qasm: {
					replacement: [
						{ name: "u1", params: { lambda: "pi/8" } }
				   ]
				},
				qiskit: {
					replacement: [
						{ name: "u1", params: { lambda: "pi/8" } }
				   ]
				},
				quirk: {
					name: "Z^⅛",
					controlQubits: 0,
					targetQubits: 1
				},
				braket: {
					name: "phaseshift",
					params: {theta: "pi/8"}
				},
				aqasm: {
					matrix: [[1,0],[0,"exp(i * pi / 8)"]],
					array: "[[1,0],[0,np.exp(1j * np.pi / 8)]]"
				},
				cudaq: {
					replacement: [
						{ name: "u3", params: { theta: 0, phi: 0, lambda: "pi/8" } }
					]				
				}
			}
		},

		rx: {
			description: "Rotation around the X-axis by given angle",
			matrix: [
				["cos(theta / 2)", "-i * sin(theta / 2)"],
				["-i * sin(theta / 2)", "cos(theta / 2)"]
			],
			params: ["theta"],
			drawingInfo: {
				connectors: ["box"],
				label: "RX"
			},
			exportInfo: {
				quil: {
					name: "RX",
					params: ["theta"]
				},
				cirq: {
					name: "rx",
					params: ["theta"]
				},
				quest: {
					name: "rotateX",
					params: ["theta"]
				},
				qsharp: {
					name: "Rx",
					params: ["theta"]
				},
				braket: {
					name: "rx",
					params: ["theta"]
				},
				aqasm: {
					name: "RX"
				},
				ionq: {
					name: "rx",
					paramsKey: "rotation"
				},
				cudaq: {
					name: "rx"
				},
				quirk: {
					controlQubits: 0,
					targetQubits: 1
				}
			}
		},

		ry: {
			description: "Rotation around the Y-axis by given angle",
			matrix: [
				["cos(theta / 2)", "-1 * sin(theta / 2)"],
				["sin(theta / 2)", "cos(theta / 2)"]
			],
			params: ["theta"],
			drawingInfo: {
				connectors: ["box"],
				label: "RY"
			},
			exportInfo: {
				quil: {
					name: "RY",
					params: ["theta"]
				},
				cirq: {
					name: "ry",
					params: ["theta"]
				},
				quest: {
					name: "rotateY",
					params: ["theta"]
				},
				qsharp: {
					name: "Ry",
					params: ["theta"]
				},
				braket: {
					name: "ry",
					params: ["theta"]
				},
				aqasm: {
					name: "RY"
				},
				ionq: {
					name: "ry",
					paramsKey: "rotation"
				},
				cudaq: {
					name: "ry"
				},
				quirk: {
					controlQubits: 0,
					targetQubits: 1
				}
			}
		},

		rz: {
			description: "Rotation around the Z-axis by given angle",
			
			matrix: [
				["cos(phi / 2) - i * sin(phi / 2)", 0],
				[0, "cos(phi / 2) + i * sin(phi / 2)"]
			],

			params: ["phi"],
			drawingInfo: {
				connectors: ["box"],
				label: "RZ"
			},
			exportInfo: {
				quil: {
					name: "RZ",
					params: ["phi"]
				},
				cirq: {
					name: "rz",
					params: ["theta"]
				},
				quest: {
					name: "rZ",
					//@TODO add function
					func: "TODO"
				},
				qsharp: {
					name: "Rz",
					params: ["theta"]
				},
				braket: {
					name: "rz",
					params: ["phi"]
				},
				aqasm: {
					name: "RZ"
				},
				ionq: {
					name: "rz",
					paramsKey: "rotation"
				},
				cudaq: {
					name: "rz"
				},
				quirk: {
					controlQubits: 0,
					targetQubits: 1
				}
			}
		},

		u1: {
			description: "Single-qubit rotation about the Z axis",
			matrix: [
				[1,0],
				[0,"exp(i * lambda)"]
			],
			params: ["lambda"],
			drawingInfo: {
				connectors: ["box"],
				label: "U1"
			},
			exportInfo: {
				quil: {
					name: "PHASE",
					params: ["lambda"]
				},
				cirq: {
					name: "u1",
					params: ["lambda"],
					array: "[[1, 0], [0, np.exp(1j*p_lambda)]]",
					notTfqSupported: true
				},
				quest: {
					name: "phaseShift",
					params: ["lambda"]
				},
				braket: {
					name: "phaseshift",
					params: ["lambda"]
				},
				qiskit: {
					name: "p"
				},
				aqasm: {
					name: "PH"
				},
				cudaq: {
					replacement: [
						{ name: "u3", params: { theta: 0, phi: 0, lambda: "lambda" } }
					]
				},
				quirk: {
					controlQubits: 0,
					targetQubits: 1
				}
			}
		},

		u2: {
			description: "Single-qubit rotation about the X+Z axis",
			matrix: [
				["1 / sqrt(2)", "-exp(i * lambda) * 1 / sqrt(2)"],
				["exp(i * phi) * 1 / sqrt(2)", "exp(i * lambda + i * phi) * 1 / sqrt(2)"]
			],
			params: ["phi", "lambda"],
			drawingInfo: {
				connectors: ["box"],
				label: "U2"
			},
			exportInfo: {
				quil: {
					name: "u2",
					params: ["phi", "lambda"],
					defgate: "DEFGATE u2(%phi, %lambda):\n    1/SQRT(2), -1*EXP(i*%lambda)*1/SQRT(2)\n    EXP(i*%phi)*1/SQRT(2), EXP(i*%lambda + i*%phi)*1/SQRT(2)"
				},
				pyquil: {
					name: "u2",
					params: ["phi", "lambda"],
					array: "[[1/quil_sqrt(2),-quil_exp(1j*p_lambda)*1/quil_sqrt(2)],[quil_exp(1j*p_phi)*1/quil_sqrt(2),quil_exp(1j*p_lambda+1j*p_phi)*1/quil_sqrt(2)]]"
				},
				cirq: {
					name: "u2",
					params: ["phi", "lambda"],
					array: "[[1/np.sqrt(2), -np.exp(1j*p_lambda)*1/np.sqrt(2)], [np.exp(1j*p_phi)*1/np.sqrt(2), np.exp(1j*p_lambda+1j*p_phi)*1/np.sqrt(2)]]",
					notTfqSupported: true
				},
				quest: {
					name: "unitary",
					params: ["phi", "lambda"],
					matrix: [[["1/sqrt(2)", "0"], ["-cos(lambda)/sqrt(2)", "-sin(lambda)/sqrt(2)"]],
							 [["cos(phi)/sqrt(2)", "sin(phi)/sqrt(2)"], ["cos(lambda+phi)/sqrt(2)", "sin(lambda+phi)/sqrt(2)"]]]
				},
				braket: {
					name: "unitary",
					params: ["phi", "lambda"],
					array: "[[1/np.sqrt(2), -np.exp(1j*p_lambda)*1/np.sqrt(2)], [np.exp(1j*p_phi)*1/np.sqrt(2), np.exp(1j*p_lambda+1j*p_phi)*1/np.sqrt(2)]]"
				},
				aqasm: {
					matrix: [["1 / sqrt(2)", "-exp(i * lambda) * 1 / sqrt(2)"],["exp(i * phi) * 1 / sqrt(2)", "exp(i * lambda + i * phi) * 1 / sqrt(2)"]],
					array: "[[1/np.sqrt(2), -np.exp(1j*p_lambda)*1/np.sqrt(2)], [np.exp(1j*p_phi)*1/np.sqrt(2), np.exp(1j*p_lambda+1j*p_phi)*1/np.sqrt(2)]]",
					params: ["phi", "lambda"]
				},
				qiskit: {
					replacement: [
						{ name: "u3", params: { theta: "pi/2", phi: "phi", lambda: "lambda" } }
					]
				},
				cudaq: {
					replacement: [
						{ name: "u3", params: { theta: "pi/2", phi: "phi", lambda: "lambda" } }
					]
				},
				quirk: {
					controlQubits: 0,
					targetQubits: 1
				}
			}
		},

		u3: {
			description: "Generic single-qubit rotation gate with 3 Euler angles",
			matrix: [
				[ "cos(theta/2)", "-exp(i * lambda) * sin(theta / 2)" ],
				[ "exp(i * phi) * sin(theta / 2)", "exp(i * lambda + i * phi) * cos(theta / 2)" ]
			],
			params: ["theta", "phi", "lambda"],
			drawingInfo: {
				connectors: ["box"],
				label: "U3"
			},
			exportInfo: {
				quil: {
					name: "u3",
					params: ["theta", "phi", "lambda"],
					defgate: "DEFGATE u3(%theta, %phi, %lambda):\n    COS(%theta/2), -1*EXP(i*%lambda)*SIN(%theta/2)\n    EXP(i*%phi)*SIN(%theta/2), EXP(i*%lambda + i*%phi)*COS(%theta/2)"
				},
				pyquil: {
					name: "u3",
					params: ["theta", "phi", "lambda"],
					array: "[[quil_cos(p_theta/2),-quil_exp(1j*p_lambda)*quil_sin(p_theta/2)],[quil_exp(1j*p_phi)*quil_sin(p_theta/2),quil_exp(1j*p_lambda+1j*p_phi)*quil_cos(p_theta/2)]]"
				},
				cirq: {
					name: "u3",
					params: ["theta", "phi", "lambda"],
					array: "[[np.cos(p_theta/2), -np.exp(1j*p_lambda)*np.sin(p_theta/2)], [np.exp(1j*p_phi)*np.sin(p_theta/2), np.exp(1j*p_lambda+1j*p_phi)*np.cos(p_theta/2)]]",
					notTfqSupported: true
				},
				quest: {
					name: "unitary",
					params: ["theta", "phi", "lambda"],
					matrix: [[["cos(theta/2)", "0"], ["-cos(lambda)*sin(theta/2)", "-sin(lambda)*sin(theta/2)"]],
							 [["cos(phi)*sin(theta/2)", "sin(phi)*sin(theta/2)"], ["cos(lambda+phi)*cos(theta/2)", "sin(lambda+phi)*cos(theta/2)"]]]
				},
				braket: {
					name: "unitary",
					params: ["theta", "phi", "lambda"],
					array: "[[np.cos(p_theta/2), -np.exp(1j*p_lambda)*np.sin(p_theta/2)], [np.exp(1j*p_phi)*np.sin(p_theta/2), np.exp(1j*p_lambda+1j*p_phi)*np.cos(p_theta/2)]]"
				},
				qiskit: {
					name: "u"
				},
				aqasm: {
					matrix: [[ "cos(theta/2)", "-exp(i * lambda) * sin(theta / 2)" ],[ "exp(i * phi) * sin(theta / 2)", "exp(i * lambda + i * phi) * cos(theta / 2)" ]],
					array: "[[np.cos(p_theta/2), -np.exp(1j*p_lambda)*np.sin(p_theta/2)], [np.exp(1j*p_phi)*np.sin(p_theta/2), np.exp(1j*p_lambda+1j*p_phi)*np.cos(p_theta/2)]]",
					params: ["theta", "phi", "lambda"]
				},
				cudaq: {
					name: "u3"
				},
				quirk: {
					controlQubits: 0,
					targetQubits: 1
				}
			}
		},

		s: {
			description: "PI/2 rotation over Z-axis (synonym for `r2`)",
			matrix: [
				[1,0],
				[0,"i"]
			],
			params: [],
			drawingInfo: {
				connectors: ["box"],
				label: "S"
			},
			exportInfo: {
				quil: {
					name: "S"
				},
				cirq: {
					name: "S"
				},
				quest: {
					name: "sGate"
				},
				qsharp: {
					name: "S"
				},
				quirk: {
					name: "Z^½",
					controlQubits: 0,
					targetQubits: 1
				},
				braket: {
					name: "s"
				},
				aqasm: {
					name: "S"
				},
				ionq: {
					name: "s"
				},
				cudaq: {
					name: "s"
				}
			}
		},

		t: {
			description: "PI/4 rotation over Z-axis (synonym for `r4`)",
			matrix: [
				[1,0],
				[0,"exp(i * pi / 4)"]
			],
			params: [],
			drawingInfo: {
				connectors: ["box"],
				label: "T"
			},
			exportInfo: {
				quil: {
					name: "T"
				},
				cirq: {
					name: "T"
				},
				quest: {
					name: "tGate"
				},
				qsharp: {
					name: "T"
				},
				quirk: {
					name: "Z^¼",
					controlQubits: 0,
					targetQubits: 1
				},
				braket: {
					name: "t"
				},
				aqasm: {
					name: "T"
				},
				ionq: {
					name: "t"
				},
				cudaq: {
					name: "t"
				}
			}
		},

		sdg: {
			description: "(-PI/2) rotation over Z-axis",
			matrix: [
				[1,0],
				[0,"-i"]
			],
			params: [],
			drawingInfo: {
				connectors: ["box"],
				label: "S&#8224;"
			},
			exportInfo: {
				quil: {
					replacement: {
						name: "u1",
						params: {
							lambda: "-pi/2"
						}
					}
				},
				cirq: {
					replacement: {
						name: "u1",
						params: {
							lambda: "-pi/2"
						}
					}
				},
				quest: {
					name: "phaseShift",
					params: { theta: "-M_PI/2" }
				},
				qsharp: {
					replacement: {
						name: "u1",
						params: {
							lambda: "-pi/2"
						}
					}
				},
				quirk: {
					name: "Z^-½",
					controlQubits: 0,
					targetQubits: 1
				},
				braket: {
					name: "si"
				},
				aqasm: {
					name: "S",
					dagger: true
				},
				ionq: {
					name: "si"
				},
				cudaq: {
					name: "sdg"
				}
			}
		},

		tdg: {
			description: "(-PI/4) rotation over Z-axis",
			matrix: [
				[1,0],
				[0,"exp(-i * pi / 4)"]
			],
			params: [],
			drawingInfo: {
				connectors: ["box"],
				label: "T&#8224;"
			},
			exportInfo: {
				quil: {
					replacement: {
						name: "u1",
						params: {
							lambda: "-pi/4"
						}
					}
				},
				cirq: {
					replacement: {
						name: "u1",
						params: {
							lambda: "-pi/4"
						}
					}
				},
				quest: {
					name: "phaseShift",
					params: { theta: "-M_PI/4" }
				},
				qsharp: {
					replacement: {
						name: "u1",
						params: {
							lambda: "-pi/4"
						}
					}
				},
				quirk: {
					name: "Z^-¼",
					controlQubits: 0,
					targetQubits: 1
				},
				braket: {
					name: "ti"
				},
				aqasm: {
					name: "T",
					dagger: true
				},
				ionq: {
					name: "ti"
				},
				cudaq: {
					name: "tdg"
				}
			}
		},

		gpi: {
			description: "GPi gate",
			matrix: [
				[0, "exp(-i*phi)"],
				["exp(i*phi)", 0]
			],
			params: ["phi"],
			drawingInfo: {
				connectors: ["box"],
				label: "GPi"
			},

			exportInfo: {
				quil: {
					name: "gpi",
					params: ["phi"],
					defgate: "DEFGATE gpi(%phi):\n    0, EXP(-i * %phi)\n    EXP(i * %phi), 0"
				},
				pyquil: {
					name: "gpi",
					params: ["phi"],
					array: "[ [ 0, quil_exp(-1j*p_phi) ], [ quil_exp(1j*p_phi), 0 ] ]"
				},
				cirq: {
					name: "gpi"
				},
				quest: {
					name: "gpi",
					//@TODO add function
					func: "TODO"
				},
				qasm: {
					equivalent: [
						{ name: "u3", params: { theta: "pi", phi: "phi", lambda: "pi-phi" }, wires: [0] }
					]
				},
				qiskit: {
					equivalent: [
						{ name: "u3", params: { theta: "pi", phi: "phi", lambda: "pi-phi" }, wires: [0] }
					]
				},
				braket: {
					name: "unitary",
					params: ["phi"],
					array: "[ [ 0, np.exp(-1j*p_phi) ], [ np.exp(1j*p_phi), 0 ] ]"
				},
				aqasm: {
					matrix: [ [ 0, "exp(-i*phi)" ], [ "exp(i*phi)", 0] ],
					array: "[ [ 0, np.exp(-1j*p_phi) ], [ np.exp(1j*p_phi), 0 ] ]",
					params: ["phi"]
				},
				ionq: {
					name: "gpi",
					paramsKey: "phase"
				},
				cudaq: {
					equivalent: [
						{ name: "u3", params: { theta: "pi", phi: "phi", lambda: "pi-phi" }, wires: [0] }
					]
				},
				quirk: {
					controlQubits: 0,
					targetQubits: 1
				}
			}
		},

		gpi2: {
			description: "GPi2 gate",
			matrix: [
				["1/sqrt(2)", "(-i*exp(-i*phi))/sqrt(2)"],
				["(-i*exp(i*phi))/sqrt(2)", "1/sqrt(2)"]
			],
			params: ["phi"],
			drawingInfo: {
				connectors: ["box"],
				label: "GPi2"
			},
			exportInfo: {
				quil: {
					name: "gpi2",
					params: ["phi"],
					defgate: "DEFGATE gpi2(%phi):\n    1/SQRT(2), (-i*EXP(-i * %phi)) / SQRT(2)\n    (-i*EXP(i * %phi)) / SQRT(2), 1/SQRT(2)"
				},
				pyquil: {
					name: "gpi2",
					params: ["phi"],
					array: "[ [ 1/quil_sqrt(2), (-1j*quil_exp(-1j*p_phi))/quil_sqrt(2) ], [ (-1j*quil_exp(1j*p_phi))/quil_sqrt(2), 1/quil_sqrt(2) ] ]"
				},
				cirq: {
					name: "gpi2"
				},
				quest: {
					name: "gpi2",
					//@TODO add function
					func: "TODO"
				},
				qasm: {
					equivalent: [
						{ name: "u3", params: { theta: "pi/2", phi: "phi-(pi/2)", lambda: "(pi/2)-phi" }, wires: [0] }
					]
				},
				qiskit: {
					equivalent: [
						{ name: "u3", params: { theta: "pi/2", phi: "phi-(pi/2)", lambda: "(pi/2)-phi" }, wires: [0] }
					]
				},
				braket: {
					name: "unitary",
					params: ["phi"],
					array: "[ [ 1/np.sqrt(2), (-1j*np.exp(-1j*p_phi))/np.sqrt(2) ], [ (-1j*np.exp(1j*p_phi))/np.sqrt(2), 1/np.sqrt(2) ] ]"
				},
				aqasm: {
					matrix: [ [ "1/sqrt(2)", "(-i*exp(-i*phi))/sqrt(2)" ], [ "(-i*exp(i*phi))/sqrt(2)", "1/sqrt(2)" ] ],
					array: "[ [ 1/np.sqrt(2), (-1j*np.exp(-1j*p_phi))/np.sqrt(2) ], [ (-1j*np.exp(1j*p_phi))/np.sqrt(2), 1/np.sqrt(2) ] ]",
					params: ["phi"]
				},
				ionq: {
					name: "gpi2",
					paramsKey: "phase"
				},
				cudaq: {
					equivalent: [
						{ name: "u3", params: { theta: "pi/2", phi: "phi-(pi/2)", lambda: "(pi/2)-phi" }, wires: [0] }
					]
				},
				quirk: {
					controlQubits: 0,
					targetQubits: 1
				},
			}
		},

		vz: {
			description: "VirtualZ gate",
			matrix: [
				["exp(-i*theta/2)", 0],
				[0, "exp(i*theta/2)"]
			],
			params: ["theta"],
			drawingInfo: {
				connectors: ["box"],
				label: "VrtZ"
			},
			exportInfo: {
				quil: {
					name: "vz",
					params: ["theta"],
					defgate: "DEFGATE vz(%theta):\n    EXP(-i * %theta/2), 0\n    0, EXP(-i * %theta/2)"
				},
				pyquil: {
					name: "vz",
					params: ["theta"],
					array: "[ [ quil_exp(-1j*p_theta/2), 0 ], [ 0, quil_exp(1j*p_theta/2) ] ]"
				},
				cirq: {
					name: "vz"
				},
				quest: {
					name: "vz",
					//@TODO add function
					func: "TODO"
				},
				qasm: {
					equivalent: [
						{ name: "rz", params: { phi: "theta" }, wires: [0] }
					]
				},
				qiskit: {
					equivalent: [
						{ name: "rz", params: { phi: "theta" }, wires: [0] }
					]
				},
				braket: {
					name: "unitary",
					params: ["theta"],
					array: "[ [ np.exp(-1j*p_theta/2), 0 ], [ 0, np.exp(1j*p_theta/2) ] ]"
				},
				aqasm: {
					matrix: [ [ "exp(-i*theta/2)", 0 ], [ 0, "exp(i*theta/2)"] ],
					array: "[ [ np.exp(-1j*p_theta/2), 0 ], [ 0, np.exp(1j*p_theta/2) ] ]",
					params: ["theta"]
				},
				ionq: {
					name: "vz",
					paramsKey: "phase"
				},
				cudaq: {
					equivalent: [
						{ name: "rz", params: { phi: "theta" }, wires: [0] }
					]
				},
				quirk: {
					controlQubits: 0,
					targetQubits: 1
				}
			}
		},

		cx: {
			description: "Controlled NOT (CNOT) gate",
			matrix: [
				[1,0,0,0],
				[0,1,0,0],
				[0,0,0,1],
				[0,0,1,0]
			],
			numTargetQubits: 1,
			numControlQubits: 1,
			params: [],
			drawingInfo: {
				connectors: ["dot","not"],
				label: "X",
				root: "x"
			},
			exportInfo: {
				quil: {
					name: "CNOT"
				},
				cirq: {
					name: "CNOT"
				},
				quest: {
					name: "controlledNot"
				},
				qsharp: {
					name: "CNOT"
				},
				quirk: {
					name: "X",
					controlQubits: 1,
					targetQubits: 1
				},
				braket: {
					name: "cnot"
				},
				aqasm: {
					name: "CNOT"
				},
				ionq: {
					name: "cnot"
				},
				cudaq: {
					name: "cx"
				}
			}
		},

		cy: {
			description: "Controlled Y gate (controlled rotation over Y-axis by PI)",
			matrix: [
				[1,0,0,0],
				[0,1,0,0],
				[0,0,0,"-i"],
				[0,0,"i",0]
			],
			numTargetQubits: 1,
			numControlQubits: 1,
			params: [],
			drawingInfo: {
				connectors: ["dot","box"],
				label: "Y",
				root: "y"
			},
			exportInfo: {
				quest: {
					name: "controlledPauliY"
				},
				cirq: {
					replacement: {
						name: "y",
						type: "controlled",
						notTfqSupported: true
					}
				},
				quil: {
					name: "cy",
					defgate: "DEFGATE cy:\n    1, 0, 0, 0\n    0, 1, 0, 0\n    0, 0, 0, -i\n    0, 0, i, 0"
				},
				pyquil: {
					name: "cy",
					array: "[[1,0,0,0],[0,1,0,0],[0,0,0,-1j],[0,0,1j,0]]"
				},
				qsharp: {
					name: "Controlled Y"
				},
				quirk: {
					name: "Y",
					controlQubits: 1,
					targetQubits: 1
				},
				braket: {
					name: "cy"
				},
				aqasm: {
					name: "Y",
					controlled: true
				},
				cudaq: {
					name: "cy"
				}
			}
		},

		cz: {
			description: "Controlled Z gate (controlled rotation over Z-axis by PI)",
			matrix: [
				[1,0,0,0],
				[0,1,0,0],
				[0,0,1,0],
				[0,0,0,-1]
			],
			numTargetQubits: 2,
			numControlQubits: 0,
			params: [],
			drawingInfo: {
				connectors: ["dot","dot"],
				label: "Z",
				root: "z"
			},
			exportInfo: {
				quil: {
					name: "CZ"
				},
				cirq: {
					name: "CZ"
				},
				quest: {
					name: "controlledPhaseFlip"
				},
				qsharp: {
					name: "Controlled Z"
				},
				quirk: {
					name: "Z",
					controlQubits: 1,
					targetQubits: 1
				},
				braket: {
					name: "cz"
				},
				aqasm: {
					name: "CSIGN"
				},
				cudaq: {
					name: "cz"
				}
			}
		},

		ch: {
			description: "Controlled Hadamard gate",
			matrix: [
				[1,0,0,0],
				[0,1,0,0],
				[0,0,"1 / sqrt(2)","1 / sqrt(2)"],
				[0,0,"1 / sqrt(2)","-1 / sqrt(2)"]
			],
			numTargetQubits: 1,
			numControlQubits: 1,
			params: [],
			drawingInfo: {
				connectors: ["dot","box"],
				label: "H",
				root: "h"
			},
			exportInfo: {
				quest: {
					name: "controlledUnitary",
					matrix: [[["1/sqrt(2)", "0"], ["1/sqrt(2)", "0"]],
							 [["1/sqrt(2)", "0"], ["-1/sqrt(2)", "0"]]]
				},
				cirq: {
					replacement: {
						name: "h",
						type: "controlled",
						notTfqSupported: true
					}
				},
				quil: {
					name: "ch",					
					defgate: "DEFGATE ch:\n    1, 0, 0, 0\n    0, 1, 0, 0\n    0, 0, 0.7071067811865475, 0.7071067811865475\n    0, 0, 0.7071067811865475, -0.7071067811865475"
				},
				pyquil: {
					name: "ch",
					array: "[[1,0,0,0],[0,1,0,0],[0,0,1/np.sqrt(2),1/np.sqrt(2)],[0,0,1/np.sqrt(2),-1/np.sqrt(2)]]"
				},
				qsharp: {
					name: "Controlled H"
				},
				quirk: {
					name: "H",
					controlQubits: 1,
					targetQubits: 1
				},
				braket: {
					name: "unitary",
					array: "[[1,0,0,0],[0,1,0,0],[0,0,1/np.sqrt(2),1/np.sqrt(2)],[0,0,1/np.sqrt(2),-1/np.sqrt(2)]]"
				},
				aqasm: {
					name: "H",
					controlled: true
				},
				cudaq: {
					name: "ch"
				}
			}
		},

		csrn: {
			description: "Controlled square root of NOT",
			matrix: [
				[1,0,0,0],
				[0,1,0,0],
				[0,0,"0.5+0.5i","0.5-0.5i"],
				[0,0,"0.5-0.5i","0.5+0.5i"]
			],
			numTargetQubits: 1,
			numControlQubits: 1,
			params: [],
			drawingInfo: {
				connectors: ["dot","box"],
				label: "&#x221A;X",
				root: "srn"
			},
			exportInfo: {
				quest: {
					name: "controlledUnitary",
					matrix: [[["-1/sqrt(2)", "0"], ["-1/sqrt(2)", "0"]],
							 [["-1/sqrt(2)", "0"], ["1/sqrt(2)", "0"]]]
				},
				cirq: {
					replacement: {
						name: "srn",
						type: "controlled",
						notTfqSupported: true
					}
				},
				quil: {
					name: "csrn",
					defgate: "DEFGATE csrn:\n    1, 0, 0, 0\n    0, 1, 0, 0\n    0, 0, 0.5+0.5i, 0.5-0.5i\n    0, 0, 0.5-0.5i, 0.5+0.5i"
				},
				qasm: {
					name: "csx"
				},
				qiskit: {
					name: "csx"
				},
				pyquil: {
					name: "csrn",
					array: "[[1,0,0,0],[0,1,0,0],[0,0,0.5+0.5j,0.5-0.5j],[0,0,0.5-0.5j,0.5+0.5j]]"
				},
				braket: {
					name: "unitary",
					array: "[[1,0,0,0],[0,1,0,0],[0,0,0.5+0.5j,0.5-0.5j],[0,0,0.5-0.5j,0.5+0.5j]]"
				},
				aqasm: {
					matrix: [[1,0,0,0],[0,1,0,0],[0,0,"0.5+0.5i","0.5-0.5i"],[0,0,"0.5-0.5i","0.5+0.5i"]],
					array: "[[1,0,0,0],[0,1,0,0],[0,0,0.5+0.5j,0.5-0.5j],[0,0,0.5-0.5j,0.5+0.5j]]"
				},
				cudaq: {
					equivalent: [
						{ name: "h", wires: [1] },
						{ name: "cu1", params: { lambda: "pi/2" }, wires: [0, 1] },
						{ name: "h", wires: [1] }
					]
				},
				quirk: {
					name: "X^½",
					controlQubits: 1,
					targetQubits: 1
				}
			}
		},

		swap: {
			description: "Swaps the state of two qubits.",
			matrix: [
				[1,0,0,0],
				[0,0,1,0],
				[0,1,0,0],
				[0,0,0,1]
			],
			numTargetQubits: 2,
			numControlQubits: 0,
			params: [],
			drawingInfo: {
				connectors: ["x","x"],
				label: "SWP"
			},
			exportInfo: {
				quil: {
					name: "SWAP"
				},
				cirq: {
					name: "SWAP"
				},
				quest: {
					name: "swap",
					func: "void swap(Qureg qubits, const int q1, const int q2) {\n"+
						  "    controlledNot(qubits, q1, q2);\n" +
						  "    controlledNot(qubits, q2, q1);\n" +
						  "    controlledNot(qubits, q1, q2);\n}"
				},
				qsharp: {
					name: "SWAP"
				},
				quirk: {
					name: "Swap",
					controlQubits: 0,
					targetQubits: 2
				},
				braket: {
					name: "swap"
				},
				aqasm: {
					name: "SWAP"
				},
				ionq: {
					name: "swap"
				},
				cudaq: {
					name: "swap"
				}
			}
		},

		srswap: {
			description: "Square root of swap",
			matrix: [
				[1,0,0,0],
				[0,"0.5 * (1 + i)","0.5 * (1 - i)",0],
				[0,"0.5 * (1 - i)","0.5 * (1 + i)",0],
				[0,0,0,1]
			],
			numTargetQubits: 2,
			numControlQubits: 0,
			params: [],
			drawingInfo: {
				connectors: ["box","box"],
				label: "&#x221A;SWP"
			},
			exportInfo: {
				quil: {
					name: "srswap",
					defgate: "DEFGATE srswap:\n    1, 0, 0, 0\n    0, 0.5+0.5i, 0.5-0.5i, 0\n    0, 0.5-0.5i, 0.5+0.5i, 0\n    0, 0, 0, 1"
				},
				cirq: {
					name: "SWAP**(1/2)"
				},
				pyquil: {
					name: "srswap",
					array: "[[1,0,0,0],[0,0.5 * (1 + 1j),0.5 * (1 - 1j),0],[0,0.5 * (1 - 1j),0.5 * (1 + 1j),0],[0,0,0,1]]"
				},
				quest: {
					name: "srswap",
					func: "void srswap(Qureg qubits, const int q1, const int q2) {\n" +
						  "    controlledNot(qubits, q2, q1);\n"+
						  "    rotateY(qubits, q2, M_PI/2);\n"+
						  "    rotateZ(qubits, q2, M_PI/16);\n"+
						  "    controlledNot(qubits, q1, q2);\n"+
						  "    rotateZ(qubits, q1, M_PI/8);\n"+
						  "    rotateZ(qubits, q2, -M_PI/8);\n"+
						  "    controlledNot(qubits, q1, q2);\n"+
						  "    rotateZ(qubits, q2, M_PI/16);\n"+
						  "    rotateY(qubits, q2, -M_PI/2);\n"+
						  "    controlledNot(qubits, q2, q1);\n}"
				},
				qasm: {
					equivalent: [
						{ name: "u3", params: { theta: "pi/2", phi: "pi/2", lambda: "-1*pi" }, wires: [0]},
						{ name: "u3", params: { theta: "pi/2", phi: "-1*pi/2", lambda: "pi" }, wires: [1]},
						{ name: "cx", wires: [0, 1]},
						{ name: "u3", params: { theta: "pi/4", phi: "-1*pi/2", lambda: "-1*pi/2" }, wires: [0]},
						{ name: "u3", params: { theta: "pi/2", phi: "0", lambda: "7*pi/4" }, wires: [1]},
						{ name: "cx", wires: [0, 1]},
						{ name: "u3", params: { theta: "pi/4", phi: "-1*pi", lambda: "-1*pi/2" }, wires: [0]},
						{ name: "u3", params: { theta: "pi/2", phi: "pi", lambda: "pi/2" }, wires: [1]},
						{ name: "cx", wires: [0, 1]},
						{ name: "u3", params: { theta: "pi/2", phi: "0", lambda: "-3*pi/2" }, wires: [0]},
						{ name: "u3", params: { theta: "pi/2", phi: "pi/2", lambda: "0" }, wires: [1]},
				   ]
				},
				qiskit: {
					equivalent: [
						{ name: "u3", params: { theta: "pi/2", phi: "pi/2", lambda: "-1*pi" }, wires: [0]},
						{ name: "u3", params: { theta: "pi/2", phi: "-1*pi/2", lambda: "pi" }, wires: [1]},
						{ name: "cx", wires: [0, 1]},
						{ name: "u3", params: { theta: "pi/4", phi: "-1*pi/2", lambda: "-1*pi/2" }, wires: [0]},
						{ name: "u3", params: { theta: "pi/2", phi: "0", lambda: "7*pi/4" }, wires: [1]},
						{ name: "cx", wires: [0, 1]},
						{ name: "u3", params: { theta: "pi/4", phi: "-1*pi", lambda: "-1*pi/2" }, wires: [0]},
						{ name: "u3", params: { theta: "pi/2", phi: "pi", lambda: "pi/2" }, wires: [1]},
						{ name: "cx", wires: [0, 1]},
						{ name: "u3", params: { theta: "pi/2", phi: "0", lambda: "-3*pi/2" }, wires: [0]},
						{ name: "u3", params: { theta: "pi/2", phi: "pi/2", lambda: "0" }, wires: [1]},
					]
				},
				braket: {
					name: "unitary",
					array: "[[1,0,0,0],[0,0.5 * (1 + 1j),0.5 * (1 - 1j),0],[0,0.5 * (1 - 1j),0.5 * (1 + 1j),0],[0,0,0,1]]"
				},
				aqasm: {
					name: "SQRTSWAP"
				},
				cudaq: {
					equivalent: [
						{ name: "u3", params: { theta: "pi/2", phi: "pi/2", lambda: "-1*pi" }, wires: [0]},
						{ name: "u3", params: { theta: "pi/2", phi: "-1*pi/2", lambda: "pi" }, wires: [1]},
						{ name: "cx", wires: [0, 1]},
						{ name: "u3", params: { theta: "pi/4", phi: "-1*pi/2", lambda: "-1*pi/2" }, wires: [0]},
						{ name: "u3", params: { theta: "pi/2", phi: "0", lambda: "7*pi/4" }, wires: [1]},
						{ name: "cx", wires: [0, 1]},
						{ name: "u3", params: { theta: "pi/4", phi: "-1*pi", lambda: "-1*pi/2" }, wires: [0]},
						{ name: "u3", params: { theta: "pi/2", phi: "pi", lambda: "pi/2" }, wires: [1]},
						{ name: "cx", wires: [0, 1]},
						{ name: "u3", params: { theta: "pi/2", phi: "0", lambda: "-3*pi/2" }, wires: [0]},
						{ name: "u3", params: { theta: "pi/2", phi: "pi/2", lambda: "0" }, wires: [1]},
					]
				},
				quirk: {
					controlQubits: 0,
					targetQubits: 2
				}
			}
		},

		iswap: {
			description: "Swaps the state of two qubits, applying a -i phase to q1 when it is in the 1 state and a -i phase to q2 when it is in the 0 state",
			matrix: [
				[1,0,0,0],
				[0,0,"0+i",0],
				[0,"0+i",0,0],
				[0,0,0,1]
			],
			numTargetQubits: 2,
			numControlQubits: 0,
			params: [],
			drawingInfo: {
				connectors: ["box","box"],
				label: "iSWP"
			},
			exportInfo: {
				quil: {
					name: "ISWAP"
				},
				cirq: {
					name: "ISWAP"
				},
				quest: {
					name: "iSWAP",
					//@TODO add function
					func: "TODO"
				},
				qasm: {
					equivalent: [
						{ name: "u3", params: { theta: "pi/2", phi: "-1*pi/2", lambda: "-1*pi" }, wires: [0]},
						{ name: "u3", params: { theta: "pi/2", phi: "-1*pi/2", lambda: "pi" }, wires: [1]},
						{ name: "cx", wires: [0, 1]},
						{ name: "u3", params: { theta: "pi/2", phi: "0", lambda: "3*pi/2" }, wires: [0]},
						{ name: "u3", params: { theta: "pi/2", phi: "3*pi/2", lambda: "0" }, wires: [1]},
						{ name: "cx", wires: [0, 1]},
						{ name: "u3", params: { theta: "pi/2", phi: "0", lambda: "0" }, wires: [0]},
						{ name: "u3", params: { theta: "pi", phi: "pi/4", lambda: "-1*pi/4" }, wires: [1]}
				   ]
				},
				qiskit: {
					equivalent: [
						{ name: "u3", params: { theta: "pi/2", phi: "-1*pi/2", lambda: "-1*pi" }, wires: [0]},
						{ name: "u3", params: { theta: "pi/2", phi: "-1*pi/2", lambda: "pi" }, wires: [1]},
						{ name: "cx", wires: [0, 1]},
						{ name: "u3", params: { theta: "pi/2", phi: "0", lambda: "3*pi/2" }, wires: [0]},
						{ name: "u3", params: { theta: "pi/2", phi: "3*pi/2", lambda: "0" }, wires: [1]},
						{ name: "cx", wires: [0, 1]},
						{ name: "u3", params: { theta: "pi/2", phi: "0", lambda: "0" }, wires: [0]},
						{ name: "u3", params: { theta: "pi", phi: "pi/4", lambda: "-1*pi/4" }, wires: [1]}
					]
				},
				braket: {
					name: "iswap"
				},
				aqasm: {
					name: "ISWAP"
				},
				cudaq: {
					equivalent: [
						{ name: "u3", params: { theta: "pi/2", phi: "-1*pi/2", lambda: "-1*pi" }, wires: [0]},
						{ name: "u3", params: { theta: "pi/2", phi: "-1*pi/2", lambda: "pi" }, wires: [1]},
						{ name: "cx", wires: [0, 1]},
						{ name: "u3", params: { theta: "pi/2", phi: "0", lambda: "3*pi/2" }, wires: [0]},
						{ name: "u3", params: { theta: "pi/2", phi: "3*pi/2", lambda: "0" }, wires: [1]},
						{ name: "cx", wires: [0, 1]},
						{ name: "u3", params: { theta: "pi/2", phi: "0", lambda: "0" }, wires: [0]},
						{ name: "u3", params: { theta: "pi", phi: "pi/4", lambda: "-1*pi/4" }, wires: [1]}
					]
				},
				quirk: {
					controlQubits: 0,
					targetQubits: 2
				}
			}
		},

		xx: {
			description: "XX gate",
			matrix: [
				["cos(theta)", 0, 0, "-i*sin(theta)"],

				[0, "cos(theta)", "-i*sin(theta)", 0],

				[0, "-i*sin(theta)", "cos(theta)", 0],

				["-i*sin(theta)", 0, 0, "cos(theta)"]
			],
			numTargetQubits: 2,
			numControlQubits: 0,
			params: ["theta"],
			drawingInfo: {
				connectors: ["box","box"],
				label: "XX"
			},
			exportInfo: {
				quil: {
					name: "xx",
					params: ["theta"],
					defgate: "DEFGATE xx(%theta):\n    COS(%theta), 0, 0, -i*SIN(%theta)\n    0, COS(%theta), -i*SIN(%theta), 0\n    0, -i*SIN(%theta), COS(%theta), 0\n    -i*SIN(%theta), 0, 0, COS(%theta)"
				},
				pyquil: {
					name: "xx",
					params: ["theta"],
					array: "[ [quil_cos(p_theta), 0, 0, -1j*quil_sin(p_theta)], [0, quil_cos(p_theta), -1j*quil_sin(p_theta), 0], [0, -1j*quil_sin(p_theta), quil_cos(p_theta), 0], [-1j*quil_sin(p_theta), 0, 0, quil_cos(p_theta)] ]"
				},
				cirq: {
					name: "xx"
				},
				quest: {
					name: "xx",
					//@TODO add function
					func: "TODO"
				},
				qasm: {
					name: "rxx"
				},
				qiskit: {
					name: "rxx"
				},
				braket: {
					name: "unitary",
					params: ["theta"],
					array: "[[np.cos(p_theta), 0, 0, -1j*np.sin(p_theta)], [0, np.cos(p_theta), -1j*np.sin(p_theta), 0], [0, -1j*np.sin(p_theta), np.cos(p_theta), 0], [-1j*np.sin(p_theta), 0, 0, np.cos(p_theta)] ]"
				},
				aqasm: {
					matrix: [["cos(theta)", 0, 0, "-i*sin(theta)"],[0, "cos(theta)", "-i*sin(theta)", 0],[0, "-i*sin(theta)", "cos(theta)", 0],["-i*sin(theta)", 0, 0, "cos(theta)"]],
					array: "[[np.cos(p_theta), 0, 0, -1j*np.sin(p_theta)], [0, np.cos(p_theta), -1j*np.sin(p_theta), 0], [0, -1j*np.sin(p_theta), np.cos(p_theta), 0], [-1j*np.sin(p_theta), 0, 0, np.cos(p_theta)] ]",
					params: ["theta"]
				},
				ionq: {
					name: "xx",
					paramsKey: "phase"
				},
				quirk: {
					controlQubits: 0,
					targetQubits: 2
				}
			}
		},
		
		yy: {
			description: "YY gate",
			matrix: [
				["cos(theta)", 0, 0, "i*sin(theta)"],

				[0, "cos(theta)", "-i*sin(theta)", 0],

				[0, "-i*sin(theta)", "cos(theta)", 0],

				["i*sin(theta)", 0, 0, "cos(theta)"]
			],
			numTargetQubits: 2,
			numControlQubits: 0,
			params: ["theta"],
			drawingInfo: {
				connectors: ["box","box"],
				label: "YY"
			},
			exportInfo: {
				quil: {
					name: "yy",
					params: ["theta"],
					defgate: "DEFGATE yy(%theta):\n    COS(%theta), 0, 0, i*SIN(%theta)\n    0, COS(%theta), -i*SIN(%theta), 0\n    0, -i*SIN(%theta), COS(%theta), 0\n    i*SIN(%theta), 0, 0, COS(%theta)"
				},
				cirq: {
					name: "YY"
				},
				pyquil: {
					name: "yy",
					params: ["theta"],
					array: "[ [quil_cos(p_theta), 0, 0, 1j*quil_sin(p_theta)], [0, quil_cos(p_theta), -1j*quil_sin(p_theta), 0], [0, -1j*quil_sin(p_theta), quil_cos(p_theta), 0], [1j*quil_sin(p_theta), 0, 0, quil_cos(p_theta)] ]"
				},
				quest: {
					name: "yy",
					//@TODO add function
					func: "TODO"
				},
				braket: {
					name: "yy",
					params: ["theta"]
				},
				aqasm: {
					matrix: [["cos(theta)", 0, 0, "i*sin(theta)"],[0, "cos(theta)", "-i*sin(theta)", 0],[0, "-i*sin(theta)", "cos(theta)", 0],["i*sin(theta)", 0, 0, "cos(theta)"]],
					array: "[[np.cos(p_theta), 0, 0, 1j*np.sin(p_theta)], [0, np.cos(p_theta), -1j*np.sin(p_theta), 0], [0, -1j*np.sin(p_theta), np.cos(p_theta), 0], [1j*np.sin(p_theta), 0, 0, np.cos(p_theta)] ]",
					params: ["theta"]
				},
				qasm: {
					name: "ryy"
				},
				qiskit: {
					name: "ryy"
				},
				ionq: {
					name: "yy",
					paramsKey: "phase"
				},
				quirk: {
					controlQubits: 0,
					targetQubits: 2
				}
			}
		},

		zz: {
			description: "Parametric 2-qubit rotation about ZZ",
			matrix: [
				[ "exp(-i * theta / 2)", 0, 0, 0 ],
				[ 0, "exp(i * theta / 2)", 0, 0  ],
				[ 0, 0, "exp(i * theta / 2)", 0  ],
				[ 0, 0, 0, "exp(-i * theta / 2)" ]
			],
			numTargetQubits: 2,
			numControlQubits: 0,
			params: ["theta"],
			drawingInfo: {
				connectors: ["box","box"],
				label: "ZZ"
			},
			exportInfo: {
				quil: {
					name: "zz",
					params: ["theta"],
					defgate: "DEFGATE zz(%theta):\n    EXP(-i * %theta / 2), 0, 0, 0\n    0, EXP(i * %theta / 2), 0, 0\n    0, 0, EXP(i * %theta / 2), 0\n    0, 0, 0, EXP(-i * %theta / 2)"
				},
				pyquil: {
					name: "zz",
					params: ["theta"],
					array: "[ [ quil_exp(-1j * p_theta / 2), 0, 0, 0 ], [ 0, quil_exp(1j * p_theta / 2), 0, 0], [ 0, 0, quil_exp(1j * p_theta / 2), 0 ], [ 0, 0, 0, quil_exp(-1j * p_theta / 2) ] ]"
				},
				quest: {
					name: "zz",
					//@TODO add function
					func: "TODO"
				},
				qasm: {
					name: "rzz"
				},
				qiskit: {
					name: "rzz"
				},
				ionq: {
					name: "zz",
					paramsKey: "phase"
				},
				quirk: {
					controlQubits: 0,
					targetQubits: 2
				}
			}
		},

		xy: {
			description: "XY gate",
			matrix: [
				[1, 0, 0, 0],
				[0, "cos(phi / 2)", "i * sin(phi / 2)", 0],
				[0, "i * sin(phi / 2)", "cos(phi / 2)", 0],
				[0, 0, 0, 1]
			],
			numTargetQubits: 2,
			numControlQubits: 0,
			params: ["phi"],
			drawingInfo: {
				connectors: ["box","box"],
				label: "XY"
			},
			exportInfo: {
				quil: {
					name: "XY",
					"params": [
						"phi"
					]
				},
				qasm: {
					equivalent: [
						{ name: "rz", params: { phi: "3*pi/4"}, wires: [0] },
						{ name: "rx", params: { theta: "pi/2"}, wires: [0] },
						{ name: "rz", params: { phi: "-3*pi/4"}, wires: [1] },
						{ name: "rx", params: { theta: "pi/2"}, wires: [1] },
						{ name: "cz", wires: [1, 0] },
						{ name: "rz", params: { phi: "-1*pi/2"}, wires: [0] },
						{ name: "rx", params: { theta: "pi/2"}, wires: [0] },
						{ name: "rz", params: { phi: "phi/2"}, wires: [0] },
						{ name: "rx", params: { theta: "-1*pi/2"}, wires: [0] },
						{ name: "rz", params: { phi: "pi/2"}, wires: [1] },
						{ name: "rx", params: { theta: "pi/2"}, wires: [1] },
						{ name: "rz", params: { phi: "phi/2"}, wires: [1] },
						{ name: "rx", params: { theta: "-1*pi/2"}, wires: [1] },
						{ name: "cz", wires: [1, 0] },
						{ name: "rz", params: { phi: "-1*pi/2"}, wires: [0] },
						{ name: "rx", params: { theta: "pi/2"}, wires: [0] },
						{ name: "rz", params: { phi: "pi/4"}, wires: [0] },
						{ name: "rz", params: { phi: "-1*pi/2"}, wires: [1] },
						{ name: "rx", params: { theta: "-1*pi/2"}, wires: [1] },
						{ name: "rz", params: { phi: "3*pi/4"}, wires: [1] },
				   ]
				},
				qiskit: {
					equivalent: [
						{ name: "rz", params: { phi: "3*pi/4"}, wires: [0] },
						{ name: "rx", params: { theta: "pi/2"}, wires: [0] },
						{ name: "rz", params: { phi: "-3*pi/4"}, wires: [1] },
						{ name: "rx", params: { theta: "pi/2"}, wires: [1] },
						{ name: "cz", wires: [1, 0] },
						{ name: "rz", params: { phi: "-1*pi/2"}, wires: [0] },
						{ name: "rx", params: { theta: "pi/2"}, wires: [0] },
						{ name: "rz", params: { phi: "phi/2"}, wires: [0] },
						{ name: "rx", params: { theta: "-1*pi/2"}, wires: [0] },
						{ name: "rz", params: { phi: "pi/2"}, wires: [1] },
						{ name: "rx", params: { theta: "pi/2"}, wires: [1] },
						{ name: "rz", params: { phi: "phi/2"}, wires: [1] },
						{ name: "rx", params: { theta: "-1*pi/2"}, wires: [1] },
						{ name: "cz", wires: [1, 0] },
						{ name: "rz", params: { phi: "-1*pi/2"}, wires: [0] },
						{ name: "rx", params: { theta: "pi/2"}, wires: [0] },
						{ name: "rz", params: { phi: "pi/4"}, wires: [0] },
						{ name: "rz", params: { phi: "-1*pi/2"}, wires: [1] },
						{ name: "rx", params: { theta: "-1*pi/2"}, wires: [1] },
						{ name: "rz", params: { phi: "3*pi/4"}, wires: [1] },
					]
				},
				cirq: {
					name: "xy",
					params: ["phi"],
					array: "[[1, 0, 0, 0], [0, np.cos(p_phi/2), 1j*np.sin(p_phi/2), 0], [0, 1j*np.sin(p_phi/2), np.cos(p_phi/2), 0], [0, 0, 0, 1]]",
					notTfqSupported: true
				},
				quest: {
					name: "xy",
					//@TODO add function
					func: "TODO"
				},
				braket: {
					name: "xy",
					params: ["phi"]
				},
				aqasm: {
					matrix: [[1, 0, 0, 0],[0, "cos(phi / 2)", "i * sin(phi / 2)", 0],[0, "i * sin(phi / 2)", "cos(phi / 2)", 0],[0, 0, 0, 1]],
					array: "[[1, 0, 0, 0], [0, np.cos(p_phi/2), 1j*np.sin(p_phi/2), 0], [0, 1j*np.sin(p_phi/2), np.cos(p_phi/2), 0], [0, 0, 0, 1]]",
					params: ["phi"]
				},
				cudaq: {
					equivalent: [
						{ name: "rz", params: { phi: "3*pi/4"}, wires: [0] },
						{ name: "rx", params: { theta: "pi/2"}, wires: [0] },
						{ name: "rz", params: { phi: "-3*pi/4"}, wires: [1] },
						{ name: "rx", params: { theta: "pi/2"}, wires: [1] },
						{ name: "cz", wires: [1, 0] },
						{ name: "rz", params: { phi: "-1*pi/2"}, wires: [0] },
						{ name: "rx", params: { theta: "pi/2"}, wires: [0] },
						{ name: "rz", params: { phi: "phi/2"}, wires: [0] },
						{ name: "rx", params: { theta: "-1*pi/2"}, wires: [0] },
						{ name: "rz", params: { phi: "pi/2"}, wires: [1] },
						{ name: "rx", params: { theta: "pi/2"}, wires: [1] },
						{ name: "rz", params: { phi: "phi/2"}, wires: [1] },
						{ name: "rx", params: { theta: "-1*pi/2"}, wires: [1] },
						{ name: "cz", wires: [1, 0] },
						{ name: "rz", params: { phi: "-1*pi/2"}, wires: [0] },
						{ name: "rx", params: { theta: "pi/2"}, wires: [0] },
						{ name: "rz", params: { phi: "pi/4"}, wires: [0] },
						{ name: "rz", params: { phi: "-1*pi/2"}, wires: [1] },
						{ name: "rx", params: { theta: "-1*pi/2"}, wires: [1] },
						{ name: "rz", params: { phi: "3*pi/4"}, wires: [1] },
					]
				},
				quirk: {
					controlQubits: 0,
					targetQubits: 2
				}
			}
		},

		ms: {
			description: "Mølmer-Sørensen gate",
			matrix: [
				["1/sqrt(2)", 0, 0, "(-i*exp(-i*(phi0+phi1)))/sqrt(2)"],

				[0, "1/sqrt(2)", "(-i*exp(-i*(phi0-phi1)))/sqrt(2)", 0],

				[0, "(-i*exp(i*(phi0-phi1)))/sqrt(2)", "1/sqrt(2)", 0],

				["(-i*exp(i*(phi0+phi1)))/sqrt(2)", 0, 0, "1/sqrt(2)"]
			],
			numTargetQubits: 2,
			numControlQubits: 0,
			params: ["phi0", "phi1"],
			drawingInfo: {
				connectors: ["box","box"],
				label: "MS"
			},
			exportInfo: {
				quil: {
					name: "ms",
					params: ["phi0", "phi1"],
					defgate: "DEFGATE ms(%phi0, %phi1):\n    1/SQRT(2), 0, 0, (-i*EXP(-i*(%phi0+%phi1)))/SQRT(2)\n    0, 1/SQRT(2), (-i*EXP(-i*(%phi0-%phi1)))/SQRT(2), 0\n    0, (-i*EXP(i*(%phi0-%phi1)))/SQRT(2), 1/SQRT(2), 0\n    (-i*EXP(i*(%phi0+%phi1)))/SQRT(2), 0, 0, 1/SQRT(2)"
				},
				pyquil: {
					name: "ms",
					params: ["phi0", "phi1"],
					array: "[ [ 1/quil_sqrt(2), 0, 0, (-1j*quil_exp(-1j*(p_phi0+p_phi1)))/quil_sqrt(2) ], [ 0, 1/quil_sqrt(2), (-1j*quil_exp(-1j*(p_phi0-p_phi1)))/quil_sqrt(2), 0 ], [ 0, (-1j*quil_exp(1j*(p_phi0-p_phi1)))/quil_sqrt(2), 1/quil_sqrt(2), 0 ], [ (-1j*quil_exp(1j*(p_phi0+p_phi1)))/quil_sqrt(2), 0, 0, 1/quil_sqrt(2) ] ]"
				},
				cirq: {
					name: "ms"
				},
				quest: {
					name: "ms",
					//@TODO add function
					func: "TODO"
				},
				qasm: {
					name: "ms"
				},
				qiskit: {
					name: "m