Python PauliClass.eye_p方法代码示例

# 需要导入模块: import PauliClass [as 别名]
# 或者: from PauliClass import eye_p [as 别名]
 def flip_code(n_correctable, stab_kind='Z'):
     """
     Creates an instance of :class:`qecc.StabilizerCode` representing a
     code that protects against weight-``n_correctable`` flip errors of a
     single kind.
     
     This method generalizes the bit-flip and phase-flip codes, corresponding
     to ``stab_kind=qecc.Z`` and ``stab_kind=qecc.X``, respectively.
     
     :param int n_correctable: Maximum weight of the errors that can be
         corrected by this code.
     :param qecc.Pauli stab_kind: Single-qubit Pauli operator specifying
         which kind of operators to use for the new stabilizer code.
     :rtype: qecc.StabilizerCode
     """
     nq = 2 * n_correctable + 1
     stab_kind = p.ensure_pauli(stab_kind)
     if len(stab_kind) != 1:
         raise ValueError("stab_kind must be single-qubit.")
     
     return StabilizerCode(
         [p.eye_p(j) & stab_kind & stab_kind & p.eye_p(nq-j-2) for j in range(nq-1)],
         ['X'*nq], ['Z'*nq],
         label='{}-flip code (t = {})'.format(stab_kind.op, n_correctable)
     )

# 需要导入模块: import PauliClass [as 别名]
# 或者: from PauliClass import eye_p [as 别名]
 def block_logical_pauli(self, P):
     r"""
     Given a Pauli operator :math:`P` acting on :math:`k`, finds a Pauli
     operator :math:`\overline{P}` on :math:`n_k` qubits that corresponds
     to the logical operator acting across :math:`k` blocks of this code.
     
     Note that this method is only supported for single logical qubit codes.
     """
     
     if self.nq_logical > 1:
         raise NotImplementedError("Mapping of logical Pauli operators is currently only supported for single-qubit codes.")
     
     # TODO: test that phases are handled correctly.
     
     # FIXME: cache this dictionary.
     replace_dict = {
         'I': p.eye_p(self.nq),
         'X': self.logical_xs[0],
         'Y': (self.logical_xs[0] * self.logical_zs[0]).mul_phase(1),
         'Z': self.logical_zs[0]
     }
     
     # FIXME: using eye_p(0) is a hack.
     return reduce(op.and_, 
             (replace_dict[sq_op] for sq_op in P.op),
             p.eye_p(0))

# 需要导入模块: import PauliClass [as 别名]
# 或者: from PauliClass import eye_p [as 别名]
    def transcoding_cliffords(self,other):
        r"""
        Returns an iterator onto all :class:`qecc.Clifford` objects which 
        take states specified by ``self``, and
        return states specified by ``other``.

        :arg other: :class:`qecc.StabilizerCode`
        """
        #Preliminaries:

        stab_in = self.group_generators
        stab_out = other.group_generators
        xs_in = self.logical_xs
        xs_out = other.logical_xs
        zs_in = self.logical_zs
        zs_out = other.logical_zs
        
        nq_in=len(stab_in[0])
        nq_out=len(stab_out[0])
        nq_anc=abs(nq_in-nq_out)

        #Decide left side:
        if nq_in<nq_out:
            stab_left=stab_out
            xs_left=xs_out
            zs_left=zs_out
            stab_right=stab_in
            xs_right=xs_in
            zs_right=zs_in
        else:
            stab_right=stab_out
            xs_right=xs_out
            zs_right=zs_out
            stab_left=stab_in
            xs_left=xs_in
            zs_left=zs_in
            
        cliff_xouts_left=stab_left+xs_left
        cliff_zouts_left=[Unspecified]*len(stab_left)+zs_left
        
        cliff_left=next(c.Clifford(cliff_xouts_left,cliff_zouts_left).constraint_completions())
        list_left=cliff_left.xout+cliff_left.zout

        for mcset in p.mutually_commuting_sets(n_elems=len(stab_left)-len(stab_right),n_bits=nq_anc):
            temp_xouts_right = p.pad(stab_right,lower_right=mcset) + [elem & p.eye_p(nq_anc) for elem in xs_right]
            temp_zouts_right = [Unspecified]*len(stab_left) + [elem & p.eye_p(nq_anc) for elem in zs_right]
        for completion in c.Clifford(temp_xouts_right,temp_zouts_right).constraint_completions():
            if nq_in < nq_out:
                yield c.gen_cliff(completion.xout+completion.zout,list_left)
            else:
                yield c.gen_cliff(list_left,completion.xout+completion.zout)

