





import math

import qiskit




def    __UpperCAmelCase(      lowercase_ = 1 ,    lowercase_ = 1 ,    lowercase_ = 1      ):
       if (
           isinstance(lowercase_ ,    lowercase_      )
           or isinstance(lowercase_ ,    lowercase_      )
           or isinstance(lowercase_ ,    lowercase_      )
       ):
              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(lowercase_      ) != input_a)
           or (math.floor(lowercase_      ) != input_a)
           or (math.floor(lowercase_      ) != 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
       _lowerCamelCase							:     Union[str, Any]	=		qiskit.QuantumRegister(4 ,    '''qr'''      )
       _lowerCamelCase							:     List[str]	=		qiskit.ClassicalRegister(2 ,    '''cr'''      )
       # list the entries
       _lowerCamelCase							:     int	=		[input_a, input_a, carry_in]

       _lowerCamelCase							:     Union[str, Any]	=		qiskit.QuantumCircuit(lowercase_ ,    lowercase_      )

       for i in range(0 ,    3      ):
              if entry[i] == 2:
                     quantum_circuit.h(lowercase_      )  # for hadamard entries
              elif entry[i] == 1:
                     quantum_circuit.x(lowercase_      )  # for 1 entries
              elif entry[i] == 0:
                     quantum_circuit.i(lowercase_      )  # 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] ,    lowercase_      )  # measure the last two qbits

       _lowerCamelCase							:     Any	=		qiskit.Aer.get_backend('''aer_simulator'''      )
       _lowerCamelCase							:     Tuple	=		qiskit.execute(lowercase_ ,    lowercase_ ,    shots=10_00      )

       return job.result().get_counts(lowercase_      )


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_flax_available,
    is_tf_available,
    is_torch_available,
)


_lowerCamelCase			       =      {
    'configuration_roberta_prelayernorm': [
        'ROBERTA_PRELAYERNORM_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'RobertaPreLayerNormConfig',
        'RobertaPreLayerNormOnnxConfig',
    ],
}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       _lowerCamelCase			       =      [
           'ROBERTA_PRELAYERNORM_PRETRAINED_MODEL_ARCHIVE_LIST',
           'RobertaPreLayerNormForCausalLM',
           'RobertaPreLayerNormForMaskedLM',
           'RobertaPreLayerNormForMultipleChoice',
           'RobertaPreLayerNormForQuestionAnswering',
           'RobertaPreLayerNormForSequenceClassification',
           'RobertaPreLayerNormForTokenClassification',
           'RobertaPreLayerNormModel',
           'RobertaPreLayerNormPreTrainedModel',
       ]

try:
       if not is_tf_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       _lowerCamelCase			       =      [
           'TF_ROBERTA_PRELAYERNORM_PRETRAINED_MODEL_ARCHIVE_LIST',
           'TFRobertaPreLayerNormForCausalLM',
           'TFRobertaPreLayerNormForMaskedLM',
           'TFRobertaPreLayerNormForMultipleChoice',
           'TFRobertaPreLayerNormForQuestionAnswering',
           'TFRobertaPreLayerNormForSequenceClassification',
           'TFRobertaPreLayerNormForTokenClassification',
           'TFRobertaPreLayerNormMainLayer',
           'TFRobertaPreLayerNormModel',
           'TFRobertaPreLayerNormPreTrainedModel',
       ]

try:
       if not is_flax_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       _lowerCamelCase			       =      [
           'FlaxRobertaPreLayerNormForCausalLM',
           'FlaxRobertaPreLayerNormForMaskedLM',
           'FlaxRobertaPreLayerNormForMultipleChoice',
           'FlaxRobertaPreLayerNormForQuestionAnswering',
           'FlaxRobertaPreLayerNormForSequenceClassification',
           'FlaxRobertaPreLayerNormForTokenClassification',
           'FlaxRobertaPreLayerNormModel',
           'FlaxRobertaPreLayerNormPreTrainedModel',
       ]


if TYPE_CHECKING:
       from .configuration_roberta_prelayernorm import (
           ROBERTA_PRELAYERNORM_PRETRAINED_CONFIG_ARCHIVE_MAP,
           RobertaPreLayerNormConfig,
           RobertaPreLayerNormOnnxConfig,
       )

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_roberta_prelayernorm import (
                  ROBERTA_PRELAYERNORM_PRETRAINED_MODEL_ARCHIVE_LIST,
                  RobertaPreLayerNormForCausalLM,
                  RobertaPreLayerNormForMaskedLM,
                  RobertaPreLayerNormForMultipleChoice,
                  RobertaPreLayerNormForQuestionAnswering,
                  RobertaPreLayerNormForSequenceClassification,
                  RobertaPreLayerNormForTokenClassification,
                  RobertaPreLayerNormModel,
                  RobertaPreLayerNormPreTrainedModel,
              )

       try:
              if not is_tf_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_tf_roberta_prelayernorm import (
                  TF_ROBERTA_PRELAYERNORM_PRETRAINED_MODEL_ARCHIVE_LIST,
                  TFRobertaPreLayerNormForCausalLM,
                  TFRobertaPreLayerNormForMaskedLM,
                  TFRobertaPreLayerNormForMultipleChoice,
                  TFRobertaPreLayerNormForQuestionAnswering,
                  TFRobertaPreLayerNormForSequenceClassification,
                  TFRobertaPreLayerNormForTokenClassification,
                  TFRobertaPreLayerNormMainLayer,
                  TFRobertaPreLayerNormModel,
                  TFRobertaPreLayerNormPreTrainedModel,
              )

       try:
              if not is_flax_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_flax_roberta_prelayernorm import (
                  FlaxRobertaPreLayerNormForCausalLM,
                  FlaxRobertaPreLayerNormForMaskedLM,
                  FlaxRobertaPreLayerNormForMultipleChoice,
                  FlaxRobertaPreLayerNormForQuestionAnswering,
                  FlaxRobertaPreLayerNormForSequenceClassification,
                  FlaxRobertaPreLayerNormForTokenClassification,
                  FlaxRobertaPreLayerNormModel,
                  FlaxRobertaPreLayerNormPreTrainedModel,
              )

else:
       import sys

       _lowerCamelCase			       =      _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

