



'''simple docstring'''







import math

import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute
def 			_lowerCAmelCase(      UpperCAmelCase_      :	int = 1					, UpperCAmelCase_      :	int = 1						) ->							qiskit.result.counts.Counts:
							if isinstance(UpperCAmelCase_					, UpperCAmelCase_						) or isinstance(UpperCAmelCase_					, UpperCAmelCase_						):
														raise TypeError("""inputs must be integers."""						)
							if (bit_a < 0) or (bit_a < 0):
														raise ValueError("""inputs must be positive."""						)
							if (math.floor(UpperCAmelCase_						) != bit_a) or (math.floor(UpperCAmelCase_						) != 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(UpperCAmelCase_					, UpperCAmelCase_						)

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

							# send the information
							lowerCAmelCase__  =   str(UpperCAmelCase_						) + str(UpperCAmelCase_						)

							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(UpperCAmelCase_					, UpperCAmelCase_						)

							lowerCAmelCase__  =   Aer.get_backend("""aer_simulator"""						)
							lowerCAmelCase__  =   execute(UpperCAmelCase_					, UpperCAmelCase_					, shots=1000						)

							return job.result().get_counts(UpperCAmelCase_						)


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










'''simple docstring'''







from ..utils import DummyObject, requires_backends

class      lowerCamelCase__     (     metaclass=_A				):






	'''simple docstring'''

	A__		=	['''torch''', '''librosa''']




	def __init__(  self		:  Optional[Any]   ,		*__A		:  Tuple   ,		**__A		:  Tuple					)     ->			Union[str, Any]:




								'''simple docstring'''





								requires_backends(self   ,		["""torch""", """librosa"""]					)




	@classmethod
	def      lowercase__							(  cls		:  Dict   ,		*__A		:  List[Any]   ,		**__A		:  List[str]					)     ->			Union[str, Any]:




								'''simple docstring'''





								requires_backends(cls   ,		["""torch""", """librosa"""]					)




	@classmethod
	def      lowercase__							(  cls		:  Optional[int]   ,		*__A		:  List[str]   ,		**__A		:  Tuple					)     ->			Any:




								'''simple docstring'''





								requires_backends(cls   ,		["""torch""", """librosa"""]					)





class      lowerCamelCase__     (     metaclass=_A				):






	'''simple docstring'''

	A__		=	['''torch''', '''librosa''']




	def __init__(  self		:  int   ,		*__A		:  Dict   ,		**__A		:  List[Any]					)     ->			List[Any]:




								'''simple docstring'''





								requires_backends(self   ,		["""torch""", """librosa"""]					)




	@classmethod
	def      lowercase__							(  cls		:  Optional[int]   ,		*__A		:  Optional[int]   ,		**__A		:  List[Any]					)     ->			Union[str, Any]:




								'''simple docstring'''





								requires_backends(cls   ,		["""torch""", """librosa"""]					)




	@classmethod
	def      lowercase__							(  cls		:  List[str]   ,		*__A		:  List[str]   ,		**__A		:  int					)     ->			List[str]:




								'''simple docstring'''





								requires_backends(cls   ,		["""torch""", """librosa"""]					)





