
'''simple docstring'''
import numpy as np
import qiskit

def     UpperCamelCase_  (						__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							):
    """simple docstring"""






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

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

    snake_case_			:     Dict        =    oracle_qc.to_gate()
    snake_case_			:     List[Any]        =    "Oracle"  # To show when we display the circuit
    return oracle_gate

def     UpperCamelCase_  (						__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							):
    """simple docstring"""






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

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

    return dj_circuit

def     UpperCamelCase_  (						__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							):
    """simple docstring"""






    snake_case_			:     List[str]        =    qiskit.Aer.get_backend("aer_simulator"							)

    snake_case_			:     List[str]        =    dj_oracle(__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							)
    snake_case_			:     Union[str, Any]        =    dj_algorithm(__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							)

    # Execute the circuit on the simulator
    snake_case_			:     List[str]        =    qiskit.execute(__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		shots=1_0_0_0							)

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


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'''
import argparse
import json

from transformers import GPTNeoConfig, GPTNeoForCausalLM, load_tf_weights_in_gpt_neo
from transformers.utils import logging


logging.set_verbosity_info()

def     UpperCamelCase_  (						__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							):
    """simple docstring"""






    snake_case_			:     Optional[Any]        =    json.load(open(__SCREAMING_SNAKE_CASE,		"r"							)							)
    snake_case_			:     Optional[int]        =    GPTNeoConfig(
        hidden_size=config_json["n_embd"],		num_layers=config_json["n_layer"],		num_heads=config_json["n_head"],		attention_types=config_json["attention_types"],		max_position_embeddings=config_json["n_positions"],		resid_dropout=config_json["res_dropout"],		embed_dropout=config_json["embed_dropout"],		attention_dropout=config_json["attn_dropout"],		)
    print(f'Building PyTorch model from configuration: {config}'							)
    snake_case_			:     Optional[Any]        =    GPTNeoForCausalLM(__SCREAMING_SNAKE_CASE							)

    # Load weights from tf checkpoint
    load_tf_weights_in_gpt_neo(__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE							)

    # Save pytorch-model
    print(f'Save PyTorch model to {pytorch_dump_path}'							)
    model.save_pretrained(__SCREAMING_SNAKE_CASE							)


if __name__ == "__main__":
  a_           =    argparse.ArgumentParser()
  # Required parameters
  parser.add_argument(
      "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
  )
  parser.add_argument(
      "--config_file",
      default=None,
      type=str,
      required=True,
      help=(
          "The config json file corresponding to the pre-trained mesh-tf model. \n"
          "This specifies the model architecture."
      ),
  )
  parser.add_argument(
      "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
  )
  a_           =    parser.parse_args()
  convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)




