


import math

import qiskit







def 							lowerCAmelCase_	(   __lowerCamelCase = 1				,      __lowerCamelCase = 1				,      __lowerCamelCase = 1      ):
							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
							__snake_case						:     int									=  qiskit.QuantumRegister(4				,      "qr"      )
							__snake_case						:     Optional[int]									=  qiskit.ClassicalRegister(2				,      "cr"      )
							# list the entries
							__snake_case						:     List[Any]									=  [input_a, input_a, carry_in]

							__snake_case						:     Dict									=  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

							__snake_case						:     Optional[int]									=  qiskit.Aer.get_backend("aer_simulator"      )
							__snake_case						:     int									=  qiskit.execute(__lowerCamelCase				,      __lowerCamelCase				,      shots=1_0_0_0      )

							return job.result().get_counts(__lowerCamelCase      )


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



import argparse

import torch

from transformers import BertConfig, BertForPreTraining, load_tf_weights_in_bert
from transformers.utils import logging


logging.set_verbosity_info()


def      UpperCamelCase   (       __lowerCamelCase	:					List[str]							,   __lowerCamelCase	:					Union[str, Any]							,   __lowerCamelCase	:					Union[str, Any]       ):
       # Initialise PyTorch model
       snake_case			:  Optional[int]     							= BertConfig.from_json_file(__lowerCamelCase       )
       print(f"""Building PyTorch model from configuration: {config}"""       )
       snake_case			:  Any     							= BertForPreTraining(__lowerCamelCase       )

       # Load weights from tf checkpoint
       load_tf_weights_in_bert(__lowerCamelCase							,   __lowerCamelCase							,   __lowerCamelCase       )

       # Save pytorch-model
       print(f"""Save PyTorch model to {pytorch_dump_path}"""       )
       torch.save(model.state_dict()							,   __lowerCamelCase       )


if __name__ == "__main__":
   __lowerCamelCase				=			argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
   )
   parser.add_argument(
       """--bert_config_file""",
       default=None,
       type=str,
       required=True,
       help=(
           """The config json file corresponding to the pre-trained BERT model. \n"""
           """This specifies the model architecture."""
       ),
   )
   parser.add_argument(
       """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
   )
   __lowerCamelCase				=			parser.parse_args()
   convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)