# 需要导入模块: import PauliClass [as 别名]
# 或者: from PauliClass import eye_p [as 别名]
 def concatenate(self,other):
     r"""
     Returns the stabilizer for a concatenated code, given the 
     stabilizers for two codes. At this point, it only works for two
     :math:`k=1` codes.
     """
     
     if self.nq_logical > 1 or other.nq_logical > 1:
         raise NotImplementedError("Concatenation is currently only supported for single-qubit codes.")
     
     nq_self = self.nq
     nq_other = other.nq
     nq_new = nq_self * nq_other
     
     # To obtain the new generators, we must apply the stabilizer generators
     # to each block of the inner code (self), as well as the stabilizer
     # generators of the outer code (other), using the inner logical Paulis
     # for the outer stabilizer generators.
     
     # Making the stabilizer generators from the inner (L0) code is straight-
     # forward: we repeat the code other.nq times, once on each block of the
     # outer code. We use that PauliList supports tensor products.
     new_generators = sum(
         (
             p.eye_p(nq_self * k) & self.group_generators & p.eye_p(nq_self * (nq_other - k - 1))
             for k in range(nq_other)
         ),
         pc.PauliList())
             
     # Each of the stabilizer generators due to the outer (L1) code can be
     # found by computing the block-logical operator across multiple L0
     # blocks, as implemented by StabilizerCode.block_logical_pauli.
     new_generators += map(self.block_logical_pauli, other.group_generators)
         
     # In the same way, the logical operators are also found by mapping L1
     # operators onto L0 qubits.
     
     # This completes the definition of the concatenated code, and so we are
     # done.
     
     return StabilizerCode(new_generators,
         logical_xs=map(self.block_logical_pauli, other.logical_xs),
         logical_zs=map(self.block_logical_pauli, other.logical_zs)
     )

# 需要导入模块: import PauliClass [as 别名]
# 或者: from PauliClass import eye_p [as 别名]
    def pad(self, extra_bits=0, lower_right=None):
        r"""
        Takes a PauliList, and returns a new PauliList, 
        appending ``extra_bits`` qubits, with stabilizer operators specified by
        ``lower_right``.
        
        :arg pauli_list_in: list of Pauli operators to be padded. 
        :param int extra_bits: Number of extra bits to be appended to the system.
        :param lower_right: list of `qecc.Pauli` operators, acting on `extra_bits` qubits.
        :rtype: list of :class:`qecc.Pauli` objects.
        
        Example:
        
        >>> import qecc as q
        >>> pauli_list = q.PauliList('XXX', 'YIY', 'ZZI')
        >>> pauli_list.pad(extra_bits=2, lower_right=q.PauliList('IX','ZI'))
        PauliList(i^0 XXXII, i^0 YIYII, i^0 ZZIII, i^0 IIIIX, i^0 IIIZI)

        """
        
        len_P = len(self)
        nq_P  = len(self[0]) if len_P > 0 else 0

        if extra_bits == 0 and lower_right is None or len(lower_right) == 0:
            return PauliList(self)
        elif len(lower_right) != 0:
            extra_bits=len(lower_right[0])
                
        setout = PauliList([pc.Pauli(pauli.op + 'I'*extra_bits) for pauli in self])
            
        if lower_right is None:
            setout += [pc.eye_p(nq_P + extra_bits)] * extra_bits
        else:
            setout += [pc.eye_p(nq_P) & P for P in lower_right]
                
        return setout    

# 需要导入模块: import PauliClass [as 别名]
# 或者: from PauliClass import eye_p [as 别名]
 def __and__(self, other):
     """Returns the Kronecker product of two stabilizer codes,
     given each of the constituent codes. """
     
     if not isinstance(other, StabilizerCode):
         return NotImplemented
     
     return StabilizerCode(
         (self.group_generators & p.eye_p(other.nq)) +
         (p.eye_p(self.nq) & other.group_generators),
         
         (self.logical_xs & p.eye_p(other.nq)) +
         (p.eye_p(self.nq) & other.logical_xs),
         
         (self.logical_zs & p.eye_p(other.nq)) +
         (p.eye_p(self.nq) & other.logical_zs),
     )

