






import math

import qiskit





def 				snake_case  (     lowerCamelCase = 1				,  lowerCamelCase = 1				,  lowerCamelCase = 1					):




	'''simple docstring'''







	if (
	    isinstance(lowerCamelCase				,  lowerCamelCase					)
	    or isinstance(lowerCamelCase				,  lowerCamelCase					)
	    or isinstance(lowerCamelCase				,  lowerCamelCase					)
	):
		raise TypeError("""inputs must be integers."""					)

	if (input_a < 0) or (input_a < 0) or (carry_in < 0):
		raise ValueError("""inputs must be positive."""					)

	if (
	    (math.floor(lowerCamelCase					) != input_a)
	    or (math.floor(lowerCamelCase					) != input_a)
	    or (math.floor(lowerCamelCase					) != carry_in)
	):
		raise ValueError("""inputs must be exact integers."""					)

	if (input_a > 2) or (input_a > 2) or (carry_in > 2):
		raise ValueError("""inputs must be less or equal to 2."""					)

	# build registers
	__lowercase             =  qiskit.QuantumRegister(4				,  """qr"""					)
	__lowercase             =  qiskit.ClassicalRegister(2				,  """cr"""					)
	# list the entries
	__lowercase             =  [input_a, input_a, carry_in]

	__lowercase             =  qiskit.QuantumCircuit(lowerCamelCase				,  lowerCamelCase					)

	for i in range(0				,  3					):
		if entry[i] == 2:
			quantum_circuit.h(lowerCamelCase					)  # for hadamard entries
		elif entry[i] == 1:
			quantum_circuit.x(lowerCamelCase					)  # for 1 entries
		elif entry[i] == 0:
			quantum_circuit.i(lowerCamelCase					)  # for 0 entries

    # build the circuit
	quantum_circuit.ccx(0				,  1				,  3					)  # ccx = toffoli gate
	quantum_circuit.cx(0				,  1					)
	quantum_circuit.ccx(1				,  2				,  3					)
	quantum_circuit.cx(1				,  2					)
	quantum_circuit.cx(0				,  1					)

	quantum_circuit.measure([2, 3]				,  lowerCamelCase					)  # measure the last two qbits

	__lowercase             =  qiskit.Aer.get_backend("""aer_simulator"""					)
	__lowercase             =  qiskit.execute(lowerCamelCase				,  lowerCamelCase				,  shots=1_000					)

	return job.result().get_counts(lowerCamelCase					)


if __name__ == "__main__":
					print(F'''Total sum count for state is: {quantum_full_adder(1, 1, 1)}''')









from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


__UpperCamelCase      :      Tuple     						=						{
    """configuration_swiftformer""": [
        """SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """SwiftFormerConfig""",
        """SwiftFormerOnnxConfig""",
    ]
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__UpperCamelCase      :      Optional[Any]     						=						[
						    """SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
						    """SwiftFormerForImageClassification""",
						    """SwiftFormerModel""",
						    """SwiftFormerPreTrainedModel""",
						]

if TYPE_CHECKING:
						from .configuration_swiftformer import (
						    SWIFTFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    SwiftFormerConfig,
						    SwiftFormerOnnxConfig,
						)

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_swiftformer import (
												    SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
												    SwiftFormerForImageClassification,
												    SwiftFormerModel,
												    SwiftFormerPreTrainedModel,
												)

else:
						import sys

						__UpperCamelCase      :      List[Any]     						=						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

