
import math

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






def        lowerCamelCase__    (    __lowerCAmelCase  :  int = 1   ,							__lowerCAmelCase  :  int = 1    ):




			"""simple docstring"""


			if isinstance(__lowerCAmelCase   ,							__lowerCAmelCase    ) or isinstance(__lowerCAmelCase   ,							__lowerCAmelCase    ):
						raise TypeError("inputs must be integers."    )
			if (bit_a < 0) or (bit_a < 0):
						raise ValueError("inputs must be positive."    )
			if (math.floor(__lowerCAmelCase    ) != bit_a) or (math.floor(__lowerCAmelCase    ) != 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(__lowerCAmelCase   ,							__lowerCAmelCase    )

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

			# send the information
			lowerCAmelCase_      =     str(__lowerCAmelCase    ) + str(__lowerCAmelCase    )

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

			lowerCAmelCase_      =     Aer.get_backend("aer_simulator"    )
			lowerCAmelCase_      =     execute(__lowerCAmelCase   ,							__lowerCAmelCase   ,							shots=1000    )

			return job.result().get_counts(__lowerCAmelCase    )


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





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_A       =					{"configuration_nat": ["NAT_PRETRAINED_CONFIG_ARCHIVE_MAP", "NatConfig"]}


try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A       =					[
			    "NAT_PRETRAINED_MODEL_ARCHIVE_LIST",
			    "NatForImageClassification",
			    "NatModel",
			    "NatPreTrainedModel",
			    "NatBackbone",
			]

if TYPE_CHECKING:
			from .configuration_nat import NAT_PRETRAINED_CONFIG_ARCHIVE_MAP, NatConfig

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_nat import (
						    NAT_PRETRAINED_MODEL_ARCHIVE_LIST,
						    NatBackbone,
						    NatForImageClassification,
						    NatModel,
						    NatPreTrainedModel,
						)

else:
			import sys

			_A       =					_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



