


'''simple docstring'''
import math

import qiskit


def       _lowercase							(					UpperCamelCase__							:       int = 1,					UpperCamelCase__							:       int = 1,					UpperCamelCase__							:       int = 1      ):
 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
 __A	:		Union[str, Any]	  =      qiskit.QuantumRegister(4,					'qr'      )
 __A	:		Dict	  =      qiskit.ClassicalRegister(2,					'cr'      )
 # list the entries
 __A	:		Dict	  =      [input_a, input_a, carry_in]

 __A	:		List[str]	  =      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

 __A	:		Union[str, Any]	  =      qiskit.Aer.get_backend('aer_simulator'      )
 __A	:		List[Any]	  =      qiskit.execute(UpperCamelCase__,					UpperCamelCase__,					shots=1000      )

 return job.result().get_counts(UpperCamelCase__      )


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










'''simple docstring'''
# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

import torch

from ..models.auto import AutoModelForVisualQuestionAnswering, AutoProcessor
from ..utils import requires_backends
from .base import PipelineTool


if TYPE_CHECKING:
 from PIL import Image

class     _lowerCamelCase       (     snake_case_					):




 '''simple docstring'''
 __lowercase					:		int     				=    '''dandelin/vilt-b32-finetuned-vqa'''
 __lowercase					:		int     				=    (
     '''This is a tool that answers a question about an image. It takes an input named `image` which should be the '''
     '''image containing the information, as well as a `question` which should be the question in English. It '''
     '''returns a text that is the answer to the question.'''
 )
 __lowercase					:		Union[str, Any]     				=    '''image_qa'''
 __lowercase					:		Optional[Any]     				=    AutoProcessor
 __lowercase					:		Tuple     				=    AutoModelForVisualQuestionAnswering

 __lowercase					:		Tuple     				=    ['''image''', '''text''']
 __lowercase					:		List[str]     				=    ['''text''']


 def __init__(   self   ,   *__lowercase   ,   **__lowercase    ):

  """simple docstring"""







  requires_backends(self   ,   ['vision']    )
  super().__init__(*__lowercase   ,   **__lowercase    )


 def 			snake_case__ (   self   ,   __lowercase   ,   __lowercase    ):

  """simple docstring"""







  return self.pre_processor(__lowercase   ,   __lowercase   ,   return_tensors='pt'    )


 def 			snake_case__ (   self   ,   __lowercase    ):

  """simple docstring"""







  with torch.no_grad():
   return self.model(**__lowercase    ).logits







 def 			snake_case__ (   self   ,   __lowercase    ):

  """simple docstring"""







  __A	:		List[str]	  =      outputs.argmax(-1    ).item()
  return self.model.config.idalabel[idx]






