

"""simple docstring"""




from typing import List

from tokenizers import NormalizedString, PreTokenizedString, normalizers


class 		_A							:





      def __init__(	self     ,    SCREAMING_SNAKE_CASE__		) ->       None:
         lowerCamelCase__						       =      vocab
         lowerCamelCase__						       =      normalizers.BertNormalizer(
             clean_text=SCREAMING_SNAKE_CASE__     ,    handle_chinese_chars=SCREAMING_SNAKE_CASE__     ,    strip_accents=SCREAMING_SNAKE_CASE__     ,    lowercase=SCREAMING_SNAKE_CASE__     ,    )
         try:
            import rjieba
         except ImportError:
            raise ImportError(
                "You need to install rjieba to use RoFormerTokenizer. "
                "See https://pypi.org/project/rjieba/ for installation."		)
         lowerCamelCase__						       =      rjieba





      def        _lowerCamelCase	(	self     ,    SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__		) ->       List[NormalizedString]:
         lowerCamelCase__						       =      []

         # this code slice normalized_string is too slow (6s) but test_alignement_methods can pass
         for token, start, end in self.jieba.tokenize(str(SCREAMING_SNAKE_CASE__		)     ,    hmm=SCREAMING_SNAKE_CASE__		):
            if token in self.vocab:
               splits.append(normalized_string[start:end]		)
            else:
               lowerCamelCase__						       =      self.normalizers.normalize_str(SCREAMING_SNAKE_CASE__		).split()
               for token in token_list:
                  if token:
                     lowerCamelCase__						       =      start + len(SCREAMING_SNAKE_CASE__		)
                     splits.append(normalized_string[start:end]		)
                     lowerCamelCase__						       =      end

        # this code test_alignement_methods can't pass but fast (300ms)
        # for token in self.jieba.cut(str(normalized_string), False):
        #     if token in self.vocab:
        #         splits.append(NormalizedString(token))
        #     else:
        #         token_list = self.normalizers.normalize_str(token).split()
        #         for token in token_list:
        #             if token:
        #                 splits.append(NormalizedString(token))

         return splits





      def        _lowerCamelCase	(	self     ,    SCREAMING_SNAKE_CASE__		) ->       List[str]:
         pretok.split(self.jieba_split		)







"""simple docstring"""




import math

import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute



def 						UpperCAmelCase__ (					A__ = 1						,     A__ = 1 )   ->   qiskit.result.counts.Counts:




   """simple docstring"""
   if isinstance(A__						,     A__ ) or isinstance(A__						,     A__ ):
      raise TypeError("inputs must be integers." )
   if (bit_a < 0) or (bit_a < 0):
      raise ValueError("inputs must be positive." )
   if (math.floor(A__ ) != bit_a) or (math.floor(A__ ) != bit_a):
      raise ValueError("inputs must be exact integers." )
   if (bit_a > 1) or (bit_a > 1):
      raise ValueError("inputs must be less or equal to 1." )

   # build registers
   lowerCamelCase__						       =      QuantumRegister(2						,     "qr" )
   lowerCamelCase__						       =      ClassicalRegister(2						,     "cr" )

   lowerCamelCase__						       =      QuantumCircuit(A__						,     A__ )

   # entanglement the qubits
   quantum_circuit.h(1 )
   quantum_circuit.cx(1						,     0 )

   # send the information
   lowerCamelCase__						       =      str(A__ ) + str(A__ )

   if c_information == "11":
      quantum_circuit.x(1 )
      quantum_circuit.z(1 )
   elif c_information == "10":
      quantum_circuit.z(1 )
   elif c_information == "01":
      quantum_circuit.x(1 )
   else:
      quantum_circuit.i(1 )

   # unentangled the circuit
   quantum_circuit.cx(1						,     0 )
   quantum_circuit.h(1 )

   # measure the circuit
   quantum_circuit.measure(A__						,     A__ )

   lowerCamelCase__						       =      Aer.get_backend("aer_simulator" )
   lowerCamelCase__						       =      execute(A__						,     A__						,     shots=1000 )

   return job.result().get_counts(A__ )


if __name__ == "__main__":
     print(F'''Counts for classical state send: {superdense_coding(1,1)}''')




