code: 
  
  
  
  
  
  
  """simple docstring"""
  import math
  import warnings
  from dataclasses import dataclass
  from typing import List, Optional, Tuple, Union
  
  import numpy as np
  import torch
  from scipy import integrate
  
  from ..configuration_utils import ConfigMixin, register_to_config
  from ..utils import BaseOutput
  from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin
  
  
  
  @dataclass
  # Copied from diffusers.schedulers.scheduling_ddpm.DDPMSchedulerOutput with DDPM->LMSDiscrete
  class 					UpperCamelCase__   (							a_):
  
  
  
  
  
  
  
      """simple docstring"""
      __UpperCAmelCase											=   42
      __UpperCAmelCase											=   None
  
  
  def        A	(							__snake_case:   Union[str, Any]   ,    __snake_case:   int=0.999   ,    __snake_case:   Any="cosine"   ,    )						->		str:
  
         """simple docstring"""
  
  
  
  
  
         if alpha_transform_type == "cosine":
  
                def alpha_bar_fn(__snake_case:   List[Any]     ):
                       return math.cos((t + 0.008) / 1.008 * math.pi / 2     ) ** 2
  
         elif alpha_transform_type == "exp":
  
                def alpha_bar_fn(__snake_case:   List[Any]     ):
                       return math.exp(t * -1_2.0     )
  
         else:
                raise ValueError(F"""Unsupported alpha_tranform_type: {alpha_transform_type}"""     )
  
         __magic_name__										=						[]
         for i in range(_UpperCAmelCase     ):
                __magic_name__										=						i / num_diffusion_timesteps
                __magic_name__										=						(i + 1) / num_diffusion_timesteps
                betas.append(min(1 - alpha_bar_fn(_UpperCAmelCase     ) / alpha_bar_fn(_UpperCAmelCase     )   ,    _UpperCAmelCase     )     )
         return torch.tensor(_UpperCAmelCase   ,    dtype=torch.floataa     )
  
  
  
  
  
  
  class 					UpperCamelCase__   (							a_       ,  a_):
  
  
  
  
  
  
  
      """simple docstring"""
      __UpperCAmelCase											=   [e.name for e in KarrasDiffusionSchedulers]
      __UpperCAmelCase											=   1
  
  
  
  
  
  
  
      @register_to_config
      def __init__(		self   :  List[str]							,						UpperCamelCase_   :  int = 1_0_0_0							,						UpperCamelCase_   :  float = 0.0_001							,						UpperCamelCase_   :  float = 0.02							,						UpperCamelCase_   :  str = "linear"							,						UpperCamelCase_   :  Optional[Union[np.ndarray, List[float]]] = None							,						UpperCamelCase_   :  Optional[bool] = False							,						UpperCamelCase_   :  str = "epsilon"							,						UpperCamelCase_   :  str = "linspace"							,						UpperCamelCase_   :  int = 0							,						):
  
  
  
  
  
             '''simple docstring'''
  
             if trained_betas is not None:
                    __magic_name__										=						torch.tensor(UpperCAmelCase_							,						dtype=torch.floataa   )
             elif beta_schedule == "linear":
                    __magic_name__										=						torch.linspace(UpperCAmelCase_							,						UpperCAmelCase_							,						UpperCAmelCase_							,						dtype=torch.floataa   )
             elif beta_schedule == "scaled_linear":
                    # this schedule is very specific to the latent diffusion model.
                    __magic_name__										=						(
                        torch.linspace(beta_start**0.5							,						beta_end**0.5							,						UpperCAmelCase_							,						dtype=torch.floataa   ) ** 2
                    )
             elif beta_schedule == "squaredcos_cap_v2":
                    # Glide cosine schedule
                    __magic_name__										=						betas_for_alpha_bar(UpperCAmelCase_   )
             else:
                    raise NotImplementedError(f"""{beta_schedule} does is not implemented for {self.__class__}"""   )
  
             __magic_name__										=						1.0 - self.betas
             __magic_name__										=						torch.cumprod(self.alphas							,						dim=0   )
  
             __magic_name__										=						np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5   )
             __magic_name__										=						np.concatenate([sigmas[::-1], [0.0]]   ).astype(np.floataa   )
             __magic_name__										=						torch.from_numpy(UpperCAmelCase_   )
  
             # setable values
             __magic_name__										=						None
             __magic_name__										=						use_karras_sigmas
             self.set_timesteps(UpperCAmelCase_							,						UpperCAmelCase_   )
             __magic_name__										=						[]
             __magic_name__										=						False
  
  
  
  
  
  
  
      @property
      def 							a__ (		self   :  Dict   ):
  
  
  
  
  
             '''simple docstring'''
  
             if self.config.timestep_spacing in ["linspace", "trailing"]:
                    return self.sigmas.max()
  
             return (self.sigmas.max() ** 2 + 1) ** 0.5
  
  
  
  
  
  
  
      def 							a__ (		self   :  Any							,						UpperCamelCase_   :  torch.FloatTensor							,						UpperCamelCase_   :  Union[float, torch.FloatTensor]   ):
  
  
  
  
  
             '''simple docstring'''
  
             if isinstance(UpperCAmelCase_							,						torch.Tensor   ):
                    __magic_name__										=						timestep.to(self.timesteps.device   )
             __magic_name__										=						(self.timesteps == timestep).nonzero().item()
             __magic_name__										=						self.sigmas[step_index]
             __magic_name__										=						sample / ((sigma**2 + 1) ** 0.5)
             __magic_name__										=						True
             return sample
  
  
  
  
  
  
  
      def 							a__ (		self   :  Any							,						UpperCamelCase_   :  Any							,						UpperCamelCase_   :  Tuple							,						UpperCamelCase_   :  Optional[Any]   ):
  
  
  
  
  
             '''simple docstring'''
  
             def lms_derivative(UpperCamelCase_   :  int   ):
                    __magic_name__										=						1.0
                    for k in range(UpperCAmelCase_   ):
                           if current_order == k:
                                  continue
                           prod *= (tau - self.sigmas[t - k]) / (self.sigmas[t - current_order] - self.sigmas[t - k])
                    return prod
  
             __magic_name__										=						integrate.quad(UpperCAmelCase_							,						self.sigmas[t]							,						self.sigmas[t + 1]							,						epsrel=1e-4   )[0]
  
             return integrated_coeff
  
  
  
  
  
  
  
      def 							a__ (		self   :  int							,						UpperCamelCase_   :  int							,						UpperCamelCase_   :  Union[str, torch.device] = None   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						num_inference_steps
  
             # "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891
             if self.config.timestep_spacing == "linspace":
                    __magic_name__										=						np.linspace(0							,						self.config.num_train_timesteps - 1							,						UpperCAmelCase_							,						dtype=UpperCAmelCase_   )[
                        ::-1
                    ].copy()
             elif self.config.timestep_spacing == "leading":
                    __magic_name__										=						self.config.num_train_timesteps // self.num_inference_steps
                    # creates integer timesteps by multiplying by ratio
                    # casting to int to avoid issues when num_inference_step is power of 3
                    __magic_name__										=						(np.arange(0							,						UpperCAmelCase_   ) * step_ratio).round()[::-1].copy().astype(UpperCAmelCase_   )
                    timesteps += self.config.steps_offset
             elif self.config.timestep_spacing == "trailing":
                    __magic_name__										=						self.config.num_train_timesteps / self.num_inference_steps
                    # creates integer timesteps by multiplying by ratio
                    # casting to int to avoid issues when num_inference_step is power of 3
                    __magic_name__										=						(np.arange(self.config.num_train_timesteps							,						0							,						-step_ratio   )).round().copy().astype(UpperCAmelCase_   )
                    timesteps -= 1
             else:
                    raise ValueError(
                        f"""{self.config.timestep_spacing} is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'."""   )
  
             __magic_name__										=						np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5   )
             __magic_name__										=						np.log(UpperCAmelCase_   )
             __magic_name__										=						np.interp(UpperCAmelCase_							,						np.arange(0							,						len(UpperCAmelCase_   )   )							,						UpperCAmelCase_   )
  
             if self.use_karras_sigmas:
                    __magic_name__										=						self._convert_to_karras(in_sigmas=UpperCAmelCase_   )
                    __magic_name__										=						np.array([self._sigma_to_t(UpperCAmelCase_							,						UpperCAmelCase_   ) for sigma in sigmas]   )
  
             __magic_name__										=						np.concatenate([sigmas, [0.0]]   ).astype(np.floataa   )
  
             __magic_name__										=						torch.from_numpy(UpperCAmelCase_   ).to(device=UpperCAmelCase_   )
             if str(UpperCAmelCase_   ).startswith('mps'   ):
                    # mps does not support float64
                    __magic_name__										=						torch.from_numpy(UpperCAmelCase_   ).to(UpperCAmelCase_							,						dtype=torch.floataa   )
             else:
                    __magic_name__										=						torch.from_numpy(UpperCAmelCase_   ).to(device=UpperCAmelCase_   )
  
             __magic_name__										=						[]
  
  
  
  
  
  
  
      def 							a__ (		self   :  str							,						UpperCamelCase_   :  Optional[Any]							,						UpperCamelCase_   :  List[str]   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						np.log(UpperCAmelCase_   )
  
             # get distribution
             __magic_name__										=						log_sigma - log_sigmas[:, np.newaxis]
  
             # get sigmas range
             __magic_name__										=						np.cumsum((dists >= 0)							,						axis=0   ).argmax(axis=0   ).clip(max=log_sigmas.shape[0] - 2   )
             __magic_name__										=						low_idx + 1
  
             __magic_name__										=						log_sigmas[low_idx]
             __magic_name__										=						log_sigmas[high_idx]
  
             # interpolate sigmas
             __magic_name__										=						(low - log_sigma) / (low - high)
             __magic_name__										=						np.clip(UpperCAmelCase_							,						0							,						1   )
  
             # transform interpolation to time range
             __magic_name__										=						(1 - w) * low_idx + w * high_idx
             __magic_name__										=						t.reshape(sigma.shape   )
             return t
  
  
  
  
  
  
  
      def 							a__ (		self   :  Any							,						UpperCamelCase_   :  torch.FloatTensor   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						in_sigmas[-1].item()
             __magic_name__										=						in_sigmas[0].item()
  
             __magic_name__										=						7.0  # 7.0 is the value used in the paper
             __magic_name__										=						np.linspace(0							,						1							,						self.num_inference_steps   )
             __magic_name__										=						sigma_min ** (1 / rho)
             __magic_name__										=						sigma_max ** (1 / rho)
             __magic_name__										=						(max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho
             return sigmas
  
  
  
  
  
  
  
      def 							a__ (		self   :  Optional[int]							,						UpperCamelCase_   :  torch.FloatTensor							,						UpperCamelCase_   :  Union[float, torch.FloatTensor]							,						UpperCamelCase_   :  torch.FloatTensor							,						UpperCamelCase_   :  int = 4							,						UpperCamelCase_   :  bool = True							,						):
  
  
  
  
  
             '''simple docstring'''
  
             if not self.is_scale_input_called:
                    warnings.warn(
                        'The `scale_model_input` function should be called before `step` to ensure correct denoising. '
                        'See `StableDiffusionPipeline` for a usage example.'   )
  
             if isinstance(UpperCAmelCase_							,						torch.Tensor   ):
                    __magic_name__										=						timestep.to(self.timesteps.device   )
             __magic_name__										=						(self.timesteps == timestep).nonzero().item()
             __magic_name__										=						self.sigmas[step_index]
  
             # 1. compute predicted original sample (x_0) from sigma-scaled predicted noise
             if self.config.prediction_type == "epsilon":
                    __magic_name__										=						sample - sigma * model_output
             elif self.config.prediction_type == "v_prediction":
                    # * c_out + input * c_skip
                    __magic_name__										=						model_output * (-sigma / (sigma**2 + 1) ** 0.5) + (sample / (sigma**2 + 1))
             elif self.config.prediction_type == "sample":
                    __magic_name__										=						model_output
             else:
                    raise ValueError(
                        f"""prediction_type given as {self.config.prediction_type} must be one of `epsilon`, or `v_prediction`"""   )
  
             # 2. Convert to an ODE derivative
             __magic_name__										=						(sample - pred_original_sample) / sigma
             self.derivatives.append(UpperCAmelCase_   )
             if len(self.derivatives   ) > order:
                    self.derivatives.pop(0   )
  
             # 3. Compute linear multistep coefficients
             __magic_name__										=						min(step_index + 1							,						UpperCAmelCase_   )
             __magic_name__										=						[self.get_lms_coefficient(UpperCAmelCase_							,						UpperCAmelCase_							,						UpperCAmelCase_   ) for curr_order in range(UpperCAmelCase_   )]
  
             # 4. Compute previous sample based on the derivatives path
             __magic_name__										=						sample + sum(
                 coeff * derivative for coeff, derivative in zip(UpperCAmelCase_							,						reversed(self.derivatives   )   )   )
  
             if not return_dict:
                    return (prev_sample,)
  
             return LMSDiscreteSchedulerOutput(prev_sample=UpperCAmelCase_							,						pred_original_sample=UpperCAmelCase_   )
  
  
  
  
  
  
  
      def 							a__ (		self   :  Optional[int]							,						UpperCamelCase_   :  torch.FloatTensor							,						UpperCamelCase_   :  torch.FloatTensor							,						UpperCamelCase_   :  torch.FloatTensor							,						):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						self.sigmas.to(device=original_samples.device							,						dtype=original_samples.dtype   )
             if original_samples.device.type == "mps" and torch.is_floating_point(UpperCAmelCase_   ):
                    # mps does not support float64
                    __magic_name__										=						self.timesteps.to(original_samples.device							,						dtype=torch.floataa   )
                    __magic_name__										=						timesteps.to(original_samples.device							,						dtype=torch.floataa   )
             else:
                    __magic_name__										=						self.timesteps.to(original_samples.device   )
                    __magic_name__										=						timesteps.to(original_samples.device   )
  
             __magic_name__										=						[(schedule_timesteps == t).nonzero().item() for t in timesteps]
  
             __magic_name__										=						sigmas[step_indices].flatten()
             while len(sigma.shape   ) < len(original_samples.shape   ):
                    __magic_name__										=						sigma.unsqueeze(-1   )
  
             __magic_name__										=						original_samples + noise * sigma
             return noisy_samples
  
  
  
  
  
  
  
      def __len__(		self   :  Dict   ):
  
  
  
  
  
             '''simple docstring'''
  
             return self.config.num_train_timesteps
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  import numpy as np
  import qiskit
  
  
  def        A	(							__snake_case:   str   ,    __snake_case:   int     )						->		qiskit.QuantumCircuit:
  
         """simple docstring"""
  
  
  
  
  
         __magic_name__										=						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:
                __magic_name__										=						np.random.randint(1   ,    2**num_qubits     )
                # Next, format 'b' as a binary string of length 'n', padded with zeros:
                __magic_name__										=						format(__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(__snake_case     ):
                       if bit == "1":
                              oracle_qc.x(__snake_case     )
          # Do the controlled-NOT gates for each qubit, using the output qubit
          # as the target:
                for index in range(__snake_case     ):
                       oracle_qc.cx(__snake_case   ,    __snake_case     )
                # Next, place the final X-gates
                for index, bit in enumerate(__snake_case     ):
                       if bit == "1":
                              oracle_qc.x(__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)
                __magic_name__										=						np.random.randint(2     )
                if output == 1:
                       oracle_qc.x(__snake_case     )
  
         __magic_name__										=						oracle_qc.to_gate()
         __magic_name__										=						'Oracle'  # To show when we display the circuit
         return oracle_gate
  
  
  def        A	(							__snake_case:   qiskit.QuantumCircuit   ,    __snake_case:   int     )						->		qiskit.QuantumCircuit:
  
         """simple docstring"""
  
  
  
  
  
         __magic_name__										=						qiskit.QuantumCircuit(num_qubits + 1   ,    __snake_case     )
         # Set up the output qubit:
         dj_circuit.x(__snake_case     )
         dj_circuit.h(__snake_case     )
         # And set up the input register:
         for qubit in range(__snake_case     ):
                dj_circuit.h(__snake_case     )
         # Let's append the oracle gate to our circuit:
         dj_circuit.append(__snake_case   ,    range(num_qubits + 1     )     )
         # Finally, perform the H-gates again and measure:
         for qubit in range(__snake_case     ):
                dj_circuit.h(__snake_case     )
  
         for i in range(__snake_case     ):
                dj_circuit.measure(__snake_case   ,    __snake_case     )
  
         return dj_circuit
  
  
  def        A	(							__snake_case:   str   ,    __snake_case:   int     )						->		qiskit.result.counts.Counts:
  
         """simple docstring"""
  
  
  
  
  
         __magic_name__										=						qiskit.Aer.get_backend('aer_simulator'     )
  
         __magic_name__										=						dj_oracle(__snake_case   ,    __snake_case     )
         __magic_name__										=						dj_algorithm(__snake_case   ,    __snake_case     )
  
         # Execute the circuit on the simulator
         __magic_name__										=						qiskit.execute(__snake_case   ,    __snake_case   ,    shots=1_0_0_0     )
  
         # Return the histogram data of the results of the experiment.
         return job.result().get_counts(__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)}""")