






"""simple docstring"""


import numpy as np
import qiskit




def      snake_case    (A_ :str      ,     A_ :int ):







  '''simple docstring'''

  a	:     Optional[Any]							=  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	:     List[str]							=  np.random.randint(1      ,     2**num_qubits )
    # Next, format 'b' as a binary string of length 'n', padded with zeros:
    a	:     str							=  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)
    a	:     Tuple							=  np.random.randint(2 )
    if output == 1:
      oracle_qc.x(lowercase__ )

  a	:     List[Any]							=  oracle_qc.to_gate()
  a	:     Optional[Any]							=  'Oracle'  # To show when we display the circuit
  return oracle_gate




def      snake_case    (A_ :qiskit.QuantumCircuit      ,     A_ :int ):







  '''simple docstring'''

  a	:     Any							=  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      snake_case    (A_ :str      ,     A_ :int ):







  '''simple docstring'''

  a	:     Optional[int]							=  qiskit.Aer.get_backend('aer_simulator' )

  a	:     Optional[int]							=  dj_oracle(lowercase__      ,     lowercase__ )
  a	:     Optional[int]							=  dj_algorithm(lowercase__      ,     lowercase__ )

  # Execute the circuit on the simulator
  a	:     Any							=  qiskit.execute(lowercase__      ,     lowercase__      ,     shots=1_0_0_0 )

  # 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)}''')








import sys
from dataclasses import dataclass
from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union

import pandas as pd
import pyarrow as pa

import datasets
import datasets.config
from datasets.features.features import require_storage_cast
from datasets.table import table_cast


if TYPE_CHECKING:
			import sqlitea

			import sqlalchemy


snake_case__  				=			datasets.utils.logging.get_logger(__name__)



@dataclass
class      snake_case__	(   datasets.BuilderConfig	):
				__lowerCAmelCase		=   None
				__lowerCAmelCase		=   None
				__lowerCAmelCase		=   None
				__lowerCAmelCase		=   True
				__lowerCAmelCase		=   None
				__lowerCAmelCase		=   None
				__lowerCAmelCase		=   None
				__lowerCAmelCase		=   10_000
				__lowerCAmelCase		=   None
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										if self.sql is None:
																raise ValueError('sql must be specified'   )
										if self.con is None:
																raise ValueError('con must be specified'   )
				def 			UpperCamelCase_    (	self  ,   _UpperCAmelCase  ,   _UpperCAmelCase = None  ,   ):




										"""simple docstring"""




										__magic_name__					:				Optional[int]				=   config_kwargs.copy()
										# We need to stringify the Selectable object to make its hash deterministic

										# The process of stringifying is explained here: http://docs.sqlalchemy.org/en/latest/faq/sqlexpressions.html
										__magic_name__					:				Union[str, Any]				=   config_kwargs['sql']
										if not isinstance(_UpperCAmelCase  ,   _UpperCAmelCase   ):
																if datasets.config.SQLALCHEMY_AVAILABLE and "sqlalchemy" in sys.modules:
																						import sqlalchemy

																						if isinstance(_UpperCAmelCase  ,   sqlalchemy.sql.Selectable   ):
																												__magic_name__					:				List[Any]				=   sqlalchemy.create_engine(config_kwargs['con'].split('://'   )[0] + '://'   )
																												__magic_name__					:				Any				=   str(sql.compile(dialect=engine.dialect   )   )
																												__magic_name__					:				str				=   sql_str
																						else:
																												raise TypeError(
																												    F"Supported types for 'sql' are string and sqlalchemy.sql.Selectable but got {type(_UpperCAmelCase   )}: {sql}"   )
																else:
																						raise TypeError(
																						    F"Supported types for 'sql' are string and sqlalchemy.sql.Selectable but got {type(_UpperCAmelCase   )}: {sql}"   )
										__magic_name__					:				List[Any]				=   config_kwargs['con']
										if not isinstance(_UpperCAmelCase  ,   _UpperCAmelCase   ):
																__magic_name__					:				Dict				=   id(_UpperCAmelCase   )
																logger.info(
																    F"SQL connection 'con' of type {type(_UpperCAmelCase   )} couldn't be hashed properly. To enable hashing, specify 'con' as URI string instead."   )

										return super().create_config_id(_UpperCAmelCase  ,   custom_features=_UpperCAmelCase   )





				@property
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										__magic_name__					:				str				=   {
										    'index_col': self.index_col,
										    'columns': self.columns,
										    'params': self.params,
										    'coerce_float': self.coerce_float,
										    'parse_dates': self.parse_dates,
										}
										return pd_read_sql_kwargs






class      snake_case__	(   datasets.ArrowBasedBuilder	):
				__lowerCAmelCase		=   SqlConfig
				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										return datasets.DatasetInfo(features=self.config.features   )
				def 			UpperCamelCase_    (	self  ,   _UpperCAmelCase   ):




										"""simple docstring"""




										return [datasets.SplitGenerator(name=datasets.Split.TRAIN  ,   gen_kwargs={}   )]
				def 			UpperCamelCase_    (	self  ,   _UpperCAmelCase   ):




										"""simple docstring"""




										if self.config.features is not None:
																__magic_name__					:				List[Any]				=   self.config.features.arrow_schema
																if all(not require_storage_cast(_UpperCAmelCase   ) for feature in self.config.features.values()   ):
																						# cheaper cast
																						__magic_name__					:				Dict				=   pa.Table.from_arrays([pa_table[field.name] for field in schema]  ,   schema=_UpperCAmelCase   )
																else:
																						# more expensive cast; allows str <-> int/float or str to Audio for example
																						__magic_name__					:				List[Any]				=   table_cast(_UpperCAmelCase  ,   _UpperCAmelCase   )
										return pa_table





				def 			UpperCamelCase_    (	self   ):




										"""simple docstring"""




										__magic_name__					:				int				=   self.config.chunksize
										__magic_name__					:				Tuple				=   pd.read_sql(
										    self.config.sql  ,   self.config.con  ,   chunksize=_UpperCAmelCase  ,   **self.config.pd_read_sql_kwargs   )
										__magic_name__					:				Dict				=   [sql_reader] if chunksize is None else sql_reader
										for chunk_idx, df in enumerate(_UpperCAmelCase   ):
																__magic_name__					:				Optional[Any]				=   pa.Table.from_pandas(_UpperCAmelCase   )
																yield chunk_idx, self._cast_table(_UpperCAmelCase   )


