

import math

import qiskit


def 							__lowerCAmelCase     (							_UpperCamelCase		:	int = 1		,				_UpperCamelCase		:	int = 1		,				_UpperCamelCase		:	int = 1						)		->				qiskit.result.counts.Counts:
 '''simple docstring'''


 if (
     isinstance(_UpperCamelCase		,				_UpperCamelCase						)
     or isinstance(_UpperCamelCase		,				_UpperCamelCase						)
     or isinstance(_UpperCamelCase		,				_UpperCamelCase						)
 ):
  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(_UpperCamelCase						) != input_a)
     or (math.floor(_UpperCamelCase						) != input_a)
     or (math.floor(_UpperCamelCase						) != 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
 SCREAMING_SNAKE_CASE		    =      qiskit.QuantumRegister(4		,				'qr'						)
 SCREAMING_SNAKE_CASE		    =      qiskit.ClassicalRegister(2		,				'cr'						)
 # list the entries
 SCREAMING_SNAKE_CASE		    =      [input_a, input_a, carry_in]

 SCREAMING_SNAKE_CASE		    =      qiskit.QuantumCircuit(_UpperCamelCase		,				_UpperCamelCase						)

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

 SCREAMING_SNAKE_CASE		    =      qiskit.Aer.get_backend('aer_simulator'						)
 SCREAMING_SNAKE_CASE		    =      qiskit.execute(_UpperCamelCase		,				_UpperCamelCase		,				shots=10_00						)

 return job.result().get_counts(_UpperCamelCase						)


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




import argparse

from transformers import BigBirdConfig, BigBirdForPreTraining, BigBirdForQuestionAnswering, load_tf_weights_in_big_bird
from transformers.utils import logging


logging.set_verbosity_info()


def 							__lowerCAmelCase     (							_UpperCamelCase		:	str		,				_UpperCamelCase		:	Union[str, Any]		,				_UpperCamelCase		:	Tuple		,				_UpperCamelCase		:	Tuple						)		->				Dict:
 '''simple docstring'''


 SCREAMING_SNAKE_CASE		    =      BigBirdConfig.from_json_file(_UpperCamelCase						)
 print(f"""Building PyTorch model from configuration: {config}"""						)

 if is_trivia_qa:
  SCREAMING_SNAKE_CASE		    =      BigBirdForQuestionAnswering(_UpperCamelCase						)
 else:
  SCREAMING_SNAKE_CASE		    =      BigBirdForPreTraining(_UpperCamelCase						)

 # Load weights from tf checkpoint
 load_tf_weights_in_big_bird(_UpperCamelCase		,				_UpperCamelCase		,				is_trivia_qa=_UpperCamelCase						)

 # Save pytorch-model
 print(f"""Save PyTorch model to {pytorch_dump_path}"""						)
 model.save_pretrained(_UpperCamelCase						)


if __name__ == "__main__":
      a_     :    int     		=   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(
          "--big_bird_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."
      )
      parser.add_argument(
          "--is_trivia_qa", action="store_true", help="Whether to convert a model with a trivia_qa head."
      )
      a_     :    Any     		=   parser.parse_args()
      convert_tf_checkpoint_to_pytorch(
          args.tf_checkpoint_path, args.big_bird_config_file, args.pytorch_dump_path, args.is_trivia_qa
      )

