






'''simple docstring'''





import numpy as np
import qiskit






def  lowerCamelCase_  (     lowercase__					,  lowercase__):
 lowerCamelCase__	=  qiskit.QuantumCircuit(num_qubits + 1)

 # First, let's deal with the case in which oracle is balanced
 if case == "balanced":
  # First generate a random number that tells us which CNOTs to
  # wrap in X-gates:
  lowerCamelCase__	=  np.random.randint(1					,  2**num_qubits)
  # Next, format 'b' as a binary string of length 'n', padded with zeros:
  lowerCamelCase__	=  format(lowercase__					,  F'''0{num_qubits}b''')
  # Next, we place the first X-gates. Each digit in our binary string
  # corresponds to a qubit, if the digit is 0, we do nothing, if it's 1
  # we apply an X-gate to that qubit:
  for index, bit in enumerate(lowercase__):
   if bit == "1":
    oracle_qc.x(lowercase__)
        # Do the controlled-NOT gates for each qubit, using the output qubit
        # as the target:
  for index in range(lowercase__):
   oracle_qc.cx(lowercase__					,  lowercase__)
  # Next, place the final X-gates
  for index, bit in enumerate(lowercase__):
   if bit == "1":
    oracle_qc.x(lowercase__)

    # Case in which oracle is constant
 if case == "constant":
  # First decide what the fixed output of the oracle will be
  # (either always 0 or always 1)
  lowerCamelCase__	=  np.random.randint(2)
  if output == 1:
   oracle_qc.x(lowercase__)

 lowerCamelCase__	=  oracle_qc.to_gate()
 lowerCamelCase__	=  "Oracle"  # To show when we display the circuit
 return oracle_gate






def  lowerCamelCase_  (     lowercase__					,  lowercase__):
 lowerCamelCase__	=  qiskit.QuantumCircuit(num_qubits + 1					,  lowercase__)
 # Set up the output qubit:
 dj_circuit.x(lowercase__)
 dj_circuit.h(lowercase__)
 # And set up the input register:
 for qubit in range(lowercase__):
  dj_circuit.h(lowercase__)
 # Let's append the oracle gate to our circuit:
 dj_circuit.append(lowercase__					,  range(num_qubits + 1))
 # Finally, perform the H-gates again and measure:
 for qubit in range(lowercase__):
  dj_circuit.h(lowercase__)

 for i in range(lowercase__):
  dj_circuit.measure(lowercase__					,  lowercase__)

 return dj_circuit






def  lowerCamelCase_  (     lowercase__					,  lowercase__):
 lowerCamelCase__	=  qiskit.Aer.get_backend("aer_simulator")

 lowerCamelCase__	=  dj_oracle(lowercase__					,  lowercase__)
 lowerCamelCase__	=  dj_algorithm(lowercase__					,  lowercase__)

 # Execute the circuit on the simulator
 lowerCamelCase__	=  qiskit.execute(lowercase__					,  lowercase__					,  shots=1000)

 # Return the histogram data of the results of the experiment.
 return job.result().get_counts(lowercase__)


if __name__ == "__main__":
 print(F"""Deutsch Jozsa - Constant Oracle: {deutsch_jozsa('constant', 3)}""")
 print(F"""Deutsch Jozsa - Balanced Oracle: {deutsch_jozsa('balanced', 3)}""")









'''simple docstring'''





from __future__ import annotations

from queue import Queue
class 					lowercase							:


    '''simple docstring'''

    def __init__(       self  :  Optional[int]  )				->				None:

     '''simple docstring'''




     lowerCamelCase__	=  {}

    def  a__					(       self  :  Optional[int]  )				->				None:

     '''simple docstring'''




     for i in self.vertices:
      print(__lowerCamelCase					,  " : "					,  " -> ".join([str(__lowerCamelCase  ) for j in self.vertices[i]]  )  )

    def  a__					(       self  :  Optional[Any]					,  __lowerCamelCase  :  int					,  __lowerCamelCase  :  int  )				->				None:

     '''simple docstring'''




     if from_vertex in self.vertices:
      self.vertices[from_vertex].append(__lowerCamelCase  )
     else:
      lowerCamelCase__	=  [to_vertex]




    def  a__					(       self  :  Optional[int]					,  __lowerCamelCase  :  int  )				->				set[int]:

     '''simple docstring'''




     lowerCamelCase__	=  set()

     # create a first in first out queue to store all the vertices for BFS
     lowerCamelCase__	=  Queue()

     # mark the source node as visited and enqueue it
     visited.add(__lowerCamelCase  )
     queue.put(__lowerCamelCase  )

     while not queue.empty():
      lowerCamelCase__	=  queue.get()

      # loop through all adjacent vertex and enqueue it if not yet visited
      for adjacent_vertex in self.vertices[vertex]:
       if adjacent_vertex not in visited:
        queue.put(__lowerCamelCase  )
        visited.add(__lowerCamelCase  )
     return visited


if __name__ == "__main__":
 from doctest import testmod

 testmod(verbose=True)

 __A				:				Optional[Any]					=		Graph()
 g.add_edge(0, 1)
 g.add_edge(0, 2)
 g.add_edge(1, 2)
 g.add_edge(2, 0)
 g.add_edge(2, 3)
 g.add_edge(3, 3)

 g.print_graph()
 # 0  :  1 -> 2
 # 1  :  2
 # 2  :  0 -> 3
 # 3  :  3

 assert sorted(g.bfs(2)) == [0, 1, 2, 3]