# 需要导入模块: import PauliClass [as 别名]
# 或者: from PauliClass import eye_p [as 别名]
 def star_decoder(self, for_enc=None, as_dict=False):
     r"""
     Returns a tuple of a decoding Clifford and a :class:`qecc.PauliList`
     specifying the recovery operation to perform as a function of the result
     of a :math:`Z^{\otimes{n - k}}` measurement on the ancilla register.
     
     For syndromes corresponding to errors of weight greater than the distance,
     the relevant element of the recovery list will be set to
     :obj:`qecc.Unspecified`.
     
     :param for_enc: If not ``None``, specifies to use a given Clifford
         operator as the encoder, instead of the first element yielded by
         :meth:`encoding_cliffords`.
     :param bool as_dict: If ``True``, returns a dictionary from recovery
         operators to syndromes that indicate that recovery.
     """
     def error_to_pauli(error):
         if error == p.I.as_clifford():
             return "I"
         if error == p.X.as_clifford():
             return "X"
         if error == p.Y.as_clifford():
             return "Y"
         if error == p.Z.as_clifford():
             return "Z"
     
     if for_enc is None:
         encoder = self.encoding_cliffords().next()
     else:
         encoder = for_enc
     decoder = encoder.inv()
     
     errors = pc.PauliList(p.eye_p(self.nq)) + pc.PauliList(p.paulis_by_weight(self.nq, self.n_correctable))
     
     syndrome_dict = defaultdict(lambda: Unspecified)
     syndrome_meas = [p.elem_gen(self.nq, idx, 'Z') for idx in range(self.nq_logical, self.nq)]
             
     for error in errors:
         effective_gate = decoder * error.as_clifford() * encoder
         # FIXME: the following line emulates measurement until we have a real
         #        measurement simulation method.
         syndrome = tuple([effective_gate(meas).ph / 2 for meas in syndrome_meas])
         
         recovery = "".join([
             # FIXME: the following is a broken hack to get the phases on the logical qubit register.
             error_to_pauli(c.Clifford([effective_gate.xout[idx][idx]], [effective_gate.zout[idx][idx]]))
             for idx in range(self.nq_logical)
         ])
         
         # For degenerate codes, the syndromes can collide, so long as we
         # correct the same way for each.
         if syndrome in syndrome_dict and syndrome_dict[syndrome] != recovery:
             raise RuntimeError('Syndrome {} has collided.'.format(syndrome))
             
         syndrome_dict[syndrome] = recovery
     
     if as_dict:
         outdict = dict()
         keyfn = lambda (syndrome, recovery): recovery
         data = sorted(syndrome_dict.items(), key=keyfn)
         for recovery, syndrome_group in it.groupby(data, keyfn):
             outdict[recovery] = [syn[0] for syn in syndrome_group]
         
         return decoder, outdict
         
     else:
         recovery_list = pc.PauliList(syndrome_dict[syndrome] for syndrome in it.product(range(2), repeat=self.n_constraints))
         
         return decoder, recovery_list

# 需要导入模块: import PauliClass [as 别名]
# 或者: from PauliClass import eye_p [as 别名]
def clifford_as_unitary(C):
    nq = len(C)
    dim = 2**nq
    U = np.zeros((dim,dim), dtype='complex')
    psi_0 = mutual_eigenspace(map(pauli_as_unitary, C.zout)).T
    for b in xrange(dim):
        bits = '{{0:0>{nq}b}}'.format(nq=nq).format(b)
        Xb   = reduce(op.mul, (C.xout[idx] for idx in xrange(nq) if bits[idx] == '1'), pc.eye_p(nq)).as_unitary()
        for a in xrange(dim):
            bra_a = np.zeros((1, dim))
            bra_a[0, a] = 1
            U[a, b] = reduce(np.dot, [bra_a, Xb, psi_0])[0,0]
            
    return U