


import math

import qiskit
def      snake_case_						( __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
   UpperCAmelCase_							:      Any						=   qiskit.QuantumRegister(4			,       '''qr'''       )
   UpperCAmelCase_							:      List[str]						=   qiskit.ClassicalRegister(2			,       '''cr'''       )
   # list the entries
   UpperCAmelCase_							:      Any						=   [input_a, input_a, carry_in]

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

   UpperCAmelCase_							:      Optional[int]						=   qiskit.Aer.get_backend('''aer_simulator'''       )
   UpperCAmelCase_							:      List[str]						=   qiskit.execute(__lowercase			,       __lowercase			,       shots=1_0_0_0       )

   return job.result().get_counts(__lowercase       )


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



import copy

from ...configuration_utils import PretrainedConfig
from ...utils import add_start_docstrings


__UpperCamelCase				:  Dict      					=							R'\n    [`RagConfig`] stores the configuration of a *RagModel*. Configuration objects inherit from [`PretrainedConfig`] and\n    can be used to control the model outputs. Read the documentation from [`PretrainedConfig`] for more information.\n\n    Args:\n        title_sep (`str`, *optional*, defaults to  `" / "`):\n            Separator inserted between the title and the text of the retrieved document when calling [`RagRetriever`].\n        doc_sep (`str`, *optional*, defaults to  `" // "`):\n            Separator inserted between the text of the retrieved document and the original input when calling\n            [`RagRetriever`].\n        n_docs (`int`, *optional*, defaults to 5):\n            Number of documents to retrieve.\n        max_combined_length (`int`, *optional*, defaults to 300):\n            Max length of contextualized input returned by [`~RagRetriever.__call__`].\n        retrieval_vector_size (`int`, *optional*, defaults to 768):\n            Dimensionality of the document embeddings indexed by [`RagRetriever`].\n        retrieval_batch_size (`int`, *optional*, defaults to 8):\n            Retrieval batch size, defined as the number of queries issues concurrently to the faiss index encapsulated\n            [`RagRetriever`].\n        dataset (`str`, *optional*, defaults to `"wiki_dpr"`):\n            A dataset identifier of the indexed dataset in HuggingFace Datasets (list all available datasets and ids\n            using `datasets.list_datasets()`).\n        dataset_split (`str`, *optional*, defaults to `"train"`)\n            Which split of the `dataset` to load.\n        index_name (`str`, *optional*, defaults to `"compressed"`)\n            The index name of the index associated with the `dataset`. One can choose between `"legacy"`, `"exact"` and\n            `"compressed"`.\n        index_path (`str`, *optional*)\n            The path to the serialized faiss index on disk.\n        passages_path (`str`, *optional*):\n            A path to text passages compatible with the faiss index. Required if using\n            [`~models.rag.retrieval_rag.LegacyIndex`]\n        use_dummy_dataset (`bool`, *optional*, defaults to `False`)\n            Whether to load a "dummy" variant of the dataset specified by `dataset`.\n        label_smoothing (`float`, *optional*, defaults to 0.0):\n            Only relevant if `return_loss` is set to `True`. Controls the `epsilon` parameter value for label smoothing\n            in the loss calculation. If set to 0, no label smoothing is performed.\n        do_marginalize (`bool`, *optional*, defaults to `False`):\n            If `True`, the logits are marginalized over all documents by making use of\n            `torch.nn.functional.log_softmax`.\n        reduce_loss (`bool`, *optional*, defaults to `False`):\n            Whether or not to reduce the NLL loss using the `torch.Tensor.sum` operation.\n        do_deduplication (`bool`, *optional*, defaults to `True`):\n            Whether or not to deduplicate the generations from different context documents for a given input. Has to be\n            set to `False` if used while training with distributed backend.\n        exclude_bos_score (`bool`, *optional*, defaults to `False`):\n            Whether or not to disregard the BOS token when computing the loss.\n        output_retrieved(`bool`, *optional*, defaults to `False`):\n            If set to `True`, `retrieved_doc_embeds`, `retrieved_doc_ids`, `context_input_ids` and\n            `context_attention_mask` are returned. See returned tensors for more detail.\n        use_cache (`bool`, *optional*, defaults to `True`):\n            Whether or not the model should return the last key/values attentions (not used by all models).\n        forced_eos_token_id (`int`, *optional*):\n            The id of the token to force as the last generated token when `max_length` is reached. Usually set to\n            `eos_token_id`.\n'





@add_start_docstrings(snake_case__						)
class  lowerCAmelCase__(    snake_case__						):






    '''simple docstring'''





    A_  :     Union[str, Any]			= 'rag'
    A_  :     Tuple			= True





    def __init__(	self				:   int       ,   __snake_case				:   List[str]=None       ,   __snake_case				:   List[Any]=True       ,   __snake_case				:   Optional[int]=None       ,   __snake_case				:   Union[str, Any]=None       ,   __snake_case				:   int=None       ,   __snake_case				:   Any=None       ,   __snake_case				:   Optional[int]=None       ,   __snake_case				:   Optional[int]=" / "       ,   __snake_case				:   Any=" // "       ,   __snake_case				:   Tuple=5       ,   __snake_case				:   Union[str, Any]=300       ,   __snake_case				:   Any=768       ,   __snake_case				:   Tuple=8       ,   __snake_case				:   int="wiki_dpr"       ,   __snake_case				:   Optional[int]="train"       ,   __snake_case				:   Tuple="compressed"       ,   __snake_case				:   Optional[int]=None       ,   __snake_case				:   List[Any]=None       ,   __snake_case				:   Optional[int]=False       ,   __snake_case				:   str=False       ,   __snake_case				:   Dict=0.0       ,   __snake_case				:   Union[str, Any]=True       ,   __snake_case				:   Union[str, Any]=False       ,   __snake_case				:   str=False       ,   __snake_case				:   str=False       ,   __snake_case				:   Optional[Any]=True       ,   __snake_case				:   int=None       ,   **__snake_case				:   str       ,   ):





       '''simple docstring'''
       super().__init__(
           bos_token_id=__snake_case       ,   pad_token_id=__snake_case       ,   eos_token_id=__snake_case       ,   decoder_start_token_id=__snake_case       ,   forced_eos_token_id=__snake_case       ,   is_encoder_decoder=__snake_case       ,   prefix=__snake_case       ,   vocab_size=__snake_case       ,   **__snake_case       ,   )
       assert (
           "question_encoder" in kwargs and "generator" in kwargs
       ), "Config has to be initialized with question_encoder and generator config"
       UpperCAmelCase_							:      Dict						=   kwargs.pop('''question_encoder'''	)
       UpperCAmelCase_							:      List[Any]						=   question_encoder_config.pop('''model_type'''	)
       UpperCAmelCase_							:      Any						=   kwargs.pop('''generator'''	)
       UpperCAmelCase_							:      Union[str, Any]						=   decoder_config.pop('''model_type'''	)

       from ..auto.configuration_auto import AutoConfig

       UpperCAmelCase_							:      Any						=   AutoConfig.for_model(__snake_case       ,   **__snake_case	)
       UpperCAmelCase_							:      int						=   AutoConfig.for_model(__snake_case       ,   **__snake_case	)

       UpperCAmelCase_							:      Any						=   reduce_loss
       UpperCAmelCase_							:      List[Any]						=   label_smoothing
       UpperCAmelCase_							:      Tuple						=   exclude_bos_score
       UpperCAmelCase_							:      int						=   do_marginalize

       UpperCAmelCase_							:      Tuple						=   title_sep
       UpperCAmelCase_							:      Union[str, Any]						=   doc_sep
       UpperCAmelCase_							:      Any						=   n_docs
       UpperCAmelCase_							:      Optional[int]						=   max_combined_length

       UpperCAmelCase_							:      Any						=   dataset
       UpperCAmelCase_							:      List[Any]						=   dataset_split
       UpperCAmelCase_							:      Union[str, Any]						=   index_name

       UpperCAmelCase_							:      List[str]						=   retrieval_vector_size
       UpperCAmelCase_							:      Optional[Any]						=   retrieval_batch_size
       UpperCAmelCase_							:      Optional[int]						=   passages_path
       UpperCAmelCase_							:      Optional[Any]						=   index_path
       UpperCAmelCase_							:      List[Any]						=   use_dummy_dataset

       UpperCAmelCase_							:      int						=   output_retrieved

       UpperCAmelCase_							:      int						=   do_deduplication

       UpperCAmelCase_							:      Optional[int]						=   use_cache

       if self.forced_eos_token_id is None:
          UpperCAmelCase_							:      int						=   getattr(self.generator       ,   '''forced_eos_token_id'''       ,   __snake_case	)





    @classmethod
    def 					_lowerCamelCase (	cls				:   Optional[Any]       ,   __snake_case				:   PretrainedConfig       ,   __snake_case				:   PretrainedConfig       ,   **__snake_case				:   str	):





       '''simple docstring'''
       return cls(question_encoder=question_encoder_config.to_dict()       ,   generator=generator_config.to_dict()       ,   **__snake_case	)





    def 					_lowerCamelCase (	self				:   int	):





       '''simple docstring'''
       UpperCAmelCase_							:      Union[str, Any]						=   copy.deepcopy(self.__dict__	)
       UpperCAmelCase_							:      Optional[int]						=   self.question_encoder.to_dict()
       UpperCAmelCase_							:      Dict						=   self.generator.to_dict()
       UpperCAmelCase_							:      Optional[Any]						=   self.__class__.model_type
       return output