



"""simple docstring"""







import numpy as np
import qiskit

def 	lowerCAmelCase__      (  lowerCamelCase__					,   lowerCamelCase__      )			->				List[Any]:
							A    =       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:
														A    =       np.random.randint(1					,   2**num_qubits      )
														# Next, format 'b' as a binary string of length 'n', padded with zeros:
														A    =       format(lowerCamelCase__					,   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(lowerCamelCase__      ):
																					if bit == "1":
																												oracle_qc.x(lowerCamelCase__      )
        # Do the controlled-NOT gates for each qubit, using the output qubit
        # as the target:
														for index in range(lowerCamelCase__      ):
																					oracle_qc.cx(lowerCamelCase__					,   lowerCamelCase__      )
														# Next, place the final X-gates
														for index, bit in enumerate(lowerCamelCase__      ):
																					if bit == "1":
																												oracle_qc.x(lowerCamelCase__      )

    # 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)
														A    =       np.random.randint(2      )
														if output == 1:
																					oracle_qc.x(lowerCamelCase__      )

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

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

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

							return dj_circuit

def 	lowerCAmelCase__      (  lowerCamelCase__					,   lowerCamelCase__      )			->				List[Any]:
							A    =       qiskit.Aer.get_backend('aer_simulator'      )

							A    =       dj_oracle(lowerCamelCase__					,   lowerCamelCase__      )
							A    =       dj_algorithm(lowerCamelCase__					,   lowerCamelCase__      )

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

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


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











def    a__    (	A       ):
   return int(A       ) if x - int(A       ) >= 0 else int(A       ) - 1


if __name__ == "__main__":
 import doctest

 doctest.testmod()


