



'''simple docstring'''




import math

import qiskit






def 	_lowerCAmelCase      (  __snake_case  :			int = 1			,							__snake_case  :			int = 1			,							__snake_case  :			int = 1      )					->					qiskit.result.counts.Counts:
     if (
         isinstance(__snake_case			,							__snake_case      )
         or isinstance(__snake_case			,							__snake_case      )
         or isinstance(__snake_case			,							__snake_case      )
     ):
          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(__snake_case      ) != input_a)
         or (math.floor(__snake_case      ) != input_a)
         or (math.floor(__snake_case      ) != 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						:			Optional[Any]								=	qiskit.QuantumRegister(4			,							'qr'      )
     __A						:			int								=	qiskit.ClassicalRegister(2			,							'cr'      )
     # list the entries
     __A						:			Optional[int]								=	[input_a, input_a, carry_in]

     __A						:			Optional[int]								=	qiskit.QuantumCircuit(__snake_case			,							__snake_case      )

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

     __A						:			str								=	qiskit.Aer.get_backend('aer_simulator'      )
     __A						:			Optional[int]								=	qiskit.execute(__snake_case			,							__snake_case			,							shots=10_00      )

     return job.result().get_counts(__snake_case      )


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






'''simple docstring'''




lowercase__   :				Any      =   {'''a''': ['''c''', '''b'''], '''b''': ['''d''', '''e'''], '''c''': [], '''d''': [], '''e''': []}
lowercase__   :				List[Any]      =   ['''a''', '''b''', '''c''', '''d''', '''e''']






def 	_lowerCAmelCase      (  __snake_case  :			str			,							__snake_case  :			Tuple			,							__snake_case  :			int      )					->					Tuple:
     __A						:			List[str]								=	start
     # add current to visited
     visited.append(__snake_case      )
     __A						:			Optional[int]								=	edges[current]
     for neighbor in neighbors:
          # if neighbor not in visited, visit
          if neighbor not in visited:
               __A						:			int								=	topological_sort(__snake_case			,							__snake_case			,							__snake_case      )
    # if all neighbors visited add current to sort
     sort.append(__snake_case      )
     # if all vertices haven't been visited select a new one to visit
     if len(__snake_case      ) != len(__snake_case      ):
          for vertice in vertices:
               if vertice not in visited:
                    __A						:			Dict								=	topological_sort(__snake_case			,							__snake_case			,							__snake_case      )
    # return sort
     return sort


if __name__ == "__main__":
  lowercase__   :				Tuple      =   topological_sort('''a''', [], [])
  print(sort)