def testFeedback(self): A, B, C, D, A1, A2 = get_symbols(3, 2, 1, 1, 1, 1) circuit_identity(1) # self.assertRaises(Exception, Feedback, ()) # self.assertRaises(Exception, Feedback, (C,)) # self.assertRaises(Exception, Feedback, (C + D,)) # self.assertRaises(Exception, Feedback, (C << D,)) # self.assertRaises(Exception, Feedback, (circuit_identity(n),)) # self.assertRaises(Exception, Feedback.create, (circuit_identity(0))) # self.assertEquals(Feedback.create(circuit_identity(n)), circuit_identity(n-1)) self.assertEquals(FB(A+B), A + FB(B)) smq = map_signals_circuit({2:1}, 3) # == 'cid(1) + X' self.assertEquals(smq, smq.series_inverse()) # import metapost as mp # mp.display_circuit(Feedback.apply_with_rules(smq.series_inverse() << (B + C) << smq)) # mp.display_circuit(B.feedback() + C) self.assertEquals(( smq << (B + C)).feedback(out_index = 2, in_index = 1), B.feedback() + C) print((smq << (B + C) << smq).feedback()) self.assertEquals(( smq << (B + C) << smq).feedback(), B.feedback() + C) self.assertEquals((B + C).feedback(1,1), B.feedback() + C) #check that feedback is resolved into series when possible self.assertEquals(B.feedback(1,0).substitute({B:(C+D)}), C << D) self.assertEquals((A << (B + cid(1))).feedback(), A.feedback() << B) self.assertEquals((A << (B + cid(1)) << (cid(1) + P_sigma(1,0))).feedback(2,1), A.feedback() << B) self.assertEquals((A << (cid(1) + P_sigma(1,0)) << (B + cid(1)) << (cid(1) + P_sigma(1,0))).feedback(1,1), A.feedback(1,1) << B) self.assertEquals((B << (cid(1) + C)).feedback(0,1).substitute({B: (A1 + A2)}), A2 << C << A1) self.assertEquals(((cid(1) + C)<< P_sigma(1,0) << B).feedback(1,1).substitute({B: (A1 + A2)}), A2 << C << A1) self.assertEquals(((cid(1) + C)<< P_sigma(1,0) << B << (cid(1) + D)).feedback(1,1).substitute({B: (A1 + A2)}), A2 << D<< C << A1)
def _creduce(self): B1, B2, C, Phase1, Phase2 = self.B1, self.B2, self.C, self.Phase1, self.Phase2 return P_sigma(0, 1, 3, 2) << ((( ((Phase2 + cid(1)) << P_sigma(1, 0) << B2 << (Phase1 + cid(1))) + cid(1)) << C) + cid(1)) << P_sigma( 0, 3, 1, 2) << ((P_sigma(1, 0) << B1) + cid(2))
def _creduce(self): NAND1, NAND2 = self.NAND1, self.NAND2 return P_sigma(3, 4, 2, 0, 1, 5) << FB( ((P_sigma(0, 1, 3, 2) << NAND2) + cid(3)) << (cid(1) + (P_sigma(0, 3, 4, 5, 1, 2) << ((P_sigma(1, 2, 0, 3) << NAND1) + cid(2)))), 3, 2) << P_sigma(1, 2, 5, 0, 4, 3)
def _creduce(self): B1, B2, B3, C, Phase1, Phase2, W = self.B1, self.B2, self.B3, self.C, self.Phase1, self.Phase2, self.W return P_sigma(0, 1, 2, 4, 3) << ( ((((B3 + cid(1)) << P_sigma(0, 2, 1) << (((Phase2 + cid(1)) << P_sigma(1, 0) << B2) + cid(1))) + cid(1)) << P_sigma(0, 1, 3, 2) << (((Phase1 + cid(2)) << C) + cid(1))) + cid(1)) << P_sigma( 0, 4, 1, 2, 3) << ( (P_sigma(1, 0) << B1 << (W + cid(1))) + cid(3)) << P_sigma(1, 0, 4, 2, 3)
def testFeedback(self): A, B, C, D, A1, A2 = get_symbols(3, 2, 1, 1, 1, 1) circuit_identity(1) # self.assertRaises(Exception, Feedback, ()) # self.assertRaises(Exception, Feedback, (C,)) # self.assertRaises(Exception, Feedback, (C + D,)) # self.assertRaises(Exception, Feedback, (C << D,)) # self.assertRaises(Exception, Feedback, (circuit_identity(n),)) # self.assertRaises(Exception, Feedback.create, (circuit_identity(0))) # self.assertEquals(Feedback.create(circuit_identity(n)), circuit_identity(n-1)) self.assertEquals(FB(A + B), A + FB(B)) smq = map_signals_circuit({2: 1}, 3) # == 'cid(1) + X' self.assertEquals(smq, smq.series_inverse()) # import metapost as mp # mp.display_circuit(Feedback.apply_with_rules(smq.series_inverse() << (B + C) << smq)) # mp.display_circuit(B.feedback() + C) self.assertEquals((smq << (B + C)).feedback(out_index=2, in_index=1), B.feedback() + C) print((smq << (B + C) << smq).feedback()) self.assertEquals((smq << (B + C) << smq).feedback(), B.feedback() + C) self.assertEquals((B + C).feedback(1, 1), B.feedback() + C) #check that feedback is resolved into series when possible self.assertEquals(B.feedback(1, 0).substitute({B: (C + D)}), C << D) self.assertEquals((A << (B + cid(1))).feedback(), A.feedback() << B) self.assertEquals((A << (B + cid(1)) << (cid(1) + P_sigma(1, 0))).feedback(2, 1), A.feedback() << B) self.assertEquals((A << (cid(1) + P_sigma(1, 0)) << (B + cid(1)) << (cid(1) + P_sigma(1, 0))).feedback(1, 1), A.feedback(1, 1) << B) self.assertEquals( (B << (cid(1) + C)).feedback(0, 1).substitute({B: (A1 + A2)}), A2 << C << A1) self.assertEquals(((cid(1) + C) << P_sigma(1, 0) << B).feedback( 1, 1).substitute({B: (A1 + A2)}), A2 << C << A1) self.assertEquals( ((cid(1) + C) << P_sigma(1, 0) << B << (cid(1) + D)).feedback(1, 1).substitute({B: (A1 + A2)}), A2 << D << C << A1)
def testConnect(self): A, B, C = get_symbols(1, 1, 2) connections = [((0, 0), (1, 0))] self.assertEqual(connect([A, B], connections, force_SLH=False), B << A) connections = [ ((0, 0), (2, 0)), ((1, 0), (2, 1)), ] self.assertEqual(connect([A, B, C], connections, force_SLH=False), C << (A + B)) connections = [((0, 0), (1, 0))] self.assertEqual(connect([A, C], connections, force_SLH=False), C << (A + cid(1)))
def testConnect(self): A, B, C = get_symbols(1, 1, 2) connections = [ ((0, 0), (1, 0)) ] self.assertEqual(connect([A, B], connections, force_SLH=False), B << A) connections = [ ((0, 0), (2, 0)), ((1, 0), (2, 1)), ] self.assertEqual(connect([A, B, C], connections, force_SLH=False), C << (A + B)) connections = [ ((0, 0), (1, 0)) ] self.assertEqual(connect([A, C], connections, force_SLH=False), C << (A + cid(1)))
def p_circuit_identity(self, p): """ circuit_identity : CID LPAREN ICONST RPAREN """ p[0] = ca.cid(int(p[3]))
def to_circuit(self, identifier_postfix = ''): """ Compute a circuit algebra expression from the QHDL code and return the circuit expression, the all_symbols appearing in it and the component instance assignments """ if self._circuit_data: return self._circuit_data from qnet.algebra import circuit_algebra as ca # initialize trivial circuit circuit = ca.cid(0) II = [] OO = [] if len(self.lossy_signals): if not self.components.get('Beamsplitter', False): self.components['Beamsplitter'] = Component('Beamsplitter', [('theta','real')],[(['In1','In2'],'in','fieldmode'),(['Out1','Out2'],'out','fieldmode')]) self.components['Beamsplitter'].cdim = 2 OPEN = object() #create all_symbols for all instances circuit_symbols = {} for (instance_name, (component, _, _)) in self.instance_assignments.items(): QQ = ca.CircuitSymbol(instance_name + identifier_postfix, component.cdim) circuit_symbols[instance_name] = QQ assert component.inout_port_identifiers == [] circuit = circuit + QQ # II = II + [(instance_name, port_name + "_i" ) for port_name in component.inout_port_identifiers] II = II + [(instance_name, port_name) for port_name in component.in_port_identifiers] # OO = OO + [(instance_name, port_name + "_o") for port_name in component.inout_port_identifiers] OO = OO + [(instance_name, port_name) for port_name in component.out_port_identifiers] if len(component.in_port_identifiers) + len(component.inout_port_identifiers) < component.cdim: II = II + [(OPEN,OPEN)] * ( component.cdim - len(component.in_port_identifiers) - len(component.inout_port_identifiers)) if len(component.out_port_identifiers) < component.cdim: OO = OO + [(OPEN,OPEN)] * ( component.cdim - len(component.out_port_identifiers) - len(component.inout_port_identifiers)) # Add loss-beamsplitters for k, s in enumerate(self.lossy_signals): # while "LSS%s_%d%s" % (s, j, identifier_postfix) in circuit_symbols: # j += 1 LBS = ca.CircuitSymbol("LSS_%s%s" % (s,identifier_postfix), 2) circuit = circuit + LBS II = II + [('LSS_%s' % s, 'In1'),(OPEN, OPEN)] OO = OO + [('LSS_%s' % s, 'Out1'),(OPEN, OPEN)] self.signals.append(s+"__from_loss") self.signals.append(s) # modify assignment of original component that leads into signal try: # exploit enforced order of dictionaries jj = list(self.in_to_signal.values()).index(s) ipnames = list(self.in_to_signal.keys())[jj] assert self.in_to_signal[ipnames] == s self.in_to_signal[ipnames] = s + "__from_loss" except ValueError: jj = list(self.global_out.values()).index(s) ipnames = list(self.global_out.keys())[jj] assert self.global_out[ipnames] == s self.global_out[ipnames] = s + "__from_loss" # Update lookup tables self.in_to_signal[('LSS_%s' % s, 'In1')] = s self.out_to_signal[('LSS_%s' % s, 'Out1')] = s + "__from_loss" # Create artificial instance assignment self.instance_assignments['LSS_%s' % s] = self.components['Beamsplitter'], {'theta': 'theta_LS%d' % k},{"In1": s, "Out1": s + "__from_loss"} circuit_symbols['LSS_%s' % s] = LBS self.entity.generics['theta_LS%d' % k] = "real", None assert circuit.cdim == len(OO) == len(II) SS = list(self.signals) # Add signals as passthru lines below rest circuit = circuit + ca.cid(len(SS)) # print(circuit) # Do feedback from instance output to signals SSp = list(SS) OOp = list(OO) M = len(OO) for iname, pname in OO: if iname is OPEN: continue sname = self.out_to_signal.get((iname, pname), False) if sname: k = OOp.index((iname, pname)) l = SSp.index(sname) + M circuit = circuit.feedback(k,l) SSp.remove(sname) OOp.remove((iname, pname)) # print(circuit) # Do feedback from signal output to instance inputs IIp = list(II) SSpp = list(SS) Mf = len(OOp) for iname, pname in II: if iname is OPEN: continue sname = self.in_to_signal.get((iname, pname), False) if sname: k = SSpp.index(sname) + Mf l = IIp.index((iname, pname)) circuit = circuit.feedback(k,l) SSpp.remove(sname) IIp.remove((iname, pname)) SIGNAL = object() OO_effective = OOp + [(SIGNAL, s) for s in SSpp] II_effective = IIp + [(SIGNAL, s) for s in SSp] omapping = {} # construct output permutation for i, (iname, pname) in enumerate(OO_effective): if iname is not SIGNAL: eport = self.global_out.get((iname, pname), False) else: eport = self.signal_to_global_out.get(pname, False) if eport: omapping[i] = list(self.entity.out_port_identifiers).index(eport) imapping = {} # construct output permutation for i, (iname, pname) in enumerate(II_effective): if not (iname is SIGNAL): eport = self.global_in.get((iname, pname), False) else: eport = self.signal_to_global_in.get(pname, False) if eport: k = list(self.entity.in_port_identifiers).index(eport) imapping[k] = i # print(imapping, II_effective,self.signal_to_global_in) circuit = ca.map_signals_circuit(omapping, circuit.cdim) << circuit << ca.map_signals_circuit(imapping, circuit.cdim) self._circuit_data = circuit, circuit_symbols, self.instance_assignments self.entity.cdim = circuit.cdim return self._circuit_data
def _creduce(self): B11, B12, B21, B22, B3, C1, C2, Phase1, Phase2, Phase3, W1, W2 = self.B11, self.B12, self.B21, self.B22, self.B3, self.C1, self.C2, self.Phase1, self.Phase2, self.Phase3, self.W1, self.W2 return P_sigma(1, 2, 3, 4, 5, 6, 7, 0) << FB( (cid(4) + (P_sigma(0, 4, 1, 2, 3) << (B11 + cid(3)))) << P_sigma(0, 1, 2, 3, 4, 6, 7, 8, 5) << ((P_sigma(0, 1, 2, 3, 4, 7, 5, 6) << ((P_sigma(0, 1, 5, 3, 4, 2) << FB( (cid(2) + ((B3 + cid(1)) << P_sigma(0, 2, 1) << (B12 + cid(1))) + cid(2)) << P_sigma(0, 1, 4, 5, 6, 2, 3) << (((cid(1) + ((cid(1) + ((Phase3 + Phase2) << B22) + cid(1)) << P_sigma(0, 1, 3, 2) << (C2 + W2))) << ((B21 << (Phase1 + cid(1))) + cid(3))) + cid(2)), 4, 0)) + cid(2)) << (cid(4) + (P_sigma(0, 2, 3, 1) << ((P_sigma(1, 0, 2) << C1) + W1)))) + cid(1)), 8, 4) << P_sigma(7, 0, 6, 3, 1, 2, 4, 5)
def _creduce(self): B1, B2, P, W = self.B1, self.B2, self.P, self.W return P_sigma(1, 0) << B2 << (P + cid(1)) << P_sigma(1, 0) << B1 << (W + cid(1))
def testFactorizePermutation(self): self.assertEqual(full_block_perm((0,1,2), (1,1,1)), (0,1,2)) self.assertEqual(full_block_perm((0,2,1), (1,1,1)), (0,2,1)) self.assertEqual(full_block_perm((0,2,1), (1,1,2)), (0,3,1,2)) self.assertEqual(full_block_perm((0,2,1), (1,2,3)), (0,4,5,1,2,3)) self.assertEqual(full_block_perm((1,2,0), (1,2,3)), (3,4,5,0,1,2)) self.assertEqual(full_block_perm((3,1,2,0), (1,2,3,4)), (9, 4, 5, 6, 7, 8, 0, 1, 2, 3 )) self.assertEqual(block_perm_and_perms_within_blocks((9, 4, 5, 6, 7, 8, 0, 1, 2, 3 ), (1,2,3,4)), \ ((3,1,2,0), [(0,),(0,1),(0,1,2),(0,1,2,3)])) A1,A2,A3,A4 = get_symbols(1,2,3,4) new_lhs, permuted_rhs, new_rhs = P_sigma(9, 4, 5, 6, 7, 8, 0, 1, 2, 3 )._factorize_for_rhs(A1+A2+A3+A4) self.assertEqual(new_lhs, cid(10)) self.assertEqual(permuted_rhs, (A4+A2+A3+A1)) self.assertEqual(new_rhs, P_sigma(9, 4, 5, 6, 7, 8, 0, 1, 2, 3 )) p = P_sigma(0,1,4,2,3,5) expr = A2 + A3 + A1 new_lhs, permuted_rhs, new_rhs = p._factorize_for_rhs(expr) self.assertEqual(new_lhs, cid(6)) self.assertEqual(permuted_rhs, A2 + (P_sigma(2,0,1) << A3) + A1) self.assertEqual(new_rhs, cid(6)) p = P_sigma(0, 3, 1, 2) p_r = P_sigma(2, 0, 1) assert p == cid(1) + p_r A = get_symbol(2) new_lhs, permuted_rhs, new_rhs = p._factorize_for_rhs(cid(1) + A+ cid(1)) self.assertEqual(new_lhs, P_sigma(0,1,3,2)) self.assertEqual(permuted_rhs, (cid(1) + (P_sigma(1,0) << A) + cid(1))) self.assertEqual(new_rhs, cid(4)) new_lhs, permuted_rhs, new_rhs = p._factorize_for_rhs(cid(2) + A) self.assertEqual(new_lhs, cid(4)) self.assertEqual(permuted_rhs, (cid(1) + A + cid(1))) self.assertEqual(new_rhs, p) self.assertEqual(p.series_inverse() << (cid(2) + A), cid(1) + SeriesProduct(P_sigma(0,2,1), Concatenation(SeriesProduct(P_sigma(1,0), A), cid(1)),P_sigma(2,0,1))) self.assertEqual(p.series_inverse() << (cid(2) + A) << p, cid(1) + (p_r.series_inverse() << (cid(1) + A) << p_r)) new_lhs, permuted_rhs, new_rhs = P_sigma(4,2,1,3,0)._factorize_for_rhs((A4 + cid(1))) self.assertEqual(new_lhs, cid(5)) self.assertEqual(permuted_rhs, (cid(1) + (P_sigma(3,1,0,2) << A4))) self.assertEqual(new_rhs, map_signals_circuit({4:0}, 5)) ## special test case that helped find the major permutation block structure factorization bug p = P_sigma(3, 4, 5, 0, 1, 6, 2) q = cid(3) + CircuitSymbol('NAND1', 4) new_lhs, permuted_rhs, new_rhs = p._factorize_for_rhs(q) self.assertEqual(new_lhs, P_sigma(0,1,2,6,3,4,5)) self.assertEqual(permuted_rhs, (P_sigma(0,1,3,2) << CircuitSymbol('NAND1', 4)) + cid(3)) self.assertEqual(new_rhs, P_sigma(4,5,6, 0,1,2,3))
def _creduce(self): BS, KC, LSS_ci_ls = self.BS, self.KC, self.LSS_ci_ls return (KC + cid(1)) << P_sigma(0, 2, 1) << (LSS_ci_ls + cid(1)) << P_sigma(0, 2, 1) << (BS + cid(1))
def _creduce(self): BS1, BS2, K, P, W_beta = self.BS1, self.BS2, self.K, self.P, self.W_beta return (cid(1) + ((cid(1) + ((P + cid(1)) << BS2 << (W_beta + cid(1)))) << P_sigma(0, 2, 1) << (K + cid(1)))) << (BS1 + cid(2)) << P_sigma(0, 1, 3, 2)
def _creduce(self): NAND1, NAND2 = self.NAND1, self.NAND2 return P_sigma(3, 4, 2, 0, 1, 5) << FB(((P_sigma(0, 1, 3, 2) << NAND2) + cid(3)) << (cid(1) + (P_sigma(0, 3, 4, 5, 1, 2) << ((P_sigma(1, 2, 0, 3) << NAND1) + cid(2)))), 3, 2) << P_sigma(1, 2, 5, 0, 4, 3)
def _creduce(self): B1, B2, C, Phase1, Phase2 = self.B1, self.B2, self.C, self.Phase1, self.Phase2 return P_sigma(0, 1, 3, 2) << (((((Phase2 + cid(1)) << P_sigma(1, 0) << B2 << (Phase1 + cid(1))) + cid(1)) << C) + cid(1)) << P_sigma(0, 3, 1, 2) << ((P_sigma(1, 0) << B1) + cid(2))
def testFactorizePermutation(self): self.assertEqual(full_block_perm((0, 1, 2), (1, 1, 1)), (0, 1, 2)) self.assertEqual(full_block_perm((0, 2, 1), (1, 1, 1)), (0, 2, 1)) self.assertEqual(full_block_perm((0, 2, 1), (1, 1, 2)), (0, 3, 1, 2)) self.assertEqual(full_block_perm((0, 2, 1), (1, 2, 3)), (0, 4, 5, 1, 2, 3)) self.assertEqual(full_block_perm((1, 2, 0), (1, 2, 3)), (3, 4, 5, 0, 1, 2)) self.assertEqual(full_block_perm((3, 1, 2, 0), (1, 2, 3, 4)), (9, 4, 5, 6, 7, 8, 0, 1, 2, 3)) self.assertEqual(block_perm_and_perms_within_blocks((9, 4, 5, 6, 7, 8, 0, 1, 2, 3 ), (1,2,3,4)), \ ((3,1,2,0), [(0,),(0,1),(0,1,2),(0,1,2,3)])) A1, A2, A3, A4 = get_symbols(1, 2, 3, 4) new_lhs, permuted_rhs, new_rhs = P_sigma( 9, 4, 5, 6, 7, 8, 0, 1, 2, 3)._factorize_for_rhs(A1 + A2 + A3 + A4) self.assertEqual(new_lhs, cid(10)) self.assertEqual(permuted_rhs, (A4 + A2 + A3 + A1)) self.assertEqual(new_rhs, P_sigma(9, 4, 5, 6, 7, 8, 0, 1, 2, 3)) p = P_sigma(0, 1, 4, 2, 3, 5) expr = A2 + A3 + A1 new_lhs, permuted_rhs, new_rhs = p._factorize_for_rhs(expr) self.assertEqual(new_lhs, cid(6)) self.assertEqual(permuted_rhs, A2 + (P_sigma(2, 0, 1) << A3) + A1) self.assertEqual(new_rhs, cid(6)) p = P_sigma(0, 3, 1, 2) p_r = P_sigma(2, 0, 1) assert p == cid(1) + p_r A = get_symbol(2) new_lhs, permuted_rhs, new_rhs = p._factorize_for_rhs( cid(1) + A + cid(1)) self.assertEqual(new_lhs, P_sigma(0, 1, 3, 2)) self.assertEqual(permuted_rhs, (cid(1) + (P_sigma(1, 0) << A) + cid(1))) self.assertEqual(new_rhs, cid(4)) new_lhs, permuted_rhs, new_rhs = p._factorize_for_rhs(cid(2) + A) self.assertEqual(new_lhs, cid(4)) self.assertEqual(permuted_rhs, (cid(1) + A + cid(1))) self.assertEqual(new_rhs, p) self.assertEqual( p.series_inverse() << (cid(2) + A), cid(1) + SeriesProduct( P_sigma(0, 2, 1), Concatenation(SeriesProduct(P_sigma(1, 0), A), cid(1)), P_sigma(2, 0, 1))) self.assertEqual( p.series_inverse() << (cid(2) + A) << p, cid(1) + (p_r.series_inverse() << (cid(1) + A) << p_r)) new_lhs, permuted_rhs, new_rhs = P_sigma(4, 2, 1, 3, 0)._factorize_for_rhs( (A4 + cid(1))) self.assertEqual(new_lhs, cid(5)) self.assertEqual(permuted_rhs, (cid(1) + (P_sigma(3, 1, 0, 2) << A4))) self.assertEqual(new_rhs, map_signals_circuit({4: 0}, 5)) ## special test case that helped find the major permutation block structure factorization bug p = P_sigma(3, 4, 5, 0, 1, 6, 2) q = cid(3) + CircuitSymbol('NAND1', 4) new_lhs, permuted_rhs, new_rhs = p._factorize_for_rhs(q) self.assertEqual(new_lhs, P_sigma(0, 1, 2, 6, 3, 4, 5)) self.assertEqual(permuted_rhs, (P_sigma(0, 1, 3, 2) << CircuitSymbol('NAND1', 4)) + cid(3)) self.assertEqual(new_rhs, P_sigma(4, 5, 6, 0, 1, 2, 3))
def _creduce(self): B11, B12, B21, B22, B3, C1, C2, Phase1, Phase2, Phase3, W1, W2 = self.B11, self.B12, self.B21, self.B22, self.B3, self.C1, self.C2, self.Phase1, self.Phase2, self.Phase3, self.W1, self.W2 return P_sigma(1, 2, 3, 4, 5, 6, 7, 0) << FB((cid(4) + (P_sigma(0, 4, 1, 2, 3) << (B11 + cid(3)))) << P_sigma(0, 1, 2, 3, 4, 6, 7, 8, 5) << ((P_sigma(0, 1, 2, 3, 4, 7, 5, 6) << ((P_sigma(0, 1, 5, 3, 4, 2) << FB((cid(2) + ((B3 + cid(1)) << P_sigma(0, 2, 1) << (B12 + cid(1))) + cid(2)) << P_sigma(0, 1, 4, 5, 6, 2, 3) << (((cid(1) + ((cid(1) + ((Phase3 + Phase2) << B22) + cid(1)) << P_sigma(0, 1, 3, 2) << (C2 + W2))) << ((B21 << (Phase1 + cid(1))) + cid(3))) + cid(2)), 4, 0)) + cid(2)) << (cid(4) + (P_sigma(0, 2, 3, 1) << ((P_sigma(1, 0, 2) << C1) + W1)))) + cid(1)), 8, 4) << P_sigma(7, 0, 6, 3, 1, 2, 4, 5)
def testCIdentity(self): self.assertEqual(parse_circuit_strings('cid(1)'), CIdentity) self.assertEqual(parse_circuit_strings('cid(5)'), cid(5))
def testDrawIdentity(self): self.assertCanBeDrawn(cid(5))
def _creduce(self): BS, KC, LSS_ci_ls = self.BS, self.KC, self.LSS_ci_ls return (KC + cid(1)) << P_sigma(0, 2, 1) << ( LSS_ci_ls + cid(1)) << P_sigma(0, 2, 1) << (BS + cid(1))
def _creduce(self): B1, B2, B3, C, Phase1, Phase2, W = self.B1, self.B2, self.B3, self.C, self.Phase1, self.Phase2, self.W return P_sigma(0, 1, 2, 4, 3) << (((((B3 + cid(1)) << P_sigma(0, 2, 1) << (((Phase2 + cid(1)) << P_sigma(1, 0) << B2) + cid(1))) + cid(1)) << P_sigma(0, 1, 3, 2) << (((Phase1 + cid(2)) << C) + cid(1))) + cid(1)) << P_sigma(0, 4, 1, 2, 3) << ((P_sigma(1, 0) << B1 << (W + cid(1))) + cid(3)) << P_sigma(1, 0, 4, 2, 3)