Object.QuantumAlgorithms (object v0.1.2)

@type optimization_problem() :: %{
  objective_function: function(),
  constraints: [function()],
  variable_bounds: [{float(), float()}],
  problem_type: :minimization | :maximization,
  classical_solution: term() | nil
}

quantum_circuit()

@type quantum_circuit() :: %{
  gates: [quantum_gate()],
  qubit_count: non_neg_integer(),
  depth: non_neg_integer(),
  parameters: [float()],
  cost_function: function()
}

quantum_gate()

@type quantum_gate() :: %{
  type:
    :pauli_x | :pauli_y | :pauli_z | :hadamard | :cnot | :rotation | :custom,
  target_qubits: [non_neg_integer()],
  parameters: [float()],
  unitary_matrix: [[Complex.t()]]
}

quantum_individual()

@type quantum_individual() :: %{
  chromosome: [float()],
  quantum_state: quantum_state(),
  fitness: float(),
  entanglement_score: float(),
  generation: non_neg_integer()
}

quantum_state()

@type quantum_state() :: %{
  qubits: [qubit()],
  global_phase: float(),
  entanglement_matrix: [[float()]],
  measurement_basis: :computational | :hadamard | :bell
}

qubit()

@type qubit() :: %{
  amplitude_0: Complex.t(),
  amplitude_1: Complex.t(),
  phase: float(),
  entangled_with: [non_neg_integer()]
}

state()

@type state() :: %{
  quantum_systems: %{required(binary()) => quantum_state()},
  optimization_problems: %{required(binary()) => optimization_problem()},
  active_circuits: %{required(binary()) => quantum_circuit()},
  populations: %{required(binary()) => [quantum_individual()]},
  performance_metrics: %{
    convergence_rate: float(),
    quantum_advantage: float(),
    entanglement_utilization: float()
  },
  hardware_simulation: %{
    noise_model: map(),
    error_rates: map(),
    decoherence_times: map()
  }
}

Functions

apply_quantum_gate(system_id, gate)

@spec apply_quantum_gate(binary(), quantum_gate()) :: :ok | {:error, term()}

Applies a quantum gate to the specified system.

child_spec(init_arg)

Returns a specification to start this module under a supervisor.

See Supervisor.

generate_qec_code(data_qubits, syndrome_qubits, distance)

@spec generate_qec_code(non_neg_integer(), non_neg_integer(), non_neg_integer()) ::
  {:ok, map()} | {:error, term()}

Generates quantum error correction codes.

initialize_quantum_system(system_id, num_qubits)

@spec initialize_quantum_system(binary(), non_neg_integer()) :: :ok | {:error, term()}

Initializes a quantum system with specified number of qubits.

quantum_annealing(problem, steps \\ 10000)

@spec quantum_annealing(optimization_problem(), non_neg_integer()) ::
  {:ok, term()} | {:error, term()}

Simulates quantum annealing for combinatorial optimization.

quantum_evolutionary_algorithm(problem, options \\ %{})

@spec quantum_evolutionary_algorithm(optimization_problem(), map()) ::
  {:ok, term()} | {:error, term()}

Performs quantum-inspired evolutionary algorithm optimization.

quantum_walk(graph, starting_node, num_steps)

@spec quantum_walk(map(), non_neg_integer(), non_neg_integer()) ::
  {:ok, [float()]} | {:error, term()}

Performs quantum walk on a graph structure.

run_qaoa(problem, num_layers \\ 10)

@spec run_qaoa(optimization_problem(), non_neg_integer()) ::
  {:ok, term()} | {:error, term()}

Runs QAOA (Quantum Approximate Optimization Algorithm) for combinatorial problems.

run_vqe(hamiltonian, ansatz_circuit)

@spec run_vqe(function(), quantum_circuit()) ::
  {:ok, {float(), [float()]}} | {:error, term()}

Executes VQE (Variational Quantum Eigensolver) for finding ground states.

start_link(opts \\ [])

Starts the quantum algorithms service.

train_quantum_neural_network(training_data, initial_circuit, options \\ %{})

@spec train_quantum_neural_network([{term(), term()}], quantum_circuit(), map()) ::
  {:ok, quantum_circuit()} | {:error, term()}

Trains a quantum neural network with parameterized quantum circuits.