diff --git a/finance/docs/locale/es_UN/LC_MESSAGES/getting_started.po b/finance/docs/locale/es_UN/LC_MESSAGES/getting_started.po index 6de34f4ae8e9d..6bbf7139a8745 100644 --- a/finance/docs/locale/es_UN/LC_MESSAGES/getting_started.po +++ b/finance/docs/locale/es_UN/LC_MESSAGES/getting_started.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-14 09:35+0000\n" -"PO-Revision-Date: 2023-11-14 11:56\n" +"PO-Revision-Date: 2024-01-14 18:33\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -28,7 +28,7 @@ msgstr "Instalación" #: ../../getting_started.rst:10 msgid "Qiskit Finance depends on Qiskit, which has its own `Qiskit Getting Started `__ detailing the installation options and its supported environments/platforms. You should refer to that first. Then the information here can be followed which focuses on the additional installation specific to Qiskit Finance." -msgstr "" +msgstr "Qiskit Finance depende de Qiskit, que tiene su propio `Qiskit Primeros Pasos `__ que detalla las opciones de instalación y sus entornos/plataformas compatibles. Deberías referirte a eso primero. Luego, se puede seguir la información que está aquí, la cual se centra en la instalación adicional específica de Qiskit Finance." #: ../../getting_started.rst msgid "Start locally" @@ -36,15 +36,15 @@ msgstr "Comenzar localmente" #: ../../getting_started.rst:20 msgid "The simplest way to get started is to first follow the `getting started 'Start locally' guide for Qiskit `__" -msgstr "" +msgstr "La forma más sencilla de comenzar es seguir primero la `guía de primeros pasos 'Comenzar localmente' para Qiskit `__" #: ../../getting_started.rst:23 msgid "In your virtual environment, where you installed Qiskit, install Qiskit Finance as follows:" -msgstr "" +msgstr "En tu entorno virtual, donde instalaste Qiskit, instala Qiskit Finance de la siguiente manera:" #: ../../getting_started.rst:31 msgid "As Qiskit Finance depends on Qiskit, you can though simply install it into your environment, as above, and pip will automatically install a compatible version of Qiskit if one is not already installed." -msgstr "" +msgstr "Como Qiskit Finance depende de Qiskit, simplemente puedes instalarlo en tu entorno, como se indicó anteriormente, y pip instalará automáticamente una versión compatible de Qiskit si aún no hay una instalada." #: ../../getting_started.rst msgid "Install from source" diff --git a/finance/docs/locale/es_UN/LC_MESSAGES/tutorials/00_amplitude_estimation.po b/finance/docs/locale/es_UN/LC_MESSAGES/tutorials/00_amplitude_estimation.po index 727ae174179e5..d143f6879949c 100644 --- a/finance/docs/locale/es_UN/LC_MESSAGES/tutorials/00_amplitude_estimation.po +++ b/finance/docs/locale/es_UN/LC_MESSAGES/tutorials/00_amplitude_estimation.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-14 09:35+0000\n" -"PO-Revision-Date: 2023-11-14 11:57\n" +"PO-Revision-Date: 2024-01-14 18:33\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -52,7 +52,7 @@ msgstr "\\mathcal{Q} = \\mathcal{A}\\mathcal{S}_0\\mathcal{A}^\\dagger\\mathcal{ #: ../../tutorials/00_amplitude_estimation.ipynb:32 msgid "where :math:`\\mathcal{S}_0` and :math:`\\mathcal{S}_{\\Psi_1}` are reflections about the :math:`|0\\rangle` and :math:`|\\Psi_1\\rangle` states, respectively, and phase estimation. However this algorithm, called `AmplitudeEstimation `__ in `Qiskit Algorithms `__, requires large circuits and is computationally expensive. Therefore, other variants of QAE have been proposed, which we will showcase in this tutorial for a simple example." -msgstr "" +msgstr "donde :math:`\\mathcal{S}_0` y :math:`\\mathcal{S}_{\\Psi_1}` son reflexiones sobre los estados :math:`|0\\rangle` y :math:`|\\Psi_1\\rangle`, respectivamente, y la estimación de fase. Sin embargo, este algoritmo, llamado `AmplitudeEstimation `__ en `Qiskit Algorithms `__, requiere circuitos grandes y es computacionalmente costoso. Por lo tanto, se han propuesto otras variantes de QAE, que mostraremos en este tutorial para un ejemplo simple." #: ../../tutorials/00_amplitude_estimation.ipynb:35 msgid "In our example, :math:`\\mathcal{A}` describes a Bernoulli random variable with (assumed to be unknown) success probability :math:`p`:" @@ -92,11 +92,11 @@ msgstr "Ahora podemos definir circuitos para :math:`\\mathcal{A}` y :math:`\\mat #: ../../tutorials/00_amplitude_estimation.ipynb:148 msgid "Amplitude Estimation workflow" -msgstr "" +msgstr "Flujo de Trabajo de Estimación de Amplitud" #: ../../tutorials/00_amplitude_estimation.ipynb:159 msgid "Qiskit Algorithms implements several QAE algorithms that all derive from the `AmplitudeEstimator `__ interface. In the initializer we specify algorithm specific settings and the ``estimate`` method, which does all the work, takes an `EstimationProblem `__ as input and returns an `AmplitudeEstimationResult `__ object. Since all QAE variants follow the same interface, we can use them all to solve the same problem instance." -msgstr "" +msgstr "Qiskit Algorithms implementa varios algoritmos QAE que se derivan de la interfaz `AmplitudeEstimator `__. En el inicializador especificamos la configuración específica del algoritmo y el método de ``estimate`` que hace todo el trabajo, toma un `EstimationProblem `__ como entrada y devuelve un objeto `AmplitudeEstimationResult `__. Dado que todas las variantes de QAE siguen la misma interfaz, podemos usarlas todas para resolver la misma instancia de problema." #: ../../tutorials/00_amplitude_estimation.ipynb:162 msgid "Next, we'll run all different QAE algorithms. To do so, we first define the estimation problem which will contain the :math:`\\mathcal{A}` and :math:`\\mathcal{Q}` operators as well as how to identify the :math:`|\\Psi_1\\rangle` state, which in this simple example is just :math:`|1\\rangle`." diff --git a/finance/docs/locale/es_UN/LC_MESSAGES/tutorials/01_portfolio_optimization.po b/finance/docs/locale/es_UN/LC_MESSAGES/tutorials/01_portfolio_optimization.po index 7608b45a986c7..8299da1f335c2 100644 --- a/finance/docs/locale/es_UN/LC_MESSAGES/tutorials/01_portfolio_optimization.po +++ b/finance/docs/locale/es_UN/LC_MESSAGES/tutorials/01_portfolio_optimization.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-14 09:35+0000\n" -"PO-Revision-Date: 2023-11-14 11:57\n" +"PO-Revision-Date: 2024-01-14 18:33\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -74,7 +74,7 @@ msgstr "Suponemos las siguientes simplificaciones: - todos los activos tienen el #: ../../tutorials/01_portfolio_optimization.ipynb:42 msgid "The equality constraint :math:`1^T x = B` is mapped to a penalty term :math:`(1^T x - B)^2` which is scaled by a parameter and subtracted from the objective function. The resulting problem can be mapped to a Hamiltonian whose ground state corresponds to the optimal solution. This notebook shows how to use the Sampling Variational Quantum Eigensolver (``SamplingVQE``) or the Quantum Approximate Optimization Algorithm (``QAOA``) from `Qiskit Algorithms `__ to find the optimal solution for a given set of parameters." -msgstr "" +msgstr "La restricción de igualdad :math:`1^T x = B` se mapea a un término de penalización :math:`(1^T x - B)^2` que se escala mediante un parámetro y se resta de la función objetivo. El problema resultante se puede mapear a un Hamiltoniano cuyo estado fundamental corresponde a la solución óptima. Este cuaderno muestra cómo usar el Solucionador Propio Variacional Cuántico de Muestreo (Sampling Variational Quantum Eigensolver, ``SamplingVQE``) o el Algoritmo Cuántico de Optimización Aproximada (Quantum Approximate Optimization Algorithm, ``QAOA``) de `Qiskit Algorithms `__ para encontrar la solución óptima para un conjunto de parámetros dado." #: ../../tutorials/01_portfolio_optimization.ipynb:45 msgid "Experiments on real quantum hardware for this problem are reported for instance in the following paper: `Improving Variational Quantum Optimization using CVaR. Barkoutsos et al. 2019. `__" diff --git a/finance/docs/locale/es_UN/LC_MESSAGES/tutorials/02_portfolio_diversification.po b/finance/docs/locale/es_UN/LC_MESSAGES/tutorials/02_portfolio_diversification.po index f5b7c89b3e4e6..bcafca5cf8814 100644 --- a/finance/docs/locale/es_UN/LC_MESSAGES/tutorials/02_portfolio_diversification.po +++ b/finance/docs/locale/es_UN/LC_MESSAGES/tutorials/02_portfolio_diversification.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-14 09:35+0000\n" -"PO-Revision-Date: 2023-11-14 11:57\n" +"PO-Revision-Date: 2024-01-14 18:33\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -272,7 +272,7 @@ msgstr "[4] DJ. Berndt and J. Clifford, *Using dynamic time warping to find patt #: ../../tutorials/02_portfolio_diversification.ipynb:190 msgid "[5] `Max-Cut and Traveling Salesman Problem `__" -msgstr "" +msgstr "[5] `Max-Cut y Problema del Vendedor Viajero `__" #: ../../tutorials/02_portfolio_diversification.ipynb:202 msgid "The Implementation" @@ -304,7 +304,7 @@ msgstr "La solución muestra las acciones seleccionadas a través de las estrell #: ../../tutorials/02_portfolio_diversification.ipynb:496 msgid "Quantum Computing solution using Qiskit" -msgstr "" +msgstr "Solución con Computación Cuántica usando Qiskit" #: ../../tutorials/02_portfolio_diversification.ipynb:498 msgid "For the quantum solution, we use Qiskit. We first define a class QuantumOptimizer that encodes the quantum approach to solve the problem and then we instantiate it and solve it. We define the following methods inside the class:" @@ -316,7 +316,7 @@ msgstr "``exact_solution`` : para asegurarnos de que el Hamiltoniano de Ising es #: ../../tutorials/02_portfolio_diversification.ipynb:501 msgid "``sampling_vqe_solution`` : solves the problem :math:`(M)` via the Sampling Variational Quantum Eigensolver (``SamplingVQE``);" -msgstr "" +msgstr "``sampling_vqe_solution`` : resuelve el problema :math:`(M)` a través del Solucionador Propio Variacional Cuántico de Muestreo (Sampling Variational Quantum Eigensolver, ``SamplingVQE``);" #: ../../tutorials/02_portfolio_diversification.ipynb:502 msgid "``qaoa_solution`` : solves the problem :math:`(M)` via a Quantum Approximate Optimization Algorithm (``QAOA``)." diff --git a/finance/docs/locale/es_UN/LC_MESSAGES/tutorials/03_european_call_option_pricing.po b/finance/docs/locale/es_UN/LC_MESSAGES/tutorials/03_european_call_option_pricing.po index 2ebd4784d4842..15e7da34c7bcd 100644 --- a/finance/docs/locale/es_UN/LC_MESSAGES/tutorials/03_european_call_option_pricing.po +++ b/finance/docs/locale/es_UN/LC_MESSAGES/tutorials/03_european_call_option_pricing.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-14 09:35+0000\n" -"PO-Revision-Date: 2023-11-14 11:57\n" +"PO-Revision-Date: 2024-01-14 18:33\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -132,7 +132,7 @@ msgstr "Evaluar el Rendimiento Esperado" #: ../../tutorials/03_european_call_option_pricing.ipynb:576 msgid "Instead of constructing these circuits manually, the Qiskit Finance module offers the ``EuropeanCallPricing`` circuit, which already implements this functionality as a building block." -msgstr "" +msgstr "En lugar de construir estos circuitos manualmente, el módulo Qiskit Finance ofrece el circuito ``EuropeanCallPricing``, que ya implementa esta funcionalidad como un bloque de construcción." #: ../../tutorials/03_european_call_option_pricing.ipynb:660 msgid "Evaluate Delta" diff --git a/machine-learning/docs/locale/es_UN/LC_MESSAGES/getting_started.po b/machine-learning/docs/locale/es_UN/LC_MESSAGES/getting_started.po index 93ee1326b13c3..9e76401bf7a8b 100644 --- a/machine-learning/docs/locale/es_UN/LC_MESSAGES/getting_started.po +++ b/machine-learning/docs/locale/es_UN/LC_MESSAGES/getting_started.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-12-01 12:18+0000\n" -"PO-Revision-Date: 2023-12-01 13:26\n" +"PO-Revision-Date: 2024-01-14 18:32\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -28,7 +28,7 @@ msgstr "Instalación" #: ../../getting_started.rst:10 msgid "Qiskit Machine Learning depends on Qiskit, which has its own `Qiskit Getting Started `__ detailing installation options and its supported environments/platforms. You should refer to that first. Then the information here can be followed which focuses on the additional installation specific to Qiskit Machine Learning." -msgstr "" +msgstr "Qiskit Machine Learning depende de Qiskit, que tiene su propio `Qiskit Primeros Pasos `__ que detalla opciones de instalación y sus entornos/plataformas compatibles. Deberías referirte a eso primero. Luego, se puede seguir la información que está aquí, la cual se centra en la instalación adicional específica de Qiskit Machine Learning." #: ../../getting_started.rst:16 msgid "Qiskit Machine Learning has some functions that have been made optional where the dependent code and/or support program(s) are not (or cannot be) installed by default. Those are PyTorch and Sparse. See :ref:`optional_installs` for more information." @@ -40,15 +40,15 @@ msgstr "Comenzar localmente" #: ../../getting_started.rst:24 msgid "The simplest way to get started is to first follow the `getting started 'Start locally' guide for Qiskit `__" -msgstr "" +msgstr "La forma más sencilla de comenzar es seguir primero la `guía de primeros pasos 'Comenzar localmente' para Qiskit `__" #: ../../getting_started.rst:27 msgid "In your virtual environment, where you installed Qiskit, install Qiskit Machine Learning as follows:" -msgstr "" +msgstr "En tu entorno virtual, donde instalaste Qiskit, instala Qiskit Machine Learning de la siguiente manera:" #: ../../getting_started.rst:35 msgid "As Qiskit Machine Learning depends on Qiskit, you can though simply install it into your environment, as above, and pip will automatically install a compatible version of Qiskit if one is not already installed." -msgstr "" +msgstr "Como Qiskit Machine Learning depende de Qiskit, simplemente puedes instalarlo en tu entorno, como se indicó anteriormente, y pip instalará automáticamente una versión compatible de Qiskit si aún no hay una instalada." #: ../../getting_started.rst msgid "Install from source" diff --git a/machine-learning/docs/locale/es_UN/LC_MESSAGES/index.po b/machine-learning/docs/locale/es_UN/LC_MESSAGES/index.po index fe32b7527f5b0..793a8b507dd0a 100644 --- a/machine-learning/docs/locale/es_UN/LC_MESSAGES/index.po +++ b/machine-learning/docs/locale/es_UN/LC_MESSAGES/index.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-12-01 12:18+0000\n" -"PO-Revision-Date: 2023-12-01 13:26\n" +"PO-Revision-Date: 2024-01-14 18:32\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -56,7 +56,7 @@ msgstr "Qiskit Machine Learning presenta bloques de construcción computacionale #: ../../index.rst:14 msgid "Qiskit Machine Learning provides the :class:`~qiskit_machine_learning.kernels.FidelityQuantumKernel` class class that makes use of the :class:`~qiskit_algorithms.state_fidelities.BaseStateFidelity` algorithm introduced in Qiskit and can be easily used to directly compute kernel matrices for given datasets or can be passed to a Quantum Support Vector Classifier (:class:`~qiskit_machine_learning.algorithms.QSVC`) or Quantum Support Vector Regressor (:class:`~qiskit_machine_learning.algorithms.QSVR`) to quickly start solving classification or regression problems. It also can be used with many other existing kernel-based machine learning algorithms from established classical frameworks." -msgstr "" +msgstr "Qiskit Machine Learning proporciona la clase :class:`~qiskit_machine_learning.kernels.FidelityQuantumKernel` que hace uso del algoritmo :class:`~qiskit_algorithms.state_fidelities.BaseStateFidelity` introducido en Qiskit y se puede usar fácilmente para calcular directamente las matrices del kernel para conjuntos de datos dados o se puede pasar a un Clasificador Cuántico de Vectores de Soporte (Quantum Support Vector Classifier) (:class:`~qiskit_machine_learning.algorithms.QSVC`) o Regresor Cuántico de Vectores de Soporte (Quantum Support Vector Regressor) (:class:`~qiskit_machine_learning.algorithms.QSVR`) para empezar a resolver rápidamente problemas de clasificación o regresión. También se puede utilizar con muchos otros algoritmos de machine learning basados en kernels existentes en frameworks clásicos establecidos." #: ../../index.rst:24 msgid "Qiskit Machine Learning defines a generic interface for neural networks that is implemented by different quantum neural networks. Two core implementations are readily provided, such as the :class:`~qiskit_machine_learning.neural_networks.EstimatorQNN` and the :class:`~qiskit_machine_learning.neural_networks.SamplerQNN`. The :class:`~qiskit_machine_learning.neural_networks.EstimatorQNN` leverages the :class:`~qiskit.primitives.BaseEstimator` primitive from Qiskit and allows users to combine parametrized quantum circuits with quantum mechanical observables. The circuits can be constructed using, for example, building blocks from Qiskit's circuit library, and the QNN's output is given by the expected value of the observable. The :class:`~qiskit_machine_learning.neural_networks.SamplerQNN` leverages another primitive introduced in Qiskit, the :class:`~qiskit.primitives.BaseSampler` primitive. This neural network translates quasi-probabilities of bitstrings estimated by the primitive into a desired output. This translation step can be used to interpret a given bitstring in a particular context, e.g. translating it into a set of classes." @@ -68,7 +68,7 @@ msgstr "Las redes neuronales incluyen la funcionalidad para evaluarlas para una #: ../../index.rst:50 msgid "In addition to the models provided directly in Qiskit Machine Learning, it has the :class:`~qiskit_machine_learning.connectors.TorchConnector`, which allows users to integrate all of our quantum neural networks directly into the `PyTorch `__ open source machine learning library. Thanks to Qiskit Algorithm's gradient algorithms, this includes automatic differentiation - the overall gradients computed by `PyTorch `__ during the backpropagation take into account quantum neural networks, too. The flexible design also allows the building of connectors to other packages in the future." -msgstr "" +msgstr "Además de los modelos provistos directamente en Qiskit Machine Learning, se tiene la clase :class:`~qiskit_machine_learning.connectors.TorchConnector`, que permite a los usuarios integrar todas nuestras redes neuronales cuánticas directamente en la biblioteca de machine learning de código abierto `PyTorch `__. Gracias los algoritmos de gradiente de Qiskit Algorithm, esto incluye la diferenciación automática, los gradientes generales calculados por `PyTorch `__ durante la retropropagación también toman en cuenta las redes neuronales cuánticas. El diseño flexible también permite la construcción de conectores a otros paquetes en el futuro." #: ../../index.rst:64 msgid "Next Steps" diff --git a/machine-learning/docs/locale/es_UN/LC_MESSAGES/migration/01_migration_guide_0.5.po b/machine-learning/docs/locale/es_UN/LC_MESSAGES/migration/01_migration_guide_0.5.po index 1ee3cc8c5f22a..7a5310c721bb2 100644 --- a/machine-learning/docs/locale/es_UN/LC_MESSAGES/migration/01_migration_guide_0.5.po +++ b/machine-learning/docs/locale/es_UN/LC_MESSAGES/migration/01_migration_guide_0.5.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-12-01 12:18+0000\n" -"PO-Revision-Date: 2023-12-01 13:27\n" +"PO-Revision-Date: 2024-01-14 10:45\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -104,11 +104,11 @@ msgstr "Junto con las primitivas, Terra tiene algunos algoritmos de tipo primiti #: ../../migration/01_migration_guide_0.5.rst:72 msgid "Algorithms to calculate the gradient of a quantum circuit. For each core primitive there’s a corresponding base interface that defines quantum circuit gradient. The documentation on gradients is `here `__." -msgstr "" +msgstr "Algoritmos para calcular el gradiente de un circuito cuántico. Para cada núcleo primitivo hay una interfaz base correspondiente que define el gradiente del circuito cuántico. La documentación sobre gradientes está `aquí `__." #: ../../migration/01_migration_guide_0.5.rst:76 msgid "Algorithms that compute the fidelity or “closeness” of pairs of quantum states. Currently, only one implementation is available that requires a sampler primitive and is based on the compute-uncompute method. The documentation is `here `__." -msgstr "" +msgstr "Algoritmos que calculan la fidelidad o “cercanía” de pares de estados cuánticos. Actualmente, solo hay disponible una implementación que requiere una primitiva sampler y se basa en el método de computación-descomputación. La documentación está `aquí `__." #: ../../migration/01_migration_guide_0.5.rst:82 msgid "Both two new algorithms are very similar to the core primitives, they share the same method signatures, so they may be called as high level primitives despite they are not in the primitives package." @@ -156,7 +156,7 @@ msgstr "El nuevo diseño del kernel cuántico se muestra en el siguiente diagram #: ../../migration/01_migration_guide_0.5.rst:-1 msgid "Quantum Kernel Diagram" -msgstr "" +msgstr "Diagrama de Kernel Cuántico" #: ../../migration/01_migration_guide_0.5.rst:116 msgid "The new kernels expose the same interface and the same parameters except the ``quantum_instance`` parameter. This parameter does not have a direct replacement and instead the ``fidelity`` parameter must be used. The backend handling/selection, which was previously done using the ``quantum_instance``, is now taken care of via the Sampler primitive given to the ``fidelity``." @@ -264,7 +264,7 @@ msgstr "El `CircuitQNN `__: The interface for neural networks. This is an abstract class all QNNs inherit from." -msgstr "" +msgstr "`NeuralNetwork `__: La interfaz para redes neuronales. Esta es una clase abstracta de la que heredan todas las QNN." #: ../../tutorials/01_neural_networks.ipynb:72 msgid "`EstimatorQNN `__: A network based on the evaluation of quantum mechanical observables." -msgstr "" +msgstr "`EstimatorQNN `__: Una red basada en la evaluación de observables mecánicos cuánticos." #: ../../tutorials/01_neural_networks.ipynb:73 msgid "`SamplerQNN `__: A network based on the samples resulting from measuring a quantum circuit." -msgstr "" +msgstr "`SamplerQNN `__: Una red basada en las muestras resultantes de medir un circuito cuántico." #: ../../tutorials/01_neural_networks.ipynb:75 msgid "These implementations are based on the `qiskit primitives `__. The primitives are the entry point to run QNNs on either a simulator or real quantum hardware. Each implementation, ``EstimatorQNN`` and ``SamplerQNN``, takes in an optional instance of its corresponding primitive, which can be any subclass of ``BaseEstimator`` and ``BaseSampler``, respectively." @@ -136,7 +136,7 @@ msgstr "La clase ``NeuralNetwork`` es la interfaz para todas las QNNs disponible #: ../../tutorials/01_neural_networks.ipynb:81 msgid "It's important to note that ``NeuralNetwork``\\ s are \"stateless\". They do not contain any training capabilities (these are pushed to the actual algorithms or applications: `classifiers `__, `regressors `__, etc), nor do they store the values for trainable weights." -msgstr "" +msgstr "Es importante tener en cuenta que las ``NeuralNetwork``\\ s son \"sin estado\". No contienen ninguna capacidad de entrenamiento (estas se envían a los algoritmos o aplicaciones reales: `classifiers `__, `regressors `__, etc), ni almacenan los valores de los pesos entrenables." #: ../../tutorials/01_neural_networks.ipynb:94 msgid "Let's now look into specific examples for the two ``NeuralNetwork`` implementations. But first, let's set the algorithmic seed to ensure that the results don't change between runs." diff --git a/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/02_neural_network_classifier_and_regressor.po b/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/02_neural_network_classifier_and_regressor.po index 9bfe6494057e1..8b29dde189b12 100644 --- a/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/02_neural_network_classifier_and_regressor.po +++ b/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/02_neural_network_classifier_and_regressor.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-12-01 12:18+0000\n" -"PO-Revision-Date: 2023-12-01 13:26\n" +"PO-Revision-Date: 2024-01-14 12:05\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -72,7 +72,7 @@ msgstr "Preparamos un conjunto de datos de clasificación simple para ilustrar l #: ../../tutorials/02_neural_network_classifier_and_regressor.ipynb:107 msgid "First we show how an ``EstimatorQNN`` can be used for classification within a ``NeuralNetworkClassifier``. In this context, the ``EstimatorQNN`` is expected to return one-dimensional output in :math:`[-1, +1]`. This only works for binary classification and we assign the two classes to :math:`\\{-1, +1\\}`. To simplify the composition of parameterized quantum circuit from a feature map and an ansatz we can use the ``QNNCircuit`` class." -msgstr "" +msgstr "Primero mostramos cómo se puede usar un ``EstimatorQNN`` para la clasificación dentro de una ``NeuralNetworkClassifier``. En este contexto, se espera que el ``EstimatorQNN`` devuelva una salida unidimensional en :math:`[-1, +1]`. Esto solo funciona para la clasificación binaria y asignamos las dos clases a :math:`\\{-1, +1\\}`. Para simplificar la composición de un circuito cuántico parametrizado a partir de un mapa de características y un ansatz, podemos utilizar la clase ``QNNCircuit``." #: ../../tutorials/02_neural_network_classifier_and_regressor.ipynb:168 msgid "Create a quantum neural network" @@ -88,7 +88,7 @@ msgstr "Ahora, cuando el modelo está entrenado, podemos explorar los pesos de l #: ../../tutorials/02_neural_network_classifier_and_regressor.ipynb:406 msgid "Next we show how a ``SamplerQNN`` can be used for classification within a ``NeuralNetworkClassifier``. In this context, the ``SamplerQNN`` is expected to return :math:`d`-dimensional probability vector as output, where :math:`d` denotes the number of classes. The underlying ``Sampler`` primitive returns quasi-distributions of bit strings and we just need to define a mapping from the measured bitstrings to the different classes. For binary classification we use the parity mapping. Again we can use the ``QNNCircuit`` class to set up a parameterized quantum circuit from a feature map and ansatz of our choice." -msgstr "" +msgstr "A continuación mostramos cómo se puede usar una ``SamplerQNN`` para la clasificación dentro de un ``NeuralNetworkClassifier``. En este contexto, se espera que ``SamplerQNN`` devuelva un vector de probabilidad de dimensión :math:`d` como salida, donde :math:`d` denota el número de clases. La primitiva ``Sampler`` subyacente devuelve cuasi-distribuciones de cadenas de bits y solo necesitamos definir un mapeo de las cadenas de bits medidas a las diferentes clases. Para la clasificación binaria usamos el mapeo de paridad. Nuevamente podemos usar la clase ``QNNCircuit`` para configurar un circuito cuántico parametrizado a partir de un mapa de características y un ansatz de nuestra elección." #: ../../tutorials/02_neural_network_classifier_and_regressor.ipynb:597 msgid "Again, once the model is trained we can take a look at the weights. As we set ``reps=1`` explicitly in our ansatz, we can see less parameters than in the previous model." diff --git a/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/03_quantum_kernel.po b/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/03_quantum_kernel.po index 47bf0d1c9818e..75e7e5450fc0c 100644 --- a/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/03_quantum_kernel.po +++ b/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/03_quantum_kernel.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-12-01 12:18+0000\n" -"PO-Revision-Date: 2023-12-01 13:26\n" +"PO-Revision-Date: 2024-01-14 12:05\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -128,7 +128,7 @@ msgstr "donde \\* :math:`K_{ij}` es la matriz del kernel \\* :math:`\\vec{x}_i, #: ../../tutorials/03_quantum_kernel.ipynb:72 msgid "Quantum kernels can be plugged into common classical kernel learning algorithms such as SVMs or clustering algorithms, as you will see in the examples below. They can also be leveraged in new quantum kernel methods like `QSVC `__ class provided by ``qiskit-machine-learning`` which is explored in this tutorial, and other methods as shown in later tutorials on `Pegasos QSVC <07_pegasos_qsvc.ipynb>`__ and `Quantum Kernel Training <08_quantum_kernel_trainer.ipynb>`__." -msgstr "" +msgstr "Los kernels cuánticos se pueden conectar a algoritmos de aprendizaje de kernel clásicos comunes, como SVM o algoritmos de agrupamiento (clustering), como verás en los ejemplos a continuación. También se pueden aprovechar en nuevos métodos de kernel cuánticos como la clase `QSVC `__ proporcionada por ``qiskit-machine-learning`` que se explora en este tutorial y otros métodos, como se muestra en tutoriales posteriores sobre `Pegasos QSVC <07_pegasos_qsvc.ipynb>`__ y `Quantum Kernel Training <08_quantum_kernel_trainer.ipynb>`__." #: ../../tutorials/03_quantum_kernel.ipynb:77 msgid "Before introducing any example, we set up the global seed to ensure reproducibility:" @@ -172,15 +172,15 @@ msgstr "El siguiente paso es crear una instancia del kernel cuántico que ayude #: ../../tutorials/03_quantum_kernel.ipynb:261 msgid "We use the `FidelityQuantumKernel `__ class, and pass two input arguments to its constructor:" -msgstr "" +msgstr "Usamos la clase `FidelityQuantumKernel `__, y pasamos dos argumentos de entrada a su constructor:" #: ../../tutorials/03_quantum_kernel.ipynb:263 msgid "``feature_map``: in this case, a two-qubit `ZZFeatureMap `__." -msgstr "" +msgstr "``feature_map``: en este caso, un `ZZFeatureMap `__ de dos qubits." #: ../../tutorials/03_quantum_kernel.ipynb:265 msgid "``fidelity``: in this case, the `ComputeUncompute `__ fidelity subroutine that leverages the `Sampler `__ primitive." -msgstr "" +msgstr "``fidelity``: en este caso, la subrutina de fidelidad `ComputeUncompute `__ que aprovecha la primitiva `Sampler `__." #: ../../tutorials/03_quantum_kernel.ipynb:267 msgid "**NOTE:** If you don't pass a ``Sampler`` or ``Fidelity`` instance, then the instances of the reference ``Sampler`` and ``ComputeUncompute`` classes (found in ``qiskit.primitives``) will be created by default." @@ -192,16 +192,16 @@ msgstr "2.3. Clasificación con SVC" #: ../../tutorials/03_quantum_kernel.ipynb:302 msgid "The quantum kernel can now be plugged into classical kernel methods, such as the `SVC `__ algorithm from ``scikit-learn``. This algorithm allows us to define a `custom kernel `__ in two ways:" -msgstr "" +msgstr "El kernel cuántico ahora se puede conectar a métodos de kernel clásicos, como el algoritmo `SVC `__ de ``scikit-learn``. Este algoritmo nos permite definir un `kernel personalizado `__ de dos maneras:" #: ../../tutorials/03_quantum_kernel.ipynb:304 #: ../../tutorials/03_quantum_kernel.ipynb:728 msgid "by providing the kernel as a **callable function**" -msgstr "" +msgstr "proporcionando el kernel como una **función invocable**" #: ../../tutorials/03_quantum_kernel.ipynb:305 msgid "by precomputing the **kernel matrix**" -msgstr "" +msgstr "precalculando la **matriz del kernel**" #: ../../tutorials/03_quantum_kernel.ipynb:317 msgid "Kernel as a callable function" @@ -281,11 +281,11 @@ msgstr "3.3. Agrupamiento (Clustering) con el Modelo de Agrupamiento Espectral" #: ../../tutorials/03_quantum_kernel.ipynb:726 msgid "The ``scikit-learn`` spectral clustering algorithm allows us to define a custom kernel in two ways (just like ``SVC``):" -msgstr "" +msgstr "El algoritmo de agrupamiento espectral de ``scikit-learn`` nos permite definir un kernel personalizado de dos maneras (al igual que ``SVC``):" #: ../../tutorials/03_quantum_kernel.ipynb:729 msgid "by precomputing the **kernel matrix**." -msgstr "" +msgstr "precalculando la **matriz del kernel**." #: ../../tutorials/03_quantum_kernel.ipynb:731 msgid "With the current ``FidelityQuantumKernel`` class in ``qiskit-machine-learning``, we can only use the latter option, so we precompute the kernel matrix by calling ``evaluate`` and visualize it as follows:" diff --git a/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/04_torch_qgan.po b/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/04_torch_qgan.po index 4371bb1038f40..aeb0f9c7b27b9 100644 --- a/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/04_torch_qgan.po +++ b/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/04_torch_qgan.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-12-01 12:18+0000\n" -"PO-Revision-Date: 2023-12-01 13:27\n" +"PO-Revision-Date: 2024-01-14 12:05\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -52,7 +52,7 @@ msgstr "`Definiciones de las Redes Neuronales <#3.-Definiciones-de-las-Redes-Neu #: ../../tutorials/04_torch_qgan.ipynb:21 msgid "`Setting up the Training Loop <#4.-Setting-up-the-Training-Loop>`__" -msgstr "" +msgstr "`Configuración del Ciclo de Entrenamiento <#4.-Configuracion-del-Ciclo-de-Entrenamiento>`__" #: ../../tutorials/04_torch_qgan.ipynb:22 msgid "`Model Training <#5.-Model-Training>`__" @@ -112,7 +112,7 @@ msgstr "Para obtener más detalles, consulta `Quantum Generative Adversarial Net #: ../../tutorials/04_torch_qgan.ipynb:51 msgid "For an example of how to use a trained qGAN in an application, the pricing of financial derivatives, please see the `Option Pricing with qGANs `__ tutorial." -msgstr "" +msgstr "Para un ejemplo de cómo utilizar una qGAN entrenada en una aplicación, la fijación de precios de derivados financieros, consulta el tutorial `Fijación de Precios de Opciones con qGANs `__." #: ../../tutorials/04_torch_qgan.ipynb:54 msgid "2. Data and Representation" diff --git a/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/05_torch_connector.po b/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/05_torch_connector.po index b2223b2bebf2d..736debaa90faa 100644 --- a/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/05_torch_connector.po +++ b/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/05_torch_connector.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-12-01 12:18+0000\n" -"PO-Revision-Date: 2023-12-01 13:26\n" +"PO-Revision-Date: 2024-01-14 12:05\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -28,7 +28,7 @@ msgstr "Conector Torch y QNNs Híbridas" #: ../../tutorials/05_torch_connector.ipynb:11 msgid "This tutorial introduces the ``TorchConnector`` class, and demonstrates how it allows for a natural integration of any ``NeuralNetwork`` from Qiskit Machine Learning into a PyTorch workflow. ``TorchConnector`` takes a ``NeuralNetwork`` and makes it available as a PyTorch ``Module``. The resulting module can be seamlessly incorporated into PyTorch classical architectures and trained jointly without additional considerations, enabling the development and testing of novel **hybrid quantum-classical** machine learning architectures." -msgstr "" +msgstr "Este tutorial presenta la clase ``TorchConnector`` y demuestra cómo permite una integración natural de cualquier ``NeuralNetwork`` de Qiskit Machine Learning en un flujo de trabajo PyTorch. ``TorchConnector`` toma una ``NeuralNetwork`` y la pone a disposición como un ``Module`` de PyTorch. El módulo resultante se puede incorporar a la perfección a las arquitecturas clásicas de PyTorch y se puede entrenar de forma conjunta sin consideraciones adicionales, permitiendo el desarrollo y pruebas de arquitecturas de machine learning **híbridas cuánticas-clásicas** novedosas." #: ../../tutorials/05_torch_connector.ipynb:15 msgid "Content:" @@ -61,7 +61,7 @@ msgstr "`Regresión <#2.-Regression>`__" #: ../../tutorials/05_torch_connector.ipynb:28 msgid "Regression with PyTorch and ``EstimatorQNN``" -msgstr "" +msgstr "Regresión con PyTorch y ``EstimatorQNN``" #: ../../tutorials/05_torch_connector.ipynb:30 msgid "`Part 2: MNIST Classification, Hybrid QNNs <#Part-2:-MNIST-Classification,-Hybrid-QNNs>`__" @@ -130,7 +130,7 @@ msgstr "En particular, debemos asegurarnos de que estamos devolviendo un arreglo #: ../../tutorials/05_torch_connector.ipynb:530 msgid "**⚠️ Attention:** If we define a custom interpret function ( in the example: ``parity``), we must remember to explicitly provide the desired output shape ( in the example: ``2``). For more info on the initial parameter setup for ``SamplerQNN``, please check out the `official qiskit documentation `__." -msgstr "" +msgstr "**⚠️ Atención:** Si definimos una función de interpretación personalizada (en el ejemplo: ``parity``), debemos recordar proporcionar explícitamente la forma de salida deseada (en el ejemplo: ``2``). Para obtener más información sobre la configuración inicial de parámetros para ``SamplerQNN``, consulta la `documentación oficial de qiskit `__." #: ../../tutorials/05_torch_connector.ipynb:601 #: ../../tutorials/05_torch_connector.ipynb:891 diff --git a/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/08_quantum_kernel_trainer.po b/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/08_quantum_kernel_trainer.po index b59f83ea4770e..865a92d28288f 100644 --- a/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/08_quantum_kernel_trainer.po +++ b/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/08_quantum_kernel_trainer.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-12-01 12:18+0000\n" -"PO-Revision-Date: 2023-12-01 13:27\n" +"PO-Revision-Date: 2024-01-14 12:05\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -64,7 +64,7 @@ msgstr "Preparar el Conjunto de Datos" #: ../../tutorials/08_quantum_kernel_trainer.ipynb:99 msgid "In this guide, we will use Qiskit Machine Learning's ``ad_hoc.py`` dataset to demonstrate the kernel training process. See the documentation `here `__." -msgstr "" +msgstr "En esta guía, utilizaremos el conjunto de datos ``ad_hoc.py`` de Qiskit Machine Learning para demostrar el proceso de entrenamiento del kernel. Consulta la documentación `aquí `__." #: ../../tutorials/08_quantum_kernel_trainer.ipynb:187 msgid "Define the Quantum Feature Map" @@ -132,7 +132,7 @@ msgstr "Ajustar y Probar el Modelo" #: ../../tutorials/08_quantum_kernel_trainer.ipynb:384 msgid "We can pass the trained quantum kernel to a machine learning model, then fit the model and test on new data. Here, we will use Qiskit Machine Learning's ``QSVC`` for classification." -msgstr "" +msgstr "Podemos pasar el kernel cuántico entrenado a un modelo de machine learning, luego ajustar el modelo y probar con nuevos datos. Aquí, usaremos el ``QSVC`` de Qiskit Machine Learning para la clasificación." #: ../../tutorials/08_quantum_kernel_trainer.ipynb:441 msgid "Visualize the Kernel Training Process" diff --git a/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/09_saving_and_loading_models.po b/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/09_saving_and_loading_models.po index 5ab08311ace84..fae26de6af8bc 100644 --- a/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/09_saving_and_loading_models.po +++ b/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/09_saving_and_loading_models.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-12-01 12:18+0000\n" -"PO-Revision-Date: 2023-12-01 13:27\n" +"PO-Revision-Date: 2024-01-14 12:05\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -193,7 +193,7 @@ msgstr "4. Modelos híbridos de PyTorch" #: ../../tutorials/09_saving_and_loading_models.ipynb:974 msgid "To save and load hybrid models, when using the TorchConnector, follow the PyTorch recommendations of saving and loading the models. For more details please refer to the `PyTorch Connector tutorial <05_torch_connector.ipynb>`__ where a short snippet shows how to do it." -msgstr "" +msgstr "Para guardar y cargar modelos híbridos, al usar TorchConnector, sigue las recomendaciones de PyTorch para guardar y cargar los modelos. Para obtener más detalles, consulta el `tutorial del Conector de PyTorch <05_torch_connector.ipynb>`__ donde un breve fragmento de código muestra cómo hacerlo." #: ../../tutorials/09_saving_and_loading_models.ipynb:976 msgid "Take a look at this pseudo-like code to get the idea:" diff --git a/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/10_effective_dimension.po b/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/10_effective_dimension.po index 666622357c64d..f884161927433 100644 --- a/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/10_effective_dimension.po +++ b/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/10_effective_dimension.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-12-01 12:18+0000\n" -"PO-Revision-Date: 2023-12-01 13:27\n" +"PO-Revision-Date: 2024-01-14 18:33\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -96,7 +96,7 @@ msgstr "3.1 Definir la QNN" #: ../../tutorials/10_effective_dimension.ipynb:111 msgid "The first step to create a ``SamplerQNN`` is to define a parametrized feature map and ansatz. In this toy example, we will use 3 qubits and the ``QNNCircuit`` class to simplify the composition of a feature map and an ansatz circuit. The resulting circuit is then used in the ``SamplerQNN`` class." -msgstr "" +msgstr "El primer paso para crear un ``SamplerQNN`` es definir un mapa de características parametrizado y un ansatz. En este ejemplo de juguete, usaremos 3 qubits y la clase ``QNNCircuit`` para simplificar la composición de un mapa de características y un circuito ansatz. El circuito resultante luego se utiliza en la clase ``SamplerQNN``." #: ../../tutorials/10_effective_dimension.ipynb:176 msgid "The parametrized circuit can then be sent together with an optional interpret map (parity in this case) to the ``SamplerQNN`` constructor." diff --git a/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/11_quantum_convolutional_neural_networks.po b/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/11_quantum_convolutional_neural_networks.po index f03206b80f39d..2da04db28a657 100644 --- a/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/11_quantum_convolutional_neural_networks.po +++ b/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/11_quantum_convolutional_neural_networks.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-12-01 12:18+0000\n" -"PO-Revision-Date: 2023-12-01 13:27\n" +"PO-Revision-Date: 2024-01-14 12:05\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -372,7 +372,7 @@ msgstr "En este ejemplo, usaremos el optimizador COBYLA para entrenar nuestro cl #: ../../tutorials/11_quantum_convolutional_neural_networks.ipynb:925 msgid "We then place the the callback function, optimizer and operator of our QCNN created above into Qiskit Machine Learning's built in Neural Network Classifier, which we can then use to train our model." -msgstr "" +msgstr "Luego colocamos la función de devolución de llamada, el optimizador y el operador de nuestra QCNN creada anteriormente en el Clasificador de Redes Neuronales integrado de Qiskit Machine Learning, que luego podemos usar para entrenar nuestro modelo." #: ../../tutorials/11_quantum_convolutional_neural_networks.ipynb:927 msgid "Since model training may take a long time we have already pre-trained the model for some iterations and saved the pre-trained weights. We'll continue training from that point by setting ``initial_point`` to a vector of pre-trained weights." diff --git a/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/12_quantum_autoencoder.po b/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/12_quantum_autoencoder.po index 4543edf884ecc..007380fc4c5f1 100644 --- a/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/12_quantum_autoencoder.po +++ b/machine-learning/docs/locale/es_UN/LC_MESSAGES/tutorials/12_quantum_autoencoder.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-12-01 12:18+0000\n" -"PO-Revision-Date: 2023-12-01 13:27\n" +"PO-Revision-Date: 2024-01-14 12:05\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -397,7 +397,7 @@ msgstr "Para este tutorial, crearemos un Autocodificador Cuántico para un conju #: ../../tutorials/12_quantum_autoencoder.ipynb:955 msgid "Each image contains :math:`32` pixels of which can be encoded into :math:`5` qubits by Amplitude Encoding. This can be done using Qiskit Machine Learning's ``RawFeatureVector`` feature map." -msgstr "" +msgstr "Cada imagen contiene :math:`32` pixeles de los cuales se pueden codificar en :math:`5` qubits mediante la Codificación de Amplitud (Amplitude Encoding). Esto se puede hacer usando el mapa de características ``RawFeatureVector`` de Qiskit Machine Learning." #: ../../tutorials/12_quantum_autoencoder.ipynb:1060 msgid "After encoding our image into :math:`5` qubits, we begin to train our Quantum Autoencoder to compress this state into :math:`3` qubits." @@ -417,7 +417,7 @@ msgstr "Nuevamente, podemos ver la prueba swap que se realiza en los qubits :mat #: ../../tutorials/12_quantum_autoencoder.ipynb:1136 msgid "We build our cost function, based on the swap test between the reference and trash space for the digit dataset. To do this, we again use Qiskit Machine Learning's CircuitQNN network and use the same interpret function as we are measuring the probability of getting the final qubit in the :math:`|1\\rangle` state." -msgstr "" +msgstr "Construimos nuestra función de costo, basada en la prueba swap entre los espacios de referencia y basura para el conjunto de datos de dígitos. Para hacer esto, nuevamente usamos la red CircuitQNN de Qiskit Machine Learning y usamos la misma función de interpretación ya que estamos midiendo la probabilidad de obtener el qubit final en el estado :math:`|1\\rangle`." #: ../../tutorials/12_quantum_autoencoder.ipynb:1170 msgid "Since model training may take a long time we have already pre-trained the model for some iterations and saved the pre-trained weights. We'll continue training from that point by setting ``initial_point`` to a vector of pre-trained weights." diff --git a/nature/docs/locale/es_UN/LC_MESSAGES/getting_started.po b/nature/docs/locale/es_UN/LC_MESSAGES/getting_started.po index 2a9fe097025e6..0fbf4a4126fda 100644 --- a/nature/docs/locale/es_UN/LC_MESSAGES/getting_started.po +++ b/nature/docs/locale/es_UN/LC_MESSAGES/getting_started.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-28 15:28+0000\n" -"PO-Revision-Date: 2023-11-29 13:37\n" +"PO-Revision-Date: 2024-01-14 19:42\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -28,7 +28,7 @@ msgstr "Instalación" #: ../../getting_started.rst:10 msgid "Qiskit Nature depends on Qiskit, which has its own `Qiskit Getting Started `__ detailing the installation options and its supported environments/platforms. You should refer to that first. Then the information here can be followed which focuses on the additional installation specific to Qiskit Nature." -msgstr "" +msgstr "Qiskit Nature depende de Qiskit, que tiene su propio `Qiskit Primeros Pasos `__ que detalla las opciones de instalación y sus entornos/plataformas compatibles. Deberías referirte a eso primero. Luego, se puede seguir la información que está aquí, la cual se centra en la instalación adicional específica de Qiskit Nature." #: ../../getting_started.rst:16 msgid "Qiskit Nature has some functions that have been made optional where the dependent code and/or support program(s) are not (or cannot be) installed by default. These include, for example, classical library/programs for molecular problems. See :ref:`optional_installs` for more information." @@ -40,15 +40,15 @@ msgstr "Comenzar localmente" #: ../../getting_started.rst:25 msgid "The simplest way to get started is to first follow the `getting started 'Start locally' guide for Qiskit `__" -msgstr "" +msgstr "La forma más sencilla de comenzar es seguir primero la `guía de primeros pasos 'Comenzar localmente' para Qiskit `__" #: ../../getting_started.rst:28 msgid "In your virtual environment, where you installed Qiskit, install Qiskit Nature as follows:" -msgstr "" +msgstr "En tu entorno virtual, donde instalaste Qiskit, instala Qiskit Nature de la siguiente manera:" #: ../../getting_started.rst:36 msgid "As Qiskit Nature depends on Qiskit, you can though simply install it into your environment, as above, and pip will automatically install a compatible version of Qiskit if one is not already installed." -msgstr "" +msgstr "Como Qiskit Nature depende de Qiskit, simplemente puedes instalarlo en tu entorno, como se indicó anteriormente, y pip instalará automáticamente una versión compatible de Qiskit si aún no hay una instalada." #: ../../getting_started.rst msgid "Install from source" @@ -100,15 +100,15 @@ msgstr "Consulta la `Instalación del controlador <./apidocs/qiskit_nature.secon #: ../../getting_started.rst:104 msgid "The drivers only provide a very limited set of capabilities of the underlying classical codes. While this is useful for getting started and testing purposes, a better experience can be had in the reversed order of responsibility. That is, in a setup where the classical code runs the Qiskit Nature components. Such an integration currently exists for the following packages:" -msgstr "" +msgstr "Los controladores sólo proporcionan un conjunto muy limitado de capacidades de los códigos clásicos subyacentes. Si bien esto es útil para comenzar y realizar pruebas, se puede obtener una mejor experiencia en el orden inverso de responsabilidad. Es decir, en una configuración donde el código clásico ejecuta los componentes de Qiskit Nature. Actualmente, existe una integración de este tipo para los siguientes paquetes:" #: ../../getting_started.rst:109 msgid "PySCF via `qiskit-nature-pyscf `_" -msgstr "" +msgstr "PySCF a través de `qiskit-nature-pyscf `_" #: ../../getting_started.rst:111 msgid "If you are interested in using Psi4, we are actively looking for help to get started on a similar integration in `qiskit-nature-psi4 `_" -msgstr "" +msgstr "Si estás interesado en utilizar Psi4, estamos buscando activamente ayuda para comenzar con una integración similar en `qiskit-nature-psi4 `_" #: ../../getting_started.rst:113 msgid "Additionally, you may find the following optional dependencies useful:" @@ -128,7 +128,7 @@ msgstr "¿Listo para empezar?..." #: ../../getting_started.rst:123 msgid "Now that Qiskit Nature is installed, let's try a chemistry application experiment using the :class:`~qiskit_algorithms.VQE` (Variational Quantum Eigensolver) algorithm to compute the ground-state (minimum) energy of a molecule." -msgstr "" +msgstr "Ahora que Qiskit Nature está instalado, probemos un experimento de aplicación de química usando el algoritmo :class:`~qiskit_algorithms.VQE` (Variational Quantum Eigensolver, Solucionador Propio Variacional Cuántico) para calcular la energía del estado fundamental (mínimo) de una molécula." #: ../../getting_started.rst:213 msgid "The program above computes the ground state energy of molecular Hydrogen, H2, where the two atoms are configured to be at a distance of 0.735 angstroms. The molecular input specification is processed by the PySCF driver. This driver produces an :class:`~qiskit_nature.second_q.problems.ElectronicStructureProblem` which gathers all the problem information required by Qiskit Nature. The second-quantized operators contained in that problem can be mapped to qubit operators with a :class:`~qiskit_nature.second_q.mappers.QubitMapper`. Here, we chose the :class:`~qiskit_nature.second_q.mappers.ParityMapper` which automatically removes 2 qubits due to inherit symmetries when the `num_particles` are provided to it; a reduction in complexity that is particularly advantageous for NISQ computers." @@ -136,9 +136,9 @@ msgstr "El programa anterior calcula la energía del estado fundamental del Hidr #: ../../getting_started.rst:226 msgid "For actually finding the ground state solution, the Variational Quantum Eigensolver (:class:`~qiskit_algorithms.VQE`) algorithm is used. Its main three components are the estimator primitive (:class:`~qiskit.primitives.Estimator`), wavefunction ansatz (:class:`~qiskit_nature.second_q.circuit.library.UCCSD`), and optimizer (:class:`~qiskit_algorithms.optimizers.L_BFGS_B`). The :class:`~qiskit_nature.second_q.circuit.library.UCCSD` component is the only one provided directly by Qiskit Nature and it is usually paired with the :class:`~qiskit_nature.second_q.circuit.library.HartreeFock` initial state and an all-zero initial point for the optimizer." -msgstr "" +msgstr "Para encontrar realmente la solución del estado fundamental, se utiliza el algoritmo Solucionador Propio Variacional Cuántico (Variational Quantum Eigensolver, :class:`~qiskit.algorithms.minimum_eigensolvers.VQE`). Sus tres componentes principales son la primitiva estimator (:class:`~qiskit.primitives.Estimator`), el ansatz de función de onda (:class:`~qiskit_nature.second_q.circuit.library.UCCSD`) y el optimizador (:class:`~qiskit_algorithms.optimizers.L_BFGS_B`). El componente :class:`~qiskit_nature.second_q.circuit.library.UCCSD` es el único proporcionado directamente por Qiskit Nature y generalmente se combina con el estado inicial de :class:`~qiskit_nature.second_q.circuit.library.HartreeFock` y un punto inicial todo en cero para el optimizador." #: ../../getting_started.rst:237 msgid "The entire problem is then solved using a :class:`~qiskit_nature.second_q.algorithms.GroundStateEigensolver` which wraps both, the :class:`~qiskit_nature.second_q.mappers.ParityMapper` and :class:`~qiskit_algorithms.VQE`. Since an :class:`~qiskit_nature.second_q.problems.ElectronicStructureProblem` is provided to it (which was the output of the :class:`~qiskit_nature.second_q.drivers.PySCFDriver`) it also returns an :class:`~qiskit_nature.second_q.problems.ElectronicStructureResult`." -msgstr "" +msgstr "Luego, todo el problema se resuelve utilizando un :class:`~qiskit_nature.second_q.algorithms.GroundStateEigensolver` que encapsula tanto el :class:`~qiskit_nature.second_q.mappers.ParityMapper` como el :class:`~qiskit_algorithms.VQE`. Dado que se le proporciona un :class:`~qiskit_nature.second_q.problems.ElectronicStructureProblem` (que fue el resultado del :class:`~qiskit_nature.second_q.drivers.PySCFDriver`), también devuelve un :class:`~qiskit_nature.second_q.problems.ElectronicStructureResult`." diff --git a/nature/docs/locale/es_UN/LC_MESSAGES/howtos/adapt_vqe.po b/nature/docs/locale/es_UN/LC_MESSAGES/howtos/adapt_vqe.po index 3d2bc52138930..919afeca230f0 100644 --- a/nature/docs/locale/es_UN/LC_MESSAGES/howtos/adapt_vqe.po +++ b/nature/docs/locale/es_UN/LC_MESSAGES/howtos/adapt_vqe.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-28 15:28+0000\n" -"PO-Revision-Date: 2023-11-29 13:38\n" +"PO-Revision-Date: 2024-01-14 18:33\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -24,7 +24,7 @@ msgstr "Encontrar la energía del estado fundamental usando AdaptVQE" #: ../../howtos/adapt_vqe.rst:4 msgid "This guide outlines how the :class:`~qiskit_algorithms.AdaptVQE` algorithm can be used to find the ground state solutions of natural science problems." -msgstr "" +msgstr "Esta guía describe cómo se puede utilizar el algoritmo :class:`~qiskit_algorithms.AdaptVQE` para encontrar soluciones del estado fundamental de problemas de ciencias naturales." #: ../../howtos/adapt_vqe.rst:8 msgid "We obtain an :class:`~qiskit_nature.second_q.problems.ElectronicStructureProblem` which we want to solve:" @@ -40,11 +40,11 @@ msgstr "Configuramos nuestro ansatz:" #: ../../howtos/adapt_vqe.rst:40 msgid "We setup a :class:`~qiskit_algorithms.VQE`:" -msgstr "" +msgstr "Configuramos un :class:`~qiskit_algorithms.VQE`:" #: ../../howtos/adapt_vqe.rst:51 msgid "We setup the :class:`~qiskit_algorithms.AdaptVQE`:" -msgstr "" +msgstr "Configuramos el :class:`~qiskit_algorithms.AdaptVQE`:" #: ../../howtos/adapt_vqe.rst:59 msgid "We wrap everything in a :class:`~qiskit_nature.second_q.algorithms.GroundStateEigensolver`:" diff --git a/nature/docs/locale/es_UN/LC_MESSAGES/howtos/numpy_eigensolver.po b/nature/docs/locale/es_UN/LC_MESSAGES/howtos/numpy_eigensolver.po index c232df074eab5..a75ac7280b454 100644 --- a/nature/docs/locale/es_UN/LC_MESSAGES/howtos/numpy_eigensolver.po +++ b/nature/docs/locale/es_UN/LC_MESSAGES/howtos/numpy_eigensolver.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-28 15:28+0000\n" -"PO-Revision-Date: 2023-11-29 13:38\n" +"PO-Revision-Date: 2024-01-14 18:33\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -24,7 +24,7 @@ msgstr "Encontrar energías de estado excitado usando el NumPyEigensolver" #: ../../howtos/numpy_eigensolver.rst:6 msgid "In order to ensure a physically meaningful excited states of a hamiltonian are found when using the :class:`~qiskit_algorithms.NumPyEigensolver` one needs to set the :attr:`~qiskit_algorithms.NumPyEigensolver.filter_criterion` attribute of the solver." -msgstr "" +msgstr "Para garantizar que se encuentren estados excitados físicamente significativos de un Hamiltoniano al usar :class:`~qiskit_algorithms.NumPyEigensolver`, es necesario configurar el atributo :attr:`~qiskit_algorithms.NumPyEigensolver.filter_criterion` del solucionador." #: ../../howtos/numpy_eigensolver.rst:11 msgid "Subclasses of :class:`~qiskit_nature.second_q.problems.BaseProblem` in Qiskit Nature provide the :meth:`~qiskit_nature.second_q.problems.BaseProblem.get_default_filter_criterion` method which provides a default implementation of such a filter criterion for commonly encountered cases." @@ -44,7 +44,7 @@ msgstr "Configuramos nuestro :class:`~qiskit_nature.second_q.mappers.QubitMapper #: ../../howtos/numpy_eigensolver.rst:33 msgid "We setup our :class:`~qiskit_algorithms.NumPyEigensolver`:" -msgstr "" +msgstr "Configuramos nuestro :class:`~qiskit_algorithms.NumPyEigensolver`:" #: ../../howtos/numpy_eigensolver.rst:41 msgid "We wrap everything in a :class:`~qiskit_nature.second_q.algorithms.ExcitedStatesEigensolver`:" diff --git a/nature/docs/locale/es_UN/LC_MESSAGES/howtos/numpy_minimum_eigensolver.po b/nature/docs/locale/es_UN/LC_MESSAGES/howtos/numpy_minimum_eigensolver.po index 38da3aeed5177..43aa928efa6d1 100644 --- a/nature/docs/locale/es_UN/LC_MESSAGES/howtos/numpy_minimum_eigensolver.po +++ b/nature/docs/locale/es_UN/LC_MESSAGES/howtos/numpy_minimum_eigensolver.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-28 15:28+0000\n" -"PO-Revision-Date: 2023-11-29 13:38\n" +"PO-Revision-Date: 2024-01-14 18:33\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -24,7 +24,7 @@ msgstr "Encontrar la energía del estado fundamental usando el NumPyMinimumEigen #: ../../howtos/numpy_minimum_eigensolver.rst:6 msgid "In order to ensure a physically meaningful ground state of a hamiltonian is found when using the :class:`~qiskit_algorithms.NumPyMinimumEigensolver` one needs to set the :attr:`~qiskit_algorithms.NumPyMinimumEigensolver.filter_criterion` attribute of the solver." -msgstr "" +msgstr "Para garantizar que se encuentre un estado fundamental físicamente significativo de un Hamiltoniano al usar :class:`~qiskit_algorithms.NumPyMinimumEigensolver`, es necesario configurar el atributo :attr:`~qiskit_algorithms.NumPyMinimumEigensolver.filter_criterion` del solucionador." #: ../../howtos/numpy_minimum_eigensolver.rst:11 msgid "Subclasses of :class:`~qiskit_nature.second_q.problems.BaseProblem` in Qiskit Nature provide the :meth:`~qiskit_nature.second_q.problems.BaseProblem.get_default_filter_criterion` method which provides a default implementation of such a filter criterion for commonly encountered cases." @@ -44,7 +44,7 @@ msgstr "Configuramos nuestro :class:`~qiskit_nature.second_q.mappers.QubitMapper #: ../../howtos/numpy_minimum_eigensolver.rst:33 msgid "We setup our :class:`~qiskit_algorithms.minimum_eigensolvers.NumPyMinimumEigensolver`:" -msgstr "" +msgstr "Configuramos nuestro :class:`~qiskit_algorithms.minimum_eigensolvers.NumPyMinimumEigensolver`:" #: ../../howtos/numpy_minimum_eigensolver.rst:41 msgid "We wrap everything in a :class:`~qiskit_nature.second_q.algorithms.GroundStateEigensolver`:" diff --git a/nature/docs/locale/es_UN/LC_MESSAGES/howtos/vqe_ucc.po b/nature/docs/locale/es_UN/LC_MESSAGES/howtos/vqe_ucc.po index e181910f7fdaa..a4127d30b3682 100644 --- a/nature/docs/locale/es_UN/LC_MESSAGES/howtos/vqe_ucc.po +++ b/nature/docs/locale/es_UN/LC_MESSAGES/howtos/vqe_ucc.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-28 15:28+0000\n" -"PO-Revision-Date: 2023-11-29 13:38\n" +"PO-Revision-Date: 2024-01-14 18:33\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -24,7 +24,7 @@ msgstr "Usar un ansatz similar a UCC con un VQE" #: ../../howtos/vqe_ucc.rst:6 msgid "When using a :class:`~qiskit_nature.second_q.circuit.library.UCC`-style ansatz with a :class:`~qiskit_algorithms.VQE` one needs to pay particular attention to the :attr:`~qiskit_algorithms.VQE.initial_point` attribute which indicates from which set of initial parameters the optimization routine should start. By default, VQE will start from a *random* initial point. In this how to we show how one can set a custom initial point instead (for example to guarantee that one starts from the Hartree-Fock state)." -msgstr "" +msgstr "Cuando se utiliza un ansatz de estilo :class:`~qiskit_nature.second_q.circuit.library.UCC` con un :class:`~qiskit_algorithms.VQE`, se debe prestar especial atención al atributo :attr:`~qiskit_algorithms.VQE.initial_point` que indica a partir de qué conjunto de parámetros iniciales debe comenzar la rutina de optimización. Por defecto, VQE comenzará desde un punto inicial *aleatorio*. En este tutorial, mostramos cómo se puede establecer un punto inicial personalizado (por ejemplo, para garantizar que uno comience desde el estado Hartree-Fock)." #: ../../howtos/vqe_ucc.rst:14 msgid "We obtain an :class:`~qiskit_nature.second_q.problems.ElectronicStructureProblem` which we want to solve:" @@ -40,7 +40,7 @@ msgstr "Configuramos nuestro ansatz:" #: ../../howtos/vqe_ucc.rst:46 msgid "We setup a :class:`~qiskit_algorithms.VQE`:" -msgstr "" +msgstr "Configuramos un :class:`~qiskit_algorithms.VQE`:" #: ../../howtos/vqe_ucc.rst:56 msgid "Now comes the key step: choosing the initial point. Since we picked the :class:`~qiskit_nature.second_q.circuit.library.HartreeFock` initial state before, in order to ensure we start from that, we need to initialize our ``initial_point`` with all-zero parameters. One way to do that is like so:" diff --git a/nature/docs/locale/es_UN/LC_MESSAGES/howtos/vqe_uvcc.po b/nature/docs/locale/es_UN/LC_MESSAGES/howtos/vqe_uvcc.po index 9d0fb8b1e80a7..9bbaca555eab2 100644 --- a/nature/docs/locale/es_UN/LC_MESSAGES/howtos/vqe_uvcc.po +++ b/nature/docs/locale/es_UN/LC_MESSAGES/howtos/vqe_uvcc.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-28 15:28+0000\n" -"PO-Revision-Date: 2023-11-29 13:38\n" +"PO-Revision-Date: 2024-01-14 18:33\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -24,7 +24,7 @@ msgstr "Usar un ansatz similar a UVCC con un VQE" #: ../../howtos/vqe_uvcc.rst:6 msgid "When using a :class:`~qiskit_nature.second_q.circuit.library.UVCC`-style ansatz with a :class:`~qiskit_algorithms.VQE` one needs to pay particular attention to the :attr:`~qiskit_algorithms.VQE.initial_point` attribute which indicates from which set of initial parameters the optimization routine should start. By default, VQE will start from a *random* initial point. In this how to we show how one can set a custom initial point instead (for example to guarantee that one starts from the VSCF state)." -msgstr "" +msgstr "Cuando se utiliza un ansatz de estilo :class:`~qiskit_nature.second_q.circuit.library.UVCC` con un :class:`~qiskit_algorithms.VQE`, se debe prestar especial atención al atributo :attr:`~qiskit_algorithms.VQE.initial_point` que indica a partir de qué conjunto de parámetros iniciales debe comenzar la rutina de optimización. Por defecto, VQE comenzará desde un punto inicial *aleatorio*. En este tutorial, mostramos cómo se puede establecer un punto inicial personalizado (por ejemplo, para garantizar que uno comience desde el estado VSCF)." #: ../../howtos/vqe_uvcc.rst:14 msgid "The basics of this how-to are identical to the UCC-like ansatz how-to (TODO: add link). Thus, here we will simply show how to use the :class:`~qiskit_nature.second_q.algorithms.initial_points.VSCFInitialPoint` like so:" @@ -40,7 +40,7 @@ msgstr "Configuramos nuestro ansatz:" #: ../../howtos/vqe_uvcc.rst:43 msgid "We setup a :class:`~qiskit_algorithms.VQE`:" -msgstr "" +msgstr "Configuramos un :class:`~qiskit_algorithms.VQE`:" #: ../../howtos/vqe_uvcc.rst:53 msgid "Now comes the key step: choosing the initial point. Since we picked the :class:`~qiskit_nature.second_q.circuit.library.VSCF` initial state before, in order to ensure we start from that, we need to initialize our ``initial_point`` with all-zero parameters. One way to do that is like so:" diff --git a/nature/docs/locale/es_UN/LC_MESSAGES/index.po b/nature/docs/locale/es_UN/LC_MESSAGES/index.po index 465244bb756e0..92ad916add6a5 100644 --- a/nature/docs/locale/es_UN/LC_MESSAGES/index.po +++ b/nature/docs/locale/es_UN/LC_MESSAGES/index.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-28 15:28+0000\n" -"PO-Revision-Date: 2023-11-29 13:37\n" +"PO-Revision-Date: 2024-01-14 19:42\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -84,7 +84,7 @@ msgstr "una biblioteca de circuitos cuánticos de ciencias naturales orientada a #: ../../index.rst:22 msgid "natural science specific algorithms and utilities to make the use of algorithms from `Qiskit Algorithms `_ easier" -msgstr "" +msgstr "algoritmos y utilidades específicos de ciencias naturales para facilitar el uso de los algoritmos de `Qiskit Algorithms `_" #: ../../index.rst:24 msgid "and much more" diff --git a/nature/docs/locale/es_UN/LC_MESSAGES/migration/0.5_b_solving_problems.po b/nature/docs/locale/es_UN/LC_MESSAGES/migration/0.5_b_solving_problems.po index dcb2fedd57b13..ab314353c871b 100644 --- a/nature/docs/locale/es_UN/LC_MESSAGES/migration/0.5_b_solving_problems.po +++ b/nature/docs/locale/es_UN/LC_MESSAGES/migration/0.5_b_solving_problems.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-28 15:28+0000\n" -"PO-Revision-Date: 2023-11-29 13:38\n" +"PO-Revision-Date: 2024-01-14 18:33\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -56,7 +56,7 @@ msgstr "``qiskit_nature.mappers``" #: ../../migration/0.5_b_solving_problems.rst:33 msgid "The mappers of Qiskit Nature did **not** receive any API changes (other than potentially requiring certain arguments to be keywords; see also the `“Too many positional arguments” section <./0.5_a_intro.ipynb>`__). However, the entire module ``qiskit_nature.mappers.second_quantization`` has been moved to ``qiskit_nature.second_q.mappers``. So updating your import is all you need to do here." -msgstr "" +msgstr "Los mapeadores de Qiskit Nature **no** recibieron ningún cambio en la API (aparte de requerir potencialmente que ciertos argumentos sean palabras clave; consulta también la sección `“Demasiados argumentos posicionales” <./0.5_a_intro.ipynb>`__). Sin embargo, todo el módulo ``qiskit_nature.mappers.second_quantization`` se ha movido a ``qiskit_nature.second_q.mappers``. Entonces, actualizar tu importación es todo lo que necesitas hacer aquí." #: ../../migration/0.5_b_solving_problems.rst:41 msgid "``qiskit_nature.converters``" diff --git a/nature/docs/locale/es_UN/LC_MESSAGES/migration/index.po b/nature/docs/locale/es_UN/LC_MESSAGES/migration/index.po index 1d12cd3b50149..133e7313150bf 100644 --- a/nature/docs/locale/es_UN/LC_MESSAGES/migration/index.po +++ b/nature/docs/locale/es_UN/LC_MESSAGES/migration/index.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-28 15:28+0000\n" -"PO-Revision-Date: 2023-11-29 13:38\n" +"PO-Revision-Date: 2024-01-14 18:33\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -24,7 +24,7 @@ msgstr "Guías de Migración de Qiskit Nature" #: ../../migration/index.rst:5 msgid "If you are switching over to version 0.7, which has removed all previously deprecated code, simply follow the instructions provided in the sections below." -msgstr "" +msgstr "Si estás cambiando a la versión 0.7, que eliminó todo el código previamente obsoleto, simplemente sigue las instrucciones proporcionadas en las secciones siguientes." #: ../../migration/index.rst:9 msgid "Migrating from 0.5 to 0.6" diff --git a/nature/docs/locale/es_UN/LC_MESSAGES/tutorials/03_ground_state_solvers.po b/nature/docs/locale/es_UN/LC_MESSAGES/tutorials/03_ground_state_solvers.po index 650915764b774..2e7873f5acc43 100644 --- a/nature/docs/locale/es_UN/LC_MESSAGES/tutorials/03_ground_state_solvers.po +++ b/nature/docs/locale/es_UN/LC_MESSAGES/tutorials/03_ground_state_solvers.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-29 13:18+0000\n" -"PO-Revision-Date: 2023-12-01 13:27\n" +"PO-Revision-Date: 2024-01-14 19:42\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -96,7 +96,7 @@ msgstr "Una forma variacional: aquí usamos el ansatz Clúster Acoplado Unitario #: ../../tutorials/03_ground_state_solvers.ipynb:163 msgid "An optimizer: this is the classical piece of code in charge of optimizing the parameters in our variational form. See `the corresponding documentation `__ for more information." -msgstr "" +msgstr "Un optimizador: este es el clásico fragmento de código encargado de optimizar los parámetros en nuestra forma variacional. Consulta `la documentación correspondiente `__ para obtener más información." #: ../../tutorials/03_ground_state_solvers.ipynb:165 msgid "One could also use any available ansatz / initial state or even define one's own. For instance," diff --git a/nature/docs/locale/es_UN/LC_MESSAGES/tutorials/index.po b/nature/docs/locale/es_UN/LC_MESSAGES/tutorials/index.po index f7ff40545dd75..72655960193dc 100644 --- a/nature/docs/locale/es_UN/LC_MESSAGES/tutorials/index.po +++ b/nature/docs/locale/es_UN/LC_MESSAGES/tutorials/index.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-28 15:28+0000\n" -"PO-Revision-Date: 2023-11-29 13:37\n" +"PO-Revision-Date: 2024-01-14 19:42\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -24,17 +24,17 @@ msgstr "Tutoriales de Qiskit Nature" #: ../../tutorials/index.rst:7 msgid "On this page you find a number of tutorials covering various topics of Qiskit Nature. These are good references if you are just getting started with Qiskit Nature." -msgstr "" +msgstr "En esta página encontrarás una serie de tutoriales que cubren diversos temas de Qiskit Nature. Estas son buenas referencias si recién estás comenzando con Qiskit Nature." #: ../../tutorials/index.rst:11 msgid "However, the code base provides a significant amount of functionality and advanced capability, and these tutorials below do **not** cover usage of `all` of the features, at the different levels, that are available in Qiskit Nature. In fact, Qiskit Nature is a very modular and flexible code, so if you really want to learn more, we suggest that you explore the API reference and code directly." -msgstr "" +msgstr "Sin embargo, el código base proporciona una cantidad significativa de funcionalidad y capacidad avanzada, y estos tutoriales a continuación **no** cubren el uso de `todas` las característica, en los diferentes niveles, que están disponibles en Qiskit Nature. De hecho, Qiskit Nature es un código muy modular y flexible, por lo que si realmente deseas obtener más información, te sugerimos que explores la referencia y el código de la API directamente." #: ../../tutorials/index.rst:18 msgid "That said, if you learn about a feature which you think deserves its own tutorial, feel free to add it to this list by `opening a pull request `_." -msgstr "" +msgstr "Dicho esto, si conoces una característica que crees que merece su propio tutorial, no dudes en agregarla a esta lista `abriendo una petición de validación (pull request) `_." #: ../../tutorials/index.rst:25 msgid "If you are looking for more concise advice, check out the `How-Tos `_." -msgstr "" +msgstr "Si buscas consejos más concisos, consulta las `Guías Prácticas `_." diff --git a/optimization/docs/locale/es_UN/LC_MESSAGES/explanations/index.po b/optimization/docs/locale/es_UN/LC_MESSAGES/explanations/index.po index c2bf941aff1e3..2ab17bfa209c4 100644 --- a/optimization/docs/locale/es_UN/LC_MESSAGES/explanations/index.po +++ b/optimization/docs/locale/es_UN/LC_MESSAGES/explanations/index.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-14 08:10+0000\n" -"PO-Revision-Date: 2023-11-14 08:59\n" +"PO-Revision-Date: 2024-01-14 19:42\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -20,13 +20,13 @@ msgstr "" #: ../../explanations/index.rst:3 msgid "Qiskit Optimization Explanations" -msgstr "" +msgstr "Explicaciones de Qiskit Optimization" #: ../../explanations/index.rst:5 msgid "This section of the documentation provides background and explanation around techniques, methods etc. both useful with and used by in Qiskit Optimization." -msgstr "" +msgstr "Esta sección de la documentación proporciona antecedentes y explicaciones sobre técnicas, métodos, etc., tanto útiles como utilizados en Qiskit Optimization." #: ../../explanations/index.rst:9 msgid "Explanations..." -msgstr "" +msgstr "Explicaciones..." diff --git a/optimization/docs/locale/es_UN/LC_MESSAGES/explanations/qrao.po b/optimization/docs/locale/es_UN/LC_MESSAGES/explanations/qrao.po index 561edb1da16ce..1cd65554b4115 100644 --- a/optimization/docs/locale/es_UN/LC_MESSAGES/explanations/qrao.po +++ b/optimization/docs/locale/es_UN/LC_MESSAGES/explanations/qrao.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-14 08:10+0000\n" -"PO-Revision-Date: 2023-11-14 09:00\n" +"PO-Revision-Date: 2024-01-15 04:21\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -20,132 +20,132 @@ msgstr "" #: ../../explanations/qrao.rst:2 msgid "Background on Quantum Random Access Optimization: *Quantum relaxations, quantum random access codes, rounding schemes*" -msgstr "" +msgstr "Antecedentes sobre la Optimización Cuántica de Acceso Aleatorio (Quantum Random Access Optimization): *Relajaciones cuánticas, códigos cuánticos de acceso aleatorio, esquemas de redondeo*" #: ../../explanations/qrao.rst:4 msgid "This material provides a deeper look into the concepts behind Quantum Random Access Optimization." -msgstr "" +msgstr "Este material proporciona una mirada más profunda a los conceptos detrás de la Optimización Cuántica de Acceso Aleatorio." #: ../../explanations/qrao.rst:8 msgid "Relaxations" -msgstr "" +msgstr "Relajaciones" #: ../../explanations/qrao.rst:10 msgid "Consider a binary optimization problem defined on binary variables :math:`m_i \\in \\{-1,1\\}`. The choice of using :math:`\\pm 1` variables instead of :math:`0/1` variables is not important, but will be convenient in terms of notation when we begin to re-cast this problem in terms of quantum observables. We will be primarily interested in `quadratic unconstrained binary optimization (QUBO) `__ problems, although the ideas in this document can readily extend to problems with more than quadratic terms, and problems with non-binary or constrained variables can often be recast as a QUBO (though this conversion will incur some overhead)." -msgstr "" +msgstr "Considera un problema de optimización binaria definido sobre variables binarias :math:`m_i \\in \\{-1,1\\}`. La elección de utilizar variables :math:`\\pm 1` en lugar de variables :math:`0/1` no es importante, pero será conveniente en términos de notación cuando comencemos a reformular este problema en términos de observables cuánticos. Estaremos interesados principalmente en problemas de `optimización binaria cuadrática sin restricciones (QUBO) `__, aunque las ideas contenidas en este documento pueden extenderse fácilmente a problemas con más que términos cuadráticos, y los problemas con variables no binarias o restringidas a menudo se pueden reformular como QUBO (aunque esta conversión generará alguna subrecarga)." #: ../../explanations/qrao.rst:22 msgid "Within mathematical optimization, `relaxation `__ is the strategy of taking some hard problem and mapping it onto a similar version of that problem which is (usually) easier to solve. The core idea here is that for useful relaxations, the solution to the relaxed problem can give information about the original problem and allow one to heuristically find better solutions. An example of relaxation could be something as simple as taking a discrete optimization problem and allowing a solver to optimize the problem using continuous variables. Once a solution is obtained for the relaxed problem, the solver must find a strategy for extracting a discrete solution from the relaxed solution of continuous values. This process of mapping the relaxed solution back onto original problem’s set of admissible solutions is often referred to as **rounding**." -msgstr "" +msgstr "Dentro de la optimización matemática, la `relajación `__ es la estrategia de tomar un problema difícil y mapearlo en una versión similar de ese problema que es (generalmente) más fácil de resolver. La idea central aquí es que para relajaciones útiles, la solución al problema relajado puede brindar información sobre el problema original y permitir encontrar heurísticamente mejores soluciones. Un ejemplo de relajación podría ser algo tan simple como tomar un problema de optimización discreto y permitir que un solucionador optimice el problema utilizando variables continuas. Una vez que se obtiene una solución para el problema relajado, el solucionador debe encontrar una estrategia para extraer una solución discreta de la solución relajada de valores continuos. Este proceso de mapear la solución relajada nuevamente al conjunto de soluciones admisibles del problema original a menudo se denomina **redondeo**." #: ../../explanations/qrao.rst:37 #, python-format msgid "For a concrete example of relaxation and rounding, see the `Goemans-Williamson Algorithm for MaxCut `__." -msgstr "" +msgstr "Para ver un ejemplo concreto de relajación y redondeo, consulta el `Algoritmo de Goemans-Williamson para MaxCut `__." #: ../../explanations/qrao.rst:41 msgid "Without loss of generality, the rest of this document will consider a `MaxCut `__ objective function defined on a graph :math:`G = (V,E)`. Our goal is to find a partitioning of our vertices :math:`V` into two sets (:math:`+1` and :math:`-1`), such that we maximize the number of edges which connect both sets. More concretely, each :math:`v_i \\in V` will be assigned a binary variable :math:`m_i \\in \\{-1, 1\\}`, and we will define the *cut* of a variable assignment as:" -msgstr "" +msgstr "Sin pérdida de generalidad, el resto de este documento considerará una función objetivo `MaxCut `__ definida sobre un grafo :math:`G = (V,E)`. Nuestro objetivo es encontrar una partición de nuestros vértices :math:`V` en dos conjuntos (:math:`+1` y :math:`-1`), de modo que maximicemos el número de aristas que conectan ambos conjuntos. Más concretamente, a cada :math:`v_i \\in V` se le asignará una variable binaria :math:`m_i \\in \\{-1, 1\\}`, y definiremos el *corte* de una asignación de variable como:" #: ../../explanations/qrao.rst:50 msgid "\\text{cut}(m) = \\sum_{ij; e_{ij} \\in E} \\frac{1}{2}(1-m_i m_j)\n\n" -msgstr "" +msgstr "\\text{cut}(m) = \\sum_{ij; e_{ij} \\in E} \\frac{1}{2}(1-m_i m_j)\n\n" #: ../../explanations/qrao.rst:53 msgid "Quantum Relaxation" -msgstr "" +msgstr "Relajación Cuántica" #: ../../explanations/qrao.rst:55 msgid "Our goal is to define a relaxation of our MaxCut objective function. We will do this by mapping our objective function’s binary variables into the space of single qubit Pauli observables and by embedding the set of feasible inputs to cut(:math:`m`) onto the space of single-qubit quantum product states. Let us denote this embedding :math:`F` as:" -msgstr "" +msgstr "Nuestro objetivo es definir una relajación de nuestra función objetivo MaxCut. Haremos esto mapeando las variables binarias de nuestra función objetivo en el espacio de observables de Pauli de un solo qubit e incorporando el conjunto de entradas factibles para cut(:math:`m`) en el espacio de estados de productos cuánticos de un solo qubit. Denotemos esta incrustración :math:`F` como:" #: ../../explanations/qrao.rst:61 msgid "F: \\{-1,1\\}^{M} \\mapsto \\mathcal{D}(\\mathbb{C}^{2^n}),\n\n" -msgstr "" +msgstr "F: \\{-1,1\\}^{M} \\mapsto \\mathcal{D}(\\mathbb{C}^{2^n}),\n\n" #: ../../explanations/qrao.rst:63 msgid "\\text{cut}(m) \\mapsto \\text{Tr}\\big(H\\cdot F(m)\\big),\n\n" -msgstr "" +msgstr "\\text{cut}(m) \\mapsto \\text{Tr}\\big(H\\cdot F(m)\\big),\n\n" #: ../../explanations/qrao.rst:65 msgid "where :math:`M = |V|`, and :math:`H` is a quantum Hamiltonian which encodes our objective function." -msgstr "" +msgstr "donde :math:`M = |V|`, y :math:`H` es un Hamiltoniano cuántico que codifica nuestra función objetivo." #: ../../explanations/qrao.rst:68 msgid "For this to be `a valid relaxation `__ of our problem, it must be the case that:" -msgstr "" +msgstr "Para que esto sea `una relajación válida `_ de nuestro problema, debe darse el caso de que:" #: ../../explanations/qrao.rst:72 msgid "\\text{cut}(m) \\geq \\text{Tr}\\big(H\\cdot F(m)\\big)\\qquad \\forall m \\in \\{-1,1\\}^M.\n\n" -msgstr "" +msgstr "\\text{cut}(m) \\geq \\text{Tr}\\big(H\\cdot F(m)\\big)\\qquad \\forall m \\in \\{-1,1\\}^M.\n\n" #: ../../explanations/qrao.rst:74 msgid "In order to guarantee this is true, we will enforce the stronger condition that our relaxation **commutes** with our objective function. In other words, cut(:math:`m`) is equal to the relaxed objective function for all :math:`m \\in \\{-1,1\\}^M`, rather than simply upper bounding it. This detail will become crucially important further down when we explicitly define our quantum relaxation." -msgstr "" +msgstr "Para garantizar que esto sea cierto, impondremos la condición más fuerte de que nuestra relajación **conmuta** con nuestra función objetivo. En otras palabras, cut(:math:`m`) es igual a la función objetivo relajada para todo :math:`m \\in \\{-1,1\\}^M`, en lugar de simplemente limitarla por arriba. Este detalle adquirirá una importancia crucial más adelante, cuando definamos explícitamente nuestra relajación cuántica." #: ../../explanations/qrao.rst:82 msgid "A Simple Quantum Relaxation" -msgstr "" +msgstr "Una Relajación Cuántica Simple" #: ../../explanations/qrao.rst:84 msgid "Before explicating the full quantum relaxation scheme based on single-qubit Quantum Random Access Codes (QRACs), it may be helpful to first discuss `a version of quantum optimization `__ which users may be more familiar with, but discussed in the language of quantum relaxation and rounding." -msgstr "" +msgstr "Antes de explicar el esquema completo de relajación cuántica basado en Códigos de Acceso Aleatorio Cuántico (Quantum Random Access Codes, QRAC) de un solo qubit, puede resultar útil analizar primero `una versión de optimización cuántica `__ con el que los usuarios pueden estar más familiarizados, pero que se analiza en el lenguaje de la relajación y el redondeo cuánticos." #: ../../explanations/qrao.rst:91 msgid "Consider the embedding" -msgstr "" +msgstr "Considera la incrustación" #: ../../explanations/qrao.rst:93 msgid "F^{(1)}: m \\in \\{-1,1\\}^M \\mapsto \\{|0\\rangle,|1\\rangle\\}^{\\otimes M},\n\n" -msgstr "" +msgstr "F^{(1)}: m \\in \\{-1,1\\}^M \\mapsto \\{|0\\rangle,|1\\rangle\\}^{\\otimes M},\n\n" #: ../../explanations/qrao.rst:95 msgid "\\text{cut}(m) \\mapsto \\text{Tr}\\big(H^{(1)}F^{(1)}(m)\\big),\\quad H^{(1)} = \\sum_{ij; e_{ij} \\in E} \\frac{1}{2}(1-Z_i Z_j),\n\n" -msgstr "" +msgstr "\\text{cut}(m) \\mapsto \\text{Tr}\\big(H^{(1)}F^{(1)}(m)\\big),\\quad H^{(1)} = \\sum_{ij; e_{ij} \\in E} \\frac{1}{2}(1-Z_i Z_j),\n\n" #: ../../explanations/qrao.rst:97 msgid "where :math:`Z_i` indicates the single qubit Pauli-Z observable defined on the :math:`i`\\ ’th qubit and identity terms on all other qubits. It is worth convincing yourself that this transformation is a valid relaxation of our problem. In particular:" -msgstr "" +msgstr "donde :math:`Z_i` indica el único qubit observable Pauli-Z definido en el :math:`i`\\ ’ésimo qubit y términos de identidad en todos los demás qubits. Vale la pena convencerse de que esta transformación es una relajación válida de nuestro problema. En particular:" #: ../../explanations/qrao.rst:102 msgid "\\text{cut}(m) = \\text{Tr}\\big(H^{(1)}F^{(1)}(m)\\big) \\quad \\forall m \\in \\{-1,1\\}^M\n\n" -msgstr "" +msgstr "\\text{cut}(m) = \\text{Tr}\\big(H^{(1)}F^{(1)}(m)\\big) \\quad \\forall m \\in \\{-1,1\\}^M\n\n" #: ../../explanations/qrao.rst:104 msgid "This sort of embedding is currently used by many near-term quantum optimization algorithms, including many `QAOA and VQE based approaches `__. Observe how although the relaxed version of our problem can exactly reproduce the objective function cut(:math:`m`) for inputs of the form :math:`\\{|0\\rangle,|1\\rangle\\}^{\\otimes M}`, we are also free to evaluate :math:`H^{(1)}` using a continuous superposition of such states. This stands in analogy to how one might classically relax an optimization problem such that they optimize the objective function using continuous values." -msgstr "" +msgstr "Este tipo de incrustación es utilizado actualmente por muchos algoritmos de optimización cuántica a corto plazo, incluidos muchos enfoques basados en `QAOA y VQE based approaches `__. Observa cómo, aunque la versión relajada de nuestro problema puede reproducir exactamente la función objetivo cut(:math:`m`) para entradas de la forma :math:`\\{|0\\rangle,|1\\rangle\\}^{\\otimes M}`, también somos libres de evaluar :math:`H^{(1)}` usando una superposición continua de dichos estados. Esto es una analogía de cómo uno podría relajar clásicamente un problema de optimización, de modo que se optimice la función objetivo utilizando valores continuos." #: ../../explanations/qrao.rst:115 msgid "Crucially, a relaxation is only useful if there is some practical way to **round** relaxed solutions back onto the original problem’s set of admissible solutions. For this particular quantum relaxation, the rounding scheme is simply given by measuring each qubit of our relaxed solution in the :math:`Z`-basis. Measurement will project any quantum state onto the set of computational basis states, and consequently, onto the image of :math:`F^{(1)}`." -msgstr "" +msgstr "Fundamentalmente, una relajación sólo es útil si hay alguna forma práctica de **redondear** las soluciones relajadas al conjunto de soluciones admisibles del problema original. Para esta relajación cuántica particular, el esquema de redondeo se obtiene simplemente midiendo cada qubit de nuestra solución relajada en la base :math:`Z`. La medición proyectará cualquier estado cuántico en el conjunto de estados básicos computacionales y, en consecuencia, en la imagen de :math:`F^{(1)}`." #: ../../explanations/qrao.rst:124 msgid "Quantum Relaxations via Quantum Random Access Codes (QRACs)" -msgstr "" +msgstr "Relajaciones Cuánticas a través de Códigos Cuánticos de Acceso Aleatorio (QRAC)" #: ../../explanations/qrao.rst:126 msgid "Quantum Random Access Codes were `first outlined in 1983 by Stephen Wiesner [2] `__ and were used in the context of communication complexity theory. We will not be using QRACs in the way they were originally conceived, instead we are co-opting them to define our quantum relaxations. For this reason will not provide a full introduction to RACs or QRACs, but encourage interested readers to seek out more information about them." -msgstr "" +msgstr "Los códigos de acceso aleatorio cuánticos fueron `delineados por primera vez en 1983 por Stephen Wiesner [2] `__ y se utilizaron en el contexto de la teoría de la complejidad de la comunicación. No usaremos QRAC en la forma en que fueron concebidos originalmente, sino que los usaremos para definir nuestras relajaciones cuánticas. Por este motivo, no proporcionaremos una introducción completa a los RAC o QRAC, pero animaremos a los lectores interesados a buscar más información sobre ellos." #: ../../explanations/qrao.rst:136 msgid ":math:`(1,1,1)`, :math:`(2,1,p)`, and :math:`(3,1,p)` Quantum Random Access Codes" -msgstr "" +msgstr ":math:`(1,1,1)`, :math:`(2,1,p)`, y :math:`(3,1,p)` Códigos Cuánticos de Acceso Aleatorio" #: ../../explanations/qrao.rst:138 msgid "A :math:`(k,1,p)`-QRAC, is a scheme for embedding :math:`k` classical bits into a 1-qubit state, such that given a single copy of this state, you can recover any one of the :math:`k`-bits with probability :math:`p` by performing some measurement. The simple quantum relaxation discussed in the previous section is an example of a trivial :math:`(1,1,1)`-QRAC. For convenience, we will write the :math:`(2,1,0.854)` and :math:`(3,1,0.789)` QRACs as :math:`(2,1,p)` and :math:`(3,1,p)`, respectively. It is worth noting :math:`(4, 1, p)`-QRAC :math:`(p > 1/2)` has been `proven to be impossible. [3] `__" -msgstr "" +msgstr "Un :math:`(k,1,p)`-QRAC, es un esquema para incrustar :math:`k` bits clásicos en un estado de 1 qubit, de modo que, dada una única copia de este estado, se puede recuperar cualquier uno de los :math:`k` bits con probabilidad :math:`p` realizando alguna medición. La relajación cuántica simple analizada en la sección anterior es un ejemplo de un :math:`(1,1,1)`-QRAC trivial. Por conveniencia, escribiremos los QRACs :math:`(2,1,0.854)` y :math:`(3,1,0.789)` como :math:`(2,1,p)` y :math:`(3,1,p)`, respectivamente. Vale la pena señalar que :math:`(4, 1, p)`-QRAC :math:`(p > 1/2)` ha `demostrado ser imposible. [3] `__" #: ../../explanations/qrao.rst:149 msgid "As we generalize the simple example above, it will be helpful to write out single qubit states decomposed in the Hermitian basis of Pauli observables." -msgstr "" +msgstr "A medida que generalizamos el ejemplo simple anterior, será útil escribir estados de qubits individuales descompuestos en la base Hermitiana de los observables de Pauli." #: ../../explanations/qrao.rst:153 msgid "\\rho = \\frac{1}{2}\\left(I + aX + bY + cZ \\right),\\quad |a|^2 + |b|^2 + |c|^2 = 1\n\n" -msgstr "" +msgstr "\\rho = \\frac{1}{2}\\left(I + aX + bY + cZ \\right),\\quad |a|^2 + |b|^2 + |c|^2 = 1\n\n" #: ../../explanations/qrao.rst:155 msgid "The embeddings :math:`F^{(1)}`, :math:`F^{(2)}`, and :math:`F^{(3)}` associated respectively with the :math:`(1,1,1), (2,1,p),` and :math:`(3,1,p)` QRACs can now be written as follows:" -msgstr "" +msgstr "Las incrustaciones :math:`F^{(1)}`, :math:`F^{(2)}`, y :math:`F^{(3)}` asociadas respectivamente con los QRACs :math:`(1,1,1), (2,1,p),` y :math:`(3,1,p)` ahora se pueden escribir de la siguiente manera:" #: ../../explanations/qrao.rst:159 msgid "\\begin{array}{l|ll}\n" @@ -155,35 +155,41 @@ msgid "\\begin{array}{l|ll}\n" "(2,1,p)&F^{(2)}(m): \\{-1,1\\}^2 &\\mapsto\\ \\vert\\psi^{(2)}_m\\rangle \\langle\\psi^{(2)}_m\\vert = \\frac{1}{2}\\left(I + \\frac{1}{\\sqrt{2}}\\big({m_0}X+ {m_1}Z \\big)\\right) \\\\\n" "(3,1,p)&F^{(3)}(m): \\{-1,1\\}^3 &\\mapsto\\ \\vert\\psi^{(3)}_m\\rangle \\langle\\psi^{(3)}_m\\vert = \\frac{1}{2}\\left(I + \\frac{1}{\\sqrt{3}}\\big({m_0}X+ {m_1}Y + {m_2}Z\\big)\\right) \\\\\n" "\\end{array}" -msgstr "" +msgstr "\\begin{array}{l|ll}\n" +"\\text{QRAC} & &\\text{Embedding into } \\rho = \\vert \\psi(m)\\rangle\\langle\\psi(m)\\vert \\\\\n" +"\\hline\n" +"(1,1,1)&F^{(1)}(m): \\{-1,1\\} &\\mapsto\\ \\vert\\psi^{(1)}_m\\rangle \\langle\\psi^{(1)}_m\\vert = \\frac{1}{2}\\Big(I + {m_0}Z \\Big) \\\\\n" +"(2,1,p)&F^{(2)}(m): \\{-1,1\\}^2 &\\mapsto\\ \\vert\\psi^{(2)}_m\\rangle \\langle\\psi^{(2)}_m\\vert = \\frac{1}{2}\\left(I + \\frac{1}{\\sqrt{2}}\\big({m_0}X+ {m_1}Z \\big)\\right) \\\\\n" +"(3,1,p)&F^{(3)}(m): \\{-1,1\\}^3 &\\mapsto\\ \\vert\\psi^{(3)}_m\\rangle \\langle\\psi^{(3)}_m\\vert = \\frac{1}{2}\\left(I + \\frac{1}{\\sqrt{3}}\\big({m_0}X+ {m_1}Y + {m_2}Z\\big)\\right) \\\\\n" +"\\end{array}" #: ../../explanations/qrao.rst:169 msgid "\\text{Table 1: QRAC states}\n\n" -msgstr "" +msgstr "\\text{Tabla 1: Estados QRAC}\n\n" #: ../../explanations/qrao.rst:171 msgid "Note that for when using a :math:`(k,1,p)`-QRAC with bit strings :math:`m \\in \\{-1,1\\}^M, M > k`, these embeddings scale naturally via composition by tensor product." -msgstr "" +msgstr "Ten en cuenta que cuando se utiliza un :math:`(k,1,p)`-QRAC con cadenas de bits :math:`m \\in \\{-1,1\\}^M, M > k`, estas incrustaciones se escalan de forma natural vía composición por producto tensorial." #: ../../explanations/qrao.rst:175 msgid "m \\in \\{-1,1\\}^6,\\quad F^{(3)}(m) = F^{(3)}(m_0,m_1,m_2)\\otimes F^{(3)}(m_3,m_4,m_5)\n\n" -msgstr "" +msgstr "m \\in \\{-1,1\\}^6,\\quad F^{(3)}(m) = F^{(3)}(m_0,m_1,m_2)\\otimes F^{(3)}(m_3,m_4,m_5)\n\n" #: ../../explanations/qrao.rst:177 msgid "Similarly, when :math:`k \\nmid M`, we can simply pad our input bitstring with the appropriate number of :math:`+1` values." -msgstr "" +msgstr "De manera similar, cuando :math:`k \\nmid M`, podemos simplemente rellenar nuestra cadena de bits de entrada con el número apropiado de valores :math:`+1`." #: ../../explanations/qrao.rst:180 msgid "m \\in \\{-1,1\\}^4,\\quad F^{(3)}(m) = F^{(3)}(m_0,m_1,m_2)\\otimes F^{(3)}(m_3,+1,+1)\n\n" -msgstr "" +msgstr "m \\in \\{-1,1\\}^4,\\quad F^{(3)}(m) = F^{(3)}(m_0,m_1,m_2)\\otimes F^{(3)}(m_3,+1,+1)\n\n" #: ../../explanations/qrao.rst:183 msgid "Recovering Encoded Bits" -msgstr "" +msgstr "Recuperar Bits Codificados" #: ../../explanations/qrao.rst:185 msgid "Given a QRAC state, we can recover the values of the encoded bits by estimating the expectation value of each bit’s corresponding observable. Note that there is a re-scaling factor which depends on the density of the QRAC." -msgstr "" +msgstr "Dado un estado QRAC, podemos recuperar los valores de los bits codificados estimando el valor esperado del observable correspondiente de cada bit. Ten en cuenta que existe un factor de reescalado que depende de la densidad del QRAC." #: ../../explanations/qrao.rst:190 msgid "\\begin{array}{l|l|l|l}\n" @@ -193,19 +199,25 @@ msgid "\\begin{array}{l|l|l|l}\n" "\\rho = F^{(2)}(m_0,m_1) &\\sqrt{2}\\cdot\\text{Tr}\\big(\\rho X\\big) &\\sqrt{2}\\cdot\\text{Tr}\\big(\\rho Z\\big) & \\\\\n" "\\rho = F^{(3)}(m_0,m_1,m_2) & \\sqrt{3}\\cdot\\text{Tr}\\big(\\rho X\\big) & \\sqrt{3}\\cdot\\text{Tr}\\big(\\rho Y\\big) & \\sqrt{3}\\cdot\\text{Tr}\\big(\\rho Z\\big)\n" "\\end{array}" -msgstr "" +msgstr "\\begin{array}{l|l|l|l}\n" +"\\text{Embedding} & m_0 & m_1 & m_2\\\\\n" +"\\hline\n" +"\\rho = F^{(1)}(m_0) &\\text{Tr}\\big(\\rho Z\\big) & & \\\\\n" +"\\rho = F^{(2)}(m_0,m_1) &\\sqrt{2}\\cdot\\text{Tr}\\big(\\rho X\\big) &\\sqrt{2}\\cdot\\text{Tr}\\big(\\rho Z\\big) & \\\\\n" +"\\rho = F^{(3)}(m_0,m_1,m_2) & \\sqrt{3}\\cdot\\text{Tr}\\big(\\rho X\\big) & \\sqrt{3}\\cdot\\text{Tr}\\big(\\rho Y\\big) & \\sqrt{3}\\cdot\\text{Tr}\\big(\\rho Z\\big)\n" +"\\end{array}" #: ../../explanations/qrao.rst:200 msgid "\\text{Table 2: Bit recovery from QRAC states}\n\n" -msgstr "" +msgstr "\\text{Tabla 2: Recuperación de bits de estados QRAC}\n\n" #: ../../explanations/qrao.rst:203 msgid "Encoded Problem Hamiltonians" -msgstr "" +msgstr "Problema de Codificado de Hamiltonianos" #: ../../explanations/qrao.rst:205 msgid "Using the tools we have outlined above, we can explicitly write out the Hamiltonians which encode the relaxed versions of our MaxCut problem. We do this by substituting each decision variable with the unique observable that has been assigned to that variable under the embedding :math:`F`." -msgstr "" +msgstr "Usando las herramientas que hemos descrito anteriormente, podemos escribir explícitamente los Hamiltonianos que codifican las versiones relajadas de nuestro problema MaxCut. Hacemos esto sustituyendo cada variable de decisión con el observable único que se ha asignado a esa variable bajo la incrustación :math:`F`." #: ../../explanations/qrao.rst:211 msgid "\\begin{array}{l|ll}\n" @@ -215,71 +227,77 @@ msgid "\\begin{array}{l|ll}\n" "(2,1,p)&H^{(2)} = \\sum_{ij; e_{ij} \\in E} \\frac{1}{2}(1-2\\cdot P_{[i]} P_{[j]}),\\quad P_{[i]} \\in \\{X,Z\\}\\\\\n" "(3,1,p)&H^{(3)} = \\sum_{ij; e_{ij} \\in E} \\frac{1}{2}(1-3\\cdot P_{[i]} P_{[j]}),\\quad P_{[i]} \\in \\{X,Y,Z\\}\\\\\n" "\\end{array}" -msgstr "" +msgstr "\\begin{array}{l|ll}\n" +"\\text{QRAC} & \\text{Problem Hamiltonian}\\\\\n" +"\\hline\n" +"(1,1,1)&H^{(1)} = \\sum_{ij; e_{ij} \\in E} \\frac{1}{2}(1-Z_i Z_j)\\\\\n" +"(2,1,p)&H^{(2)} = \\sum_{ij; e_{ij} \\in E} \\frac{1}{2}(1-2\\cdot P_{[i]} P_{[j]}),\\quad P_{[i]} \\in \\{X,Z\\}\\\\\n" +"(3,1,p)&H^{(3)} = \\sum_{ij; e_{ij} \\in E} \\frac{1}{2}(1-3\\cdot P_{[i]} P_{[j]}),\\quad P_{[i]} \\in \\{X,Y,Z\\}\\\\\n" +"\\end{array}" #: ../../explanations/qrao.rst:221 msgid "\\text{Table 3: Relaxed MaxCut Hamiltonians after QRAC embedding}\n\n" -msgstr "" +msgstr "\\text{Tabla 3: Hamiltonianos MaxCut relajados después de la incorporación de QRAC}\n\n" #: ../../explanations/qrao.rst:223 msgid "Note that here, :math:`P_{[i]}` indicates a single-qubit Pauli observable corresponding to decision variable :math:`i`. The bracketed index here is to make clear that :math:`P_{[i]}` will not necessarily be acting on qubit :math:`i`, because the :math:`(2,1,p)` and :math:`(3,1,p)` no longer have a 1:1 relationship between qubits and decision variables." -msgstr "" +msgstr "Ten en cuenta que aquí, :math:`P_{[i]}` indica un observable de Pauli de un solo qubit correspondiente a la variable de decisión :math:`i`. El índice entre corchetes aquí es para dejar claro que :math:`P_{[i]}` no necesariamente actuará sobre el qubit :math:`i`, porque :math:`(2,1,p)` y :math:`(3,1,p)` ya no tiene una relación 1:1 entre qubits y variables de decisión." #: ../../explanations/qrao.rst:231 msgid "Commutation of Quantum Relaxation" -msgstr "" +msgstr "Conmutación de la Relajación Cuántica" #: ../../explanations/qrao.rst:233 msgid "Note that for the :math:`(2,1,p)` and :math:`(3,1,p)` QRACs, we are associating multiple decision variables to each qubit. This means that each decision variable is assigned a *unique* single-qubit Pauli observable and some subsets of these Pauli observables will be defined on the same qubits. This can potentially pose a problem when trying to ensure the commutativity condition discussed earlier" -msgstr "" +msgstr "Ten en cuenta que para los QRACs :math:`(2,1,p)` y :math:`(3,1,p)`, estamos asociando múltiples variables de decisión a cada qubit. Esto significa que a cada variable de decisión se le asigna un observable de Pauli de un solo qubit *único* y algunos subconjuntos de estos observables de Pauli se definirán en los mismos qubits. Potencialmente, esto puede plantear un problema al intentar garantizar la condición de conmutatividad comentada anteriormente" #: ../../explanations/qrao.rst:240 msgid "Observe that under the :math:`(3,1,p)`-QRAC, any term in our objective function of the form :math:`(1 - x_i x_j)` will map to a Hamiltonian term of the form :math:`(1-3\\cdot P_{[i]} P_{[j]})`. If both :math:`P_{[i]}` and :math:`P_{[j]}` are acting on different qubits, then :math:`P_{[i]}\\cdot P_{[j]} = P_{[i]}\\otimes P_{[j]}` and this term of our Hamiltonian will behave as we expect." -msgstr "" +msgstr "Observa que bajo el :math:`(3,1,p)`-QRAC, cualquier término en nuestra función objetivo de la forma :math:`(1 - x_i x_j)` se asignará a un término del Hamiltoniano de la forma :math:`(1-3\\cdot P_{[i]} P_{[j]})`. Si ambos :math:`P_{[i]}` y :math:`P_{[j]}` actúan sobre diferentes qubits, entonces :math:`P_{[i]}\\cdot P_{[j]} = P_{[i]}\\otimes P_{[j]}` y este término de nuestro Hamiltoniano se comportará como esperamos." #: ../../explanations/qrao.rst:247 msgid "If however, :math:`P_{[i]}` and :math:`P_{[j]}` are acting on the same qubit, the two Paulis will compose directly. Recall that the Pauli matrices form a group and are self-inverse, thus we can deduce that the product of two distinct Paulis will yield another element of the group and it will not be the identity." -msgstr "" +msgstr "Sin embargo, si :math:`P_{[i]}` y :math:`P_{[j]}` actúan en el mismo qubit, los dos Paulis se compondrán directamente. Recordemos que las matrices de Pauli forman un grupo y son autoinversas, por lo que podemos deducir que el producto de dos Paulis distintas dará otro elemento del grupo y no será la identidad." #: ../../explanations/qrao.rst:253 msgid "Practically, this means that our commutation relationship will break and :math:`\\text{cut}(m) \\not= \\text{Tr}\\big(H^{(1)}F^{(3)}(m)\\big)`" -msgstr "" +msgstr "En la práctica, esto significa que nuestra relación de conmutación se romperá y :math:`\\text{cut}(m) \\not= \\text{Tr}\\big(H^{(1)}F^{(3)}(m)\\big)`" #: ../../explanations/qrao.rst:256 msgid "In order to restore the commutation of our encoding with our objective function, we must introduce an additional constraint on the form of our problem Hamiltonian. Specifically, we must guarantee that decision variables which share an edge in our input graph :math:`G` are not assigned to the same qubit under our embedding :math:`F`" -msgstr "" +msgstr "Para restaurar la conmutación de nuestra codificación con nuestra función objetivo, debemos introducir una restricción adicional en la forma de nuestro problema Hamiltoniano. Específicamente, debemos garantizar que las variables de decisión que comparten una ventaja en nuestro grafo de entrada :math:`G` no se asignen al mismo qubit bajo nuestra incrustración :math:`F`" #: ../../explanations/qrao.rst:262 msgid "\\forall e_{ij} \\in E,\\quad F^{(3)}(\\dots,m_i,\\dots,m_j,\\dots) = F^{(3)}(\\dots,m_i,\\dots)\\otimes F^{(3)}(\\dots,m_j,\\dots)\n\n" -msgstr "" +msgstr "\\forall e_{ij} \\in E,\\quad F^{(3)}(\\dots,m_i,\\dots,m_j,\\dots) = F^{(3)}(\\dots,m_i,\\dots)\\otimes F^{(3)}(\\dots,m_j,\\dots)\n\n" #: ../../explanations/qrao.rst:264 msgid "In [1] this is accomplished by finding a coloring of the graph G such that no vertices with the same color share an edge, and then assigning variables to the same qubit only if they have the same color." -msgstr "" +msgstr "En [1] esto se logra encontrando una coloración del grafo G tal que ningún vértice con el mismo color comparta una arista, y luego asignando variables al mismo qubit solo si tienen el mismo color." #: ../../explanations/qrao.rst:269 msgid "Quantum Rounding Schemes" -msgstr "" +msgstr "Esquemas de Redondeo Cuántico" #: ../../explanations/qrao.rst:271 msgid "Because the final solution we obtain for the relaxed problem :math:`\\rho_\\text{relax}` is unlikely to be in the image of :math:`F`, we need a strategy for mapping :math:`\\rho_\\text{relax}` to the image of :math:`F` so that we may extract a solution to our original problem." -msgstr "" +msgstr "Debido a que es poco probable que la solución final que obtenemos para el problema relajado :math:`\\rho_\\text{relax}` sea similar a :math:`F`, necesitamos una estrategia para mapear :math:`\\rho_\\text{relax}` a la imagen de :math:`F` para que podamos extraer una solución a nuestro problema original." #: ../../explanations/qrao.rst:276 msgid "In [1] there are two strategies proposed for rounding :math:`\\rho_\\text{relax}` back to :math:`m \\in \\{-1,1\\}^M`." -msgstr "" +msgstr "En [1] hay dos estrategias propuestas para redondear :math:`\\rho_\\text{relax}` a :math:`m \\in \\{-1,1\\}^M`." #: ../../explanations/qrao.rst:280 msgid "Semi-deterministic Rounding" -msgstr "" +msgstr "Redondeo Semideterminista" #: ../../explanations/qrao.rst:282 msgid "A natural choice for extracting a solution is to use the results of Table :math:`2` and simply estimate :math:`\\text{Tr}(P_{[i]}\\rho_\\text{relax})` for all :math:`i` in order to assign a value to each variable :math:`m_i`. The procedure described in Table :math:`2` was intended for use on states in the image of :math:`F`, however, we are now applying it to arbitrary input states. The practical consequence is we will no longer measure a value close to {:math:`\\pm 1`}, {:math:`\\pm \\sqrt{2}`}, or {:math:`\\pm \\sqrt{3}`}, as we would expect for the :math:`(1,1,1)`, :math:`(2,1,p)`, and :math:`(3,1,p)` QRACs, respectively." -msgstr "" +msgstr "Una opción natural para extraer una solución es utilizar los resultados de la Tabla :math:`2` y simplemente estimar :math:`\\text{Tr}(P_{[i]}\\rho_\\text{relax})` para todo :math:`i` para poder asignar un valor a cada variable :math:`m_i`. El procedimiento descrito en la Tabla :math:`2` estaba pensado para usarse en estados en la imagen de :math:`F`; sin embargo, ahora lo estamos aplicando a estados de entrada arbitrarios. La consecuencia práctica es que ya no mediremos un valor cercano a {:math:`\\pm 1`}, {:math:`\\pm \\sqrt{2}`}, o {:math:`\\pm \\sqrt{3}`}, como es de esperar para los QRACs :math:`(1,1,1)`, :math:`(2,1,p)`, y :math:`(3,1,p)`, respectivamente." #: ../../explanations/qrao.rst:293 msgid "We handle this by returning the sign of the expectation value, leading to the following rounding scheme." -msgstr "" +msgstr "Manejamos esto devolviendo el signo del valor esperado, lo que lleva al siguiente esquema de redondeo." #: ../../explanations/qrao.rst:296 msgid "m_i = \\left\\{\\begin{array}{rl}\n" @@ -287,69 +305,73 @@ msgid "m_i = \\left\\{\\begin{array}{rl}\n" " X \\sim\\{-1,1\\} & \\text{Tr}(P_{[i]}\\rho_\\text{relax}) = 0 \\\\\n" " -1 & \\text{Tr}(P_{[i]}\\rho_\\text{relax}) < 0\n" " \\end{array}\\right." -msgstr "" +msgstr "m_i = \\left\\{\\begin{array}{rl}\n" +" +1 & \\text{Tr}(P_{[i]}\\rho_\\text{relax}) > 0 \\\\\n" +" X \\sim\\{-1,1\\} & \\text{Tr}(P_{[i]}\\rho_\\text{relax}) = 0 \\\\\n" +" -1 & \\text{Tr}(P_{[i]}\\rho_\\text{relax}) < 0\n" +" \\end{array}\\right." #: ../../explanations/qrao.rst:304 msgid "Where :math:`X` is a random variable which returns either -1 or 1 with equal probability." -msgstr "" +msgstr "Donde :math:`X` es una variable aleatoria que devuelve -1 o 1 con la misma probabilidad." #: ../../explanations/qrao.rst:307 msgid "Notice that semi-deterministic rounding will faithfully recover :math:`m` from :math:`F(m)` with a failure probability that decreases exponentially with the number of shots used to estimate each :math:`\\text{Tr}(P_{[i]}\\rho_\\text{relax})`" -msgstr "" +msgstr "Observa que el redondeo semideterminista recuperará fielmente :math:`m` de :math:`F(m)` con una probabilidad de falla que disminuye exponencialmente con el número de iteraciones utilizados para estimar cada :math:`\\text{Tr}(P_{[i]}\\rho_\\text{relax})`" #: ../../explanations/qrao.rst:313 msgid "Magic State Rounding" -msgstr "" +msgstr "Redondeo de Estado Mágico" #: ../../explanations/qrao.rst:319 msgid "Three different encodings, the states and the measurement bases, of variables into a single qubit. (a) One variable per qubit. (b) Two variables per qubit. (c) Three variables per qubit. Taken from `[1] `__." -msgstr "" +msgstr "Tres codificaciones diferentes, los estados y las bases de medición, de variables en un solo qubit. (a) Una variable por qubit. (b) Dos variables por qubit. (c) Tres variables por qubit. Tomado de `[1] `__." #: ../../explanations/qrao.rst:323 msgid "Rather than seeking to independently distinguish each :math:`m_i`, magic state rounding randomly selects a measurement basis which will perfectly distinguish a particular pair of orthogonal QRAC states :math:`\\{ F(m), F(\\bar m)\\}`, where :math:`\\bar m` indicates that every bit of :math:`m` has been flipped." -msgstr "" +msgstr "En lugar de buscar distinguir de forma independiente cada :math:`m_i`, el redondeo mágico de estados se selecciona aleatoriamente una base de medición que distinguirá perfectamente un par particular de estados QRAC ortogonales :math:`\\{ F(m), F(\\bar m)\\}`, donde :math:`\\bar m` indica que cada bit de :math:`m` ha sido invertido." #: ../../explanations/qrao.rst:329 msgid "Let :math:`\\mathcal{M}` be the randomized rounding procedure which takes as input a state :math:`\\rho_\\text{relax}` and samples a bitstring :math:`m` by measuring in a randomly selected magic-basis." -msgstr "" +msgstr "Sea :math:`\\mathcal{M}` el procedimiento de redondeo aleatorio que toma como entrada un estado :math:`\\rho_\\text{relax}` y muestrea una cadena de bits :math:`m` midiendo en una base mágica seleccionada aleatoriamente." #: ../../explanations/qrao.rst:333 msgid "\\mathcal{M}^{\\otimes n}(\\rho_\\text{relax}) \\rightarrow F(m)\n\n" -msgstr "" +msgstr "\\mathcal{M}^{\\otimes n}(\\rho_\\text{relax}) \\rightarrow F(m)\n\n" #: ../../explanations/qrao.rst:335 msgid "First, notice that for the :math:`(1,1,1)`-QRAC, there is only one basis to choose and the magic state rounding scheme is essentially equivalent to the semi-deterministic rounding scheme." -msgstr "" +msgstr "Primero, observa que para :math:`(1,1,1)`-QRAC, solo hay una base para elegir y el esquema de redondeo de estado mágico es esencialmente equivalente al esquema de redondeo semideterminista." #: ../../explanations/qrao.rst:339 msgid "For the :math:`(2,1,p)` and :math:`(3,1,p)` QRACs, if we apply the magic state rounding scheme to an :math:`n`-qubit QRAC state :math:`F(m)`, we will have a :math:`2^{-n}` and :math:`4^{-n}` probability of picking the correct basis on each qubit to perfectly extract the solution :math:`m`. Put differently, if we are given an unknown state :math:`F(m)` the probability that :math:`\\mathcal{M}^{\\otimes n}(F(m))\\mapsto F(m)` decreases exponentially with the number of qubits measured - it is far more likely to be mapped to some other :math:`F(m^*)`. Similarly, when we perform magic rounding on an arbitrary state :math:`\\rho_\\text{relax}`, we have similarly low odds of randomly choosing the optimal magic basis for all :math:`n`-qubits. Fortunately magic state rounding does offer a lower bound on the approximation ratio under certain conditions." -msgstr "" +msgstr "Para los QRAC :math:`(2,1,p)` y :math:`(3,1,p)`, si aplicamos el esquema de redondeo de estado mágico a un estado QRAC :math:`F(m)` de :math:`n` qubits, tendremos una probabilidad :math:`2^{-n}` y :math:`4^{-n}` de elegir la base correcta en cada qubit para extraer perfectamente la solución :math:`m`. Dicho de otra manera, si nos dan un estado desconocido :math:`F(m)` la probabilidad de que :math:`\\mathcal{M}^{\\otimes n}(F(m))\\mapsto F(m)` disminuya exponencialmente con el número de qubits medidos; es mucho más probable que se asigne a algún otro :math:`F(m^*)`. . De manera similar, cuando realizamos un redondeo mágico en un estado arbitrario :math:`\\rho_\\text{relax}`, tenemos probabilidades igualmente bajas de elegir aleatoriamente la base mágica óptima para todos los :math:`n` qubits. Afortunadamente, el redondeo de estados mágicos ofrece un límite inferior en la relación de aproximación bajo ciertas condiciones." #: ../../explanations/qrao.rst:353 msgid "Let :math:`F(m^*)` be the highest energy state in the image of F, and let :math:`\\rho^*` be the maximal eigenstate of H." -msgstr "" +msgstr "Sea :math:`F(m^*)` el estado de mayor energía en la imagen de F, y sea :math:`\\rho^*` el estado propio máximo de H." #: ../../explanations/qrao.rst:356 msgid "\\forall \\rho_\\text{relax}\\quad \\text{s.t.}\\quad \\text{Tr}\\left(F(m^*)\\cdot H\\right) \\leq \\text{Tr}\\left(\\rho_\\text{relax}\\cdot H\\right)\\leq \\text{Tr}\\left(\\rho^*\\cdot H\\right)\n\n" -msgstr "" +msgstr "\\forall \\rho_\\text{relax}\\quad \\text{s.t.}\\quad \\text{Tr}\\left(F(m^*)\\cdot H\\right) \\leq \\text{Tr}\\left(\\rho_\\text{relax}\\cdot H\\right)\\leq \\text{Tr}\\left(\\rho^*\\cdot H\\right)\n\n" #: ../../explanations/qrao.rst:358 msgid "\\frac{\\text{expected fval}}{\\text{optimal fval}} = \\frac{\\mathbb{E}\\left[\\text{Tr}\\left(H\\cdot \\mathcal{M}^{\\otimes n}(\\rho_\\text{relax})\\right)\\right]}{\\text{Tr}\\left(H\\cdot F(m^*)\\right)} \\geq \\frac{5}{9}\n\n" -msgstr "" +msgstr "\\frac{\\text{expected fval}}{\\text{optimal fval}} = \\frac{\\mathbb{E}\\left[\\text{Tr}\\left(H\\cdot \\mathcal{M}^{\\otimes n}(\\rho_\\text{relax})\\right)\\right]}{\\text{Tr}\\left(H\\cdot F(m^*)\\right)} \\geq \\frac{5}{9}\n\n" #: ../../explanations/qrao.rst:361 msgid "References" -msgstr "" +msgstr "Referencias" #: ../../explanations/qrao.rst:363 msgid "[1] Bryce Fuller et al., “Approximate solutions of combinatorial problems via quantum relaxations,” (2021), `arXiv:2111.03167 `__," -msgstr "" +msgstr "[1] Bryce Fuller et al., “Approximate solutions of combinatorial problems via quantum relaxations,” (2021), `arXiv:2111.03167 `__," #: ../../explanations/qrao.rst:366 msgid "[2] Stephen Wiesner, “Conjugate coding,” SIGACT News, vol. 15, issue 1, pp. 78-88, 1983. `link `__" -msgstr "" +msgstr "[2] Stephen Wiesner, “Conjugate coding,” SIGACT News, vol. 15, issue 1, pp. 78-88, 1983. `link `__" #: ../../explanations/qrao.rst:370 msgid "[3] Masahito Hayashi et al., “(4,1)-Quantum random access coding does not exist—one qubit is not enough to recover one of four bits,” New Journal of Physics, vol. 8, number 8, pp. 129, 2006. `link `__" -msgstr "" +msgstr "[3] Masahito Hayashi et al., “(4,1)-Quantum random access coding does not exist—one qubit is not enough to recover one of four bits,” New Journal of Physics, vol. 8, number 8, pp. 129, 2006. `link `__" diff --git a/optimization/docs/locale/es_UN/LC_MESSAGES/getting_started.po b/optimization/docs/locale/es_UN/LC_MESSAGES/getting_started.po index 204fc22730cea..5fbf164e389d6 100644 --- a/optimization/docs/locale/es_UN/LC_MESSAGES/getting_started.po +++ b/optimization/docs/locale/es_UN/LC_MESSAGES/getting_started.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-14 08:10+0000\n" -"PO-Revision-Date: 2023-11-14 08:54\n" +"PO-Revision-Date: 2024-01-14 21:15\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -28,7 +28,7 @@ msgstr "Instalación" #: ../../getting_started.rst:10 msgid "Qiskit Optimization depends Qiskit. which has its own `Qiskit Getting Started `__ detailing the installation options and its supported environments/platforms. You should refer to that first. Then the information here can be followed which focuses on the additional installation specific to Qiskit Optimization." -msgstr "" +msgstr "Qiskit Optimization depende de Qiskit, que tiene su propio `Qiskit Primeros Pasos `__ que detalla las opciones de instalación y sus entornos/plataformas compatibles. Deberías referirte a eso primero. Luego, se puede seguir la información que está aquí, la cual se centra en la instalación adicional específica de Qiskit Optimization." #: ../../getting_started.rst:16 msgid "Qiskit Optimization has some functions that have been made optional where the dependent code and/or support program(s) are not (or cannot be) installed by default. Those are IBM CPLEX, CVXPY and Matplotlib. See :ref:`optional_installs` for more information." @@ -40,15 +40,15 @@ msgstr "Comenzar localmente" #: ../../getting_started.rst:24 msgid "The simplest way to get started is to first follow the `getting started 'Start locally' guide for Qiskit `__" -msgstr "" +msgstr "La forma más sencilla de comenzar es seguir primero la `guía de primeros pasos 'Comenzar localmente' para Qiskit `__" #: ../../getting_started.rst:27 msgid "In your virtual environment where you installed Qiskit simply add ``optimization`` to the extra list in a similar manner to how the extra ``visualization`` support is installed for Qiskit, i.e: In your virtual environment, where you installed Qiskit, install Qiskit Optimization as follows:" -msgstr "" +msgstr "En tu entorno virtual donde instalaste Qiskit, simplemente agrega ``optimization`` a la lista adicional de manera similar a cómo se instala el soporte de ``visualization`` adicional para Qiskit, es decir: en tu entorno virtual, donde instalaste Qiskit, Instala la Qiskit Optimization de la siguiente manera:" #: ../../getting_started.rst:38 msgid "As Qiskit Optimization depends on Qiskit, you can though simply install it into your environment, as above, and pip will automatically install a compatible version of Qiskit if one is not already installed." -msgstr "" +msgstr "Como Qiskit Optimization depende de Qiskit, simplemente puedes instalarlo en tu entorno, como se indicó anteriormente, y pip instalará automáticamente una versión compatible de Qiskit si aún no hay una instalada." #: ../../getting_started.rst msgid "Install from source" diff --git a/optimization/docs/locale/es_UN/LC_MESSAGES/index.po b/optimization/docs/locale/es_UN/LC_MESSAGES/index.po index 6011c6e4b758c..02b3302987b84 100644 --- a/optimization/docs/locale/es_UN/LC_MESSAGES/index.po +++ b/optimization/docs/locale/es_UN/LC_MESSAGES/index.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-14 08:10+0000\n" -"PO-Revision-Date: 2023-11-14 08:54\n" +"PO-Revision-Date: 2024-01-14 21:15\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -40,7 +40,7 @@ msgstr "Referencia de la API" #: ../../index.rst:34 msgid "Explanations" -msgstr "" +msgstr "Explicaciones" #: ../../index.rst:34 msgid "Release Notes" @@ -60,7 +60,7 @@ msgstr "**Qiskit Optimization** es un framework de código abierto que cubre tod #: ../../index.rst:13 msgid "The Optimization module enables easy, efficient modeling of optimization problems using `docplex `__. A uniform interface as well as automatic conversion between different problem representations allows users to solve problems using a large set of algorithms, from variational quantum algorithms, such as the Quantum Approximate Optimization Algorithm QAOA, to Grover Adaptive Search using the GroverOptimizer, leveraging fundamental algorithms provided by `Qiskit Algorithms `__. Furthermore, the modular design of the optimization module allows it to be easily extended and facilitates rapid development and testing of new algorithms. Compatible classical optimizers are also provided for testing, validation, and benchmarking." -msgstr "" +msgstr "El módulo Optimization permite el modelado fácil y eficiente de problemas de optimización utilizando `docplex `__. Una interfaz uniforme, así como la conversión automática entre diferentes representaciones de problemas, permite a los usuarios resolver problemas usando un gran conjunto de algoritmos, desde algoritmos cuánticos variacionales, como el Algoritmo Cuántico de Optimización Aproximada QAOA (Quantum Approximate Optimization Algorithm), hasta la Búsqueda Adaptativa de Grover (Grover Adaptive Search) utilizando GroverOptimizer, aprovechando los algoritmos fundamentales proporcionados por `Qiskit Algorithms `__. Además, el diseño modular del módulo de optimización permite ampliarlo fácilmente, y permite el desarrollo rápido y prueba de nuevos algoritmos. También se proporcionan optimizadores clásicos compatibles para pruebas, validación y evaluación comparativa." #: ../../index.rst:26 msgid "Next Steps" diff --git a/optimization/docs/locale/es_UN/LC_MESSAGES/migration/02_migration_guide_to_v0.6.po b/optimization/docs/locale/es_UN/LC_MESSAGES/migration/02_migration_guide_to_v0.6.po index 130e466e81f1b..b04da12e2e9cb 100644 --- a/optimization/docs/locale/es_UN/LC_MESSAGES/migration/02_migration_guide_to_v0.6.po +++ b/optimization/docs/locale/es_UN/LC_MESSAGES/migration/02_migration_guide_to_v0.6.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-14 08:10+0000\n" -"PO-Revision-Date: 2023-11-14 09:00\n" +"PO-Revision-Date: 2024-01-14 21:15\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -20,91 +20,91 @@ msgstr "" #: ../../migration/02_migration_guide_to_v0.6.rst:2 msgid "Qiskit Optimization v0.6 Migration Guide" -msgstr "" +msgstr "Guía de Migración de Qiskit Optimization v0.6" #: ../../migration/02_migration_guide_to_v0.6.rst:4 msgid "This tutorial will guide you through the process of migrating your code from Qiskit Optimization v0.5 to v0.6." -msgstr "" +msgstr "Este tutorial te guiará a través del proceso de migración de tu código de Qiskit Optimization v0.5 a v0.6." #: ../../migration/02_migration_guide_to_v0.6.rst:8 msgid "Overview" -msgstr "" +msgstr "Descripción General" #: ../../migration/02_migration_guide_to_v0.6.rst:10 msgid "Qiskit Terra v0.25 deprecated the ``qiskit.algorithms`` module. It has been superseded by a new standalone library `Qiskit Algorithms `__." -msgstr "" +msgstr "Qiskit Terra v0.25 obsoletizó el módulo ``qiskit.algorithms``. Ha sido reemplazado por una nueva biblioteca independiente `Qiskit Algorithms `__." #: ../../migration/02_migration_guide_to_v0.6.rst:14 msgid "Qiskit Optimization v0.6 supports only the new algorithms of Qiskit Algorithms." -msgstr "" +msgstr "Qiskit Optimization v0.6 solo admite los nuevos algoritmos de Qiskit Algorithms." #: ../../migration/02_migration_guide_to_v0.6.rst:16 msgid "It is not the intention to provide detailed explanations of the new Qiskit Algorithms in this migration guide. We suggest that you read the `corresponding resources `__ of the Qiskit Algorithms documentation instead." -msgstr "" +msgstr "No es la intención proporcionar explicaciones detalladas de los nuevos Qiskit Algorithms en esta guía de migración. Te sugerimos que leas los `recursos correspondientes `__ de la documentación de Qiskit Algorithms en su lugar." #: ../../migration/02_migration_guide_to_v0.6.rst:22 msgid "We can basically use the existing codes by replacing ``qiskit.algorithms`` with ``qiskit_algorithms``." -msgstr "" +msgstr "Básicamente podemos usar los códigos existentes reemplazando ``qiskit.algorithms`` con ``qiskit_algorithms``." #: ../../migration/02_migration_guide_to_v0.6.rst:27 msgid "``MinimumEigenOptimizer``" -msgstr "" +msgstr "``MinimumEigenOptimizer``" #: ../../migration/02_migration_guide_to_v0.6.rst:29 msgid "The former algorithms exist in ``qiskit.algorithms.minimum_eigensolvers``. On the other hand, the new algorithms exist in ``qiskit_algorithms.minimum_eigensolvers`` and we can access them by ``qiskit_algorithms.*``." -msgstr "" +msgstr "Los algoritmos anteriores existen en ``qiskit.algorithms.minimum_eigensolvers``. Por otro lado, los nuevos algoritmos existen en ``qiskit_algorithms.minimum_eigensolvers`` y podemos acceder a ellos mediante ``qiskit_algorithms.*``." #: ../../migration/02_migration_guide_to_v0.6.rst:35 msgid "``MinimumEigenOptimizer`` of Qiskit Optimization can use ``qiskit_algorithms.SamplingMinimumEigensolver`` interface of the new algorithms. Note that ``MinimumEigenOptimizer`` cannot basically handle ``qiskit_algorithms.MinimumEigensolver`` of the new algorithms. But there is an exception. ``MinimumEigenOptimizer`` can handle ``qiskit_algorithms.NumPyMinimumEigensolver`` because ``qiskit_algorithms.NumPyMinimumEigensolver`` has an extension that allows users to access the eigen states." -msgstr "" +msgstr "``MinimumEigenOptimizer`` de Qiskit Optimization puede usar la interfaz ``qiskit_algorithms.SamplingMinimumEigensolver`` de los nuevos algoritmos. Ten en cuenta que ``MinimumEigenOptimizer`` básicamente no puede manejar ``qiskit_algorithms.MinimumEigensolver`` de los nuevos algoritmos. Pero hay una excepción. ``MinimumEigenOptimizer`` puede manejar ``qiskit_algorithms.NumPyMinimumEigensolver`` porque ``qiskit_algorithms.NumPyMinimumEigensolver`` tiene una extensión que permite a los usuarios acceder a los estados propios." #: ../../migration/02_migration_guide_to_v0.6.rst:45 msgid "The following is the corresponding table." -msgstr "" +msgstr "La siguiente es la tabla correspondiente." #: ../../migration/02_migration_guide_to_v0.6.rst:1 msgid "Former algorithm" -msgstr "" +msgstr "Algoritmo anterior" #: ../../migration/02_migration_guide_to_v0.6.rst:1 msgid "New algorithm" -msgstr "" +msgstr "Algoritmo nuevo" #: ../../migration/02_migration_guide_to_v0.6.rst:1 msgid "``qiskit.algorithms.minimum_eigensolvers.SamplingMinimumEigensolver``" -msgstr "" +msgstr "``qiskit.algorithms.minimum_eigensolvers.SamplingMinimumEigensolver``" #: ../../migration/02_migration_guide_to_v0.6.rst:1 msgid "``qiskit_algorithms.SamplingMinimumEigensolver``" -msgstr "" +msgstr "``qiskit_algorithms.SamplingMinimumEigensolver``" #: ../../migration/02_migration_guide_to_v0.6.rst:1 msgid "``qiskit.algorithms.minimum_eigensolver.NumPyMinimumEigensolver``" -msgstr "" +msgstr "``qiskit.algorithms.minimum_eigensolver.NumPyMinimumEigensolver``" #: ../../migration/02_migration_guide_to_v0.6.rst:1 msgid "``qiskit_algorithms.NumPyMinimumEigensolver``" -msgstr "" +msgstr "``qiskit_algorithms.NumPyMinimumEigensolver``" #: ../../migration/02_migration_guide_to_v0.6.rst:1 msgid "``qiskit.algorithms.minimum_eigensolvers.QAOA``" -msgstr "" +msgstr "``qiskit.algorithms.minimum_eigensolvers.QAOA``" #: ../../migration/02_migration_guide_to_v0.6.rst:1 msgid "``qiskit_algorithms.QAOA``" -msgstr "" +msgstr "``qiskit_algorithms.QAOA``" #: ../../migration/02_migration_guide_to_v0.6.rst:1 msgid "``qiskit.algorithms.minimum_eigensolvers.SamplingVQE``" -msgstr "" +msgstr "``qiskit.algorithms.minimum_eigensolvers.SamplingVQE``" #: ../../migration/02_migration_guide_to_v0.6.rst:1 msgid "``qiskit_algorithms.SamplingVQE``" -msgstr "" +msgstr "``qiskit_algorithms.SamplingVQE``" #: ../../migration/02_migration_guide_to_v0.6.rst:58 msgid "NumPyMinimumEigensolver" -msgstr "" +msgstr "NumPyMinimumEigensolver" #: ../../migration/02_migration_guide_to_v0.6.rst:60 #: ../../migration/02_migration_guide_to_v0.6.rst:92 @@ -112,7 +112,7 @@ msgstr "" #: ../../migration/02_migration_guide_to_v0.6.rst:169 #: ../../migration/02_migration_guide_to_v0.6.rst:210 msgid "Previously" -msgstr "" +msgstr "Previamente" #: ../../migration/02_migration_guide_to_v0.6.rst:74 #: ../../migration/02_migration_guide_to_v0.6.rst:109 @@ -120,21 +120,21 @@ msgstr "" #: ../../migration/02_migration_guide_to_v0.6.rst:187 #: ../../migration/02_migration_guide_to_v0.6.rst:224 msgid "New" -msgstr "" +msgstr "Nuevo" #: ../../migration/02_migration_guide_to_v0.6.rst:90 msgid "QAOA" -msgstr "" +msgstr "QAOA" #: ../../migration/02_migration_guide_to_v0.6.rst:128 msgid "SamplingVQE" -msgstr "" +msgstr "SamplingVQE" #: ../../migration/02_migration_guide_to_v0.6.rst:166 msgid "``WarmStartQAOAOptimizer``" -msgstr "" +msgstr "``WarmStartQAOAOptimizer``" #: ../../migration/02_migration_guide_to_v0.6.rst:207 msgid "``GroverOptimizer``" -msgstr "" +msgstr "``GroverOptimizer``" diff --git a/optimization/docs/locale/es_UN/LC_MESSAGES/migration/index.po b/optimization/docs/locale/es_UN/LC_MESSAGES/migration/index.po index a17b3e0ba9523..575f1b3b27826 100644 --- a/optimization/docs/locale/es_UN/LC_MESSAGES/migration/index.po +++ b/optimization/docs/locale/es_UN/LC_MESSAGES/migration/index.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-14 08:10+0000\n" -"PO-Revision-Date: 2023-11-14 08:56\n" +"PO-Revision-Date: 2024-01-14 21:15\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -24,5 +24,5 @@ msgstr "Guía de Migración de Qiskit Optimization" #: ../../migration/index.rst:5 msgid "If you are switching over to version 0.6, which has removed all previously deprecated code, simply follow the instructions provided in the sections below." -msgstr "" +msgstr "Si estás cambiando a la versión 0.6, que eliminó todo el código previamente obsoleto, simplemente sigue las instrucciones proporcionadas en las secciones siguientes." diff --git a/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/01_quadratic_program.po b/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/01_quadratic_program.po index 9f1831a0082c3..bf3bf558bf20a 100644 --- a/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/01_quadratic_program.po +++ b/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/01_quadratic_program.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-14 08:10+0000\n" -"PO-Revision-Date: 2023-11-14 08:54\n" +"PO-Revision-Date: 2024-01-14 21:15\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -32,7 +32,7 @@ msgstr "Introducción" #: ../../tutorials/01_quadratic_program.ipynb:32 msgid "In this tutorial, we briefly introduce how to build optimization problems using Qiskit optimization module. Qiskit optimization introduces the ``QuadraticProgram`` class to make a model of an optimization problem. More precisely, it deals with quadratically constrained quadratic programs given as follows:" -msgstr "" +msgstr "En este tutorial presentamos brevemente cómo construir problemas de optimización usando el módulo de optimización de Qiskit. Qiskit Optimization introduce la clase ``QuadraticProgram`` para hacer un modelo de un problema de optimización. Más precisamente, se ocupa de programas cuadráticamente restringidos que se dan de la siguiente manera:" #: ../../tutorials/01_quadratic_program.ipynb:34 msgid "\\begin{align}\n" @@ -66,7 +66,7 @@ msgstr "Comienzas con un modelo vacío. La forma de agregar variables y restricc #: ../../tutorials/01_quadratic_program.ipynb:100 msgid "Qiskit optimization module supports the conversion from Docplex model. You can easily make a model of an optimization problem with Docplex. You can find the documentation of Docplex at https://ibmdecisionoptimization.github.io/docplex-doc/mp/index.html" -msgstr "" +msgstr "El módulo de optimización de Qiskit soporta la conversión del modelo Docplex. Puedes crear fácilmente un modelo de un problema de optimización con Docplex. Puedes encontrar la documentación de Docplex en https://ibmdecisionoptimization.github.io/docplex-doc/mp/index.html" #: ../../tutorials/01_quadratic_program.ipynb:102 msgid "You can load a Docplex model to ``QuadraticProgram`` by using ``from_docplex_mp`` function." diff --git a/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/02_converters_for_quadratic_programs.po b/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/02_converters_for_quadratic_programs.po index 2c7e8740554b8..7e892d39af3d4 100644 --- a/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/02_converters_for_quadratic_programs.po +++ b/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/02_converters_for_quadratic_programs.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-14 08:10+0000\n" -"PO-Revision-Date: 2023-11-14 08:54\n" +"PO-Revision-Date: 2024-01-14 21:15\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -28,15 +28,15 @@ msgstr "Conversores para Programas Cuadráticos" #: ../../tutorials/02_converters_for_quadratic_programs.ipynb:20 msgid "Optimization problems in Qiskit optimization module are represented with the ``QuadraticProgram`` class, which is a generic and powerful representation for optimization problems. In general, optimization algorithms are defined for a certain formulation of a quadratic program, and we need to convert our problem to the right type." -msgstr "" +msgstr "Los problemas de optimización en el módulo de optimización de Qiskit se representan con la clase ``QuadraticProgram``, que es una representación genérica y poderosa de los problemas de optimización. En general, los algoritmos de optimización se definen para una determinada formulación de un programa cuadrático y necesitamos convertir nuestro problema al tipo correcto." #: ../../tutorials/02_converters_for_quadratic_programs.ipynb:22 msgid "For instance, Qiskit optimization provides several optimization algorithms that can handle `Quadratic Unconstrained Binary Optimization `__ (QUBO) problems. These are mapped to Ising Hamiltonians, for which Qiskit optimization uses the ``qiskit.quantum_info.SparsePauliOp`` object, and then their ground state is approximated. For this optimization, commonly known algorithms such as VQE or QAOA can be used as underlying routine. See the following tutorial about the `Minimum Eigen Optimizer <./03_minimum_eigen_optimizer.ipynb>`__ for more detail. Note that also other algorithms exist that work differently, such as the ``GroverOptimizer``." -msgstr "" +msgstr "Por ejemplo, Qiskit Optimization proporciona varios algoritmos de optimización que pueden manejar problemas de `Optimización Binaria Cuadrática Sin Restricciones `__ (Quadratic Unconstrained Binary Optimization, QUBO). Estos se mapean a Hamiltonianos Ising, para los cuales Qiskit Optimization usa el objeto ``qiskit.quantum_info.SparsePauliOp``, y luego se aproxima su estado fundamental. Para esta optimización, se pueden utilizar algoritmos comúnmente conocidos como VQE o QAOA como rutina subyacente. Consulta el siguiente tutorial sobre el `Optimizador Propio Mínimo <./03_minimum_eigen_optimizer.ipynb>`__ para obtener más detalles. Ten en cuenta que también existen otros algoritmos que funcionan de manera diferente, como por ejemplo el ``GroverOptimizer``." #: ../../tutorials/02_converters_for_quadratic_programs.ipynb:25 msgid "To map a problem to the correct input format, the optimization module of Qiskit optimization offers a variety of converters. In this tutorial we're providing an overview on this functionality. Currently, Qiskit optimization contains the following converters." -msgstr "" +msgstr "Para mapear un problema al formato de entrada correcto, el módulo de optimización de Qiskit Optimization ofrece una variedad de convertidores. En este tutorial proporcionamos una descripción general de esta funcionalidad. Actualmente, Qiskit Optimization contiene los siguientes convertidores." #: ../../tutorials/02_converters_for_quadratic_programs.ipynb:27 msgid "``InequalityToEquality``: convert inequality constraints into equality constraints with additional slack variables." @@ -96,15 +96,15 @@ msgstr "Expliquemos cómo funciona la conversión. Por ejemplo, el límite infer #: ../../tutorials/02_converters_for_quadratic_programs.ipynb:299 msgid "Let us see how the ``interpret`` method works. The purpose of this method is to convert the solution of the converted problem back to that of the original problem. To use this method, we would first require to solve the problem. For the purpose of this tutorial, we will use docplex to solve. We will first translate the quadratic problem into a docplex.mp model." -msgstr "" +msgstr "Veamos cómo funciona el método ``interpret``. El propósito de este método es convertir la solución del problema convertido a la del problema original. Para utilizar este método, primero necesitaríamos resolver el problema. Para los fines de este tutorial, usaremos docplex para resolverlo. Primero traduciremos el problema cuadrático a un modelo docplex.mp." #: ../../tutorials/02_converters_for_quadratic_programs.ipynb:392 msgid "The result ``result_eq`` of ``qp_eq`` has 5 variable values (``x=1.0, y=1.0, z=3.0, xyz_leq@int_slack=0.0, xyz_geq@int_slack=2.0``) while result ``result_orig`` of the original ``qp`` has three values (``x=1.0, y=1.0, z=3.0``). We can call ``InequalityToEquality.interpret`` method by passing a list or an array to the method that has values of ``qp_eq.variables`` as follows. ``result_eq.x`` has the list of values that each variable takes in the solution in correspondence to their position in the variable list ``qp_eq.variables``." -msgstr "" +msgstr "El resultado ``result_eq`` de ``qp_eq`` tiene 5 valores variables (``x=1.0, y=1.0, z=3.0, xyz_leq@int_slack=0.0, xyz_geq@int_slack=2.0``) mientras que el resultado ``result_orig`` del ``qp`` original tiene tres valores (``x=1.0, y=1.0, z=3.0``). Podemos llamar al método ``InequalityToEquality.interpret`` pasando una lista o una matriz al método que tiene valores de ``qp_eq.variables`` de la siguiente manera. ``result_eq.x`` tiene la lista de valores que toma cada variable en la solución en correspondencia con su posición en la lista de variables ``qp_eq.variables``." #: ../../tutorials/02_converters_for_quadratic_programs.ipynb:442 msgid "We notice that :math:`[1., 1., 3.]` are the values taken in the solution of the converted problem for the common variables between converted and original problems (variables: :math:`x`, :math:`y`, :math:`z`). The interpret method shows the same values are the solution of the original problem. This is because the objective function for the converted and original problems is exactly the same. The slack variables are just ensuring equality in the constraints of the converted problem, where the constraints are also exactly same between the original and converted problems, except that the original problem has inequality constraints." -msgstr "" +msgstr "Notamos que :math:`[1., 1., 3.]` son los valores tomados en la solución del problema convertido para las variables comunes entre los problemas convertidos y originales (variables: :math:`x`, :math:`y`, :math:`z`). El método de interpretación muestra que los mismos valores son la solución del problema original. Esto se debe a que la función objetivo para los problemas originales y convertidos es exactamente la misma. Las variables de holgura (slack) solo garantizan la igualdad en las restricciones del problema convertido, donde las restricciones también son exactamente iguales entre los problemas original y convertido, excepto que el problema original tiene restricciones de desigualdad." #: ../../tutorials/02_converters_for_quadratic_programs.ipynb:455 msgid "IntegerToBinary" @@ -132,11 +132,11 @@ msgstr "Nota: En esencia, los coeficientes significan que la suma de estas varia #: ../../tutorials/02_converters_for_quadratic_programs.ipynb:670 msgid "``IntegerToBinary`` also provides ``interpret`` method that is the functionality to translate a given binary result back to the original integer representation. Let us see how the ``interpret`` method works." -msgstr "" +msgstr "``IntegerToBinary`` también provee el método ``interpret`` que es la funcionalidad para traducir un resultado binario dado de nuevo a la representación original. Veamos cómo funciona el método ``interpret``." #: ../../tutorials/02_converters_for_quadratic_programs.ipynb:751 msgid "``result_eq_bin`` has more binary variables due to the conversion by ``IntegerToBinary.convert``. ``IntegerToBinary.interpret`` translates them back to the integer values by aggregating binary variables values associated with the original integer variables of ``qp_eq``." -msgstr "" +msgstr "``result_eq_bin`` tiene más variables binarias debido a la conversión mediante ``IntegerToBinary.convert``. ``IntegerToBinary.interpret`` los traduce nuevamente a valores enteros agregando valores de variables binarias asociadas con las variables enteras originales de ``qp_eq``." #: ../../tutorials/02_converters_for_quadratic_programs.ipynb:801 msgid "LinearEqualityToPenalty" @@ -156,7 +156,7 @@ msgstr "Llama al método ``convert`` de ``LinearEqualityToPenalty`` para convert #: ../../tutorials/02_converters_for_quadratic_programs.ipynb:1070 msgid "After converting, the equality constraints are added to the objective function as additional terms with the default penalty factor provided by Qiskit optimization. The resulting problem is now a QUBO and compatible with many quantum optimization algorithms such as VQE, QAOA and so on." -msgstr "" +msgstr "Después de la conversión, las restricciones de igualdad se añaden a la función objetivo como términos adicionales con el factor de penalización predeterminado provisto por Qiskit Optimization. El problema resultante es ahora un QUBO y es compatible con muchos algoritmos de optimización cuántica como VQE, QAOA y otros." #: ../../tutorials/02_converters_for_quadratic_programs.ipynb:1081 msgid "This gives the same result as before." @@ -164,13 +164,13 @@ msgstr "Esto da el mismo resultado que antes." #: ../../tutorials/02_converters_for_quadratic_programs.ipynb:1092 msgid "Like we did for the other converters, let us see how ``interpret`` method works for this case." -msgstr "" +msgstr "Como hicimos con los otros convertidores, veamos cómo funciona el método ``interpret`` en este caso." #: ../../tutorials/02_converters_for_quadratic_programs.ipynb:1211 msgid "We can see that the result of the ``interpret`` method implies that both the original and converted problems have exactly the same solution. This is expected because the converted problem has exactly the same variables as the original problem, the objective has been modified in such a way that we do not have the constraints anymore in the converted problem." -msgstr "" +msgstr "Podemos ver que el resultado del método ``interpret`` implica que tanto el problema original como el convertido tienen exactamente la misma solución. Esto es de esperarse porque el problema convertido tiene exactamente las mismas variables que el problema original, el objetivo se ha modificado de tal manera que ya no tenemos las restricciones en el problema convertido." #: ../../tutorials/02_converters_for_quadratic_programs.ipynb:1222 msgid "Finally, let us see how we interpret the result of QUBO back to the solution of the original problem ``qp``. The following code shows that the interpreted values are equivalent to the result of the original problem ``qp``." -msgstr "" +msgstr "Finalmente, veamos cómo interpretamos el resultado de QUBO hasta la solución del problema original ``qp``. El siguiente código muestra que los valores interpretados son equivalentes al resultado del problema original ``qp``." diff --git a/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/03_minimum_eigen_optimizer.po b/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/03_minimum_eigen_optimizer.po index c01b7367892dc..3407c3b5f09ff 100644 --- a/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/03_minimum_eigen_optimizer.po +++ b/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/03_minimum_eigen_optimizer.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-14 08:10+0000\n" -"PO-Revision-Date: 2023-11-14 08:54\n" +"PO-Revision-Date: 2024-01-14 21:15\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -36,7 +36,7 @@ msgstr "Una clase interesante de problemas de optimización que debe abordar la #: ../../tutorials/03_minimum_eigen_optimizer.ipynb:35 msgid "Qiskit optimization provides automatic conversion from a suitable ``QuadraticProgram`` to an Ising Hamiltonian, which then allows leveraging all the ``SamplingMinimumEigensolver`` implementations, such as" -msgstr "" +msgstr "Qiskit Optimization proporciona conversión automática de un ``QuadraticProgram`` adecuado a un Hamiltoniano de Ising, que luego permite aprovechar todas las implementaciones de ``SamplingMinimumEigensolver``, como" #: ../../tutorials/03_minimum_eigen_optimizer.ipynb:37 msgid "``SamplingVQE``," @@ -52,7 +52,7 @@ msgstr "``NumpyMinimumEigensolver`` (método clásico exacto)." #: ../../tutorials/03_minimum_eigen_optimizer.ipynb:41 msgid "Note 1: ``MinimumEigenOptimizer`` does not support ``qiskit_algorithms.VQE``. But ``qiskit_algorithms.SamplingVQE`` can be used instead." -msgstr "" +msgstr "Nota 1: ``MinimumEigenOptimizer`` no es compatible con ``qiskit_algorithms.VQE``. Pero en su lugar se puede usar ``qiskit_algorithms.SamplingVQE``." #: ../../tutorials/03_minimum_eigen_optimizer.ipynb:43 msgid "Note 2: ``MinimumEigenOptimizer`` can use ``NumpyMinimumEigensolver`` as an exception case though it inherits ``MinimumEigensolver`` (not ``SamplingMinimumEigensolver``)." @@ -60,15 +60,15 @@ msgstr "Nota 2: ``MinimumEigenOptimizer`` puede usar ``NumpyMinimumEigensolver`` #: ../../tutorials/03_minimum_eigen_optimizer.ipynb:45 msgid "Qiskit optimization provides a the ``MinimumEigenOptimizer`` class, which wraps the translation to an Ising Hamiltonian (in Qiskit Terra also called ``SparsePauliOp``), the call to a ``MinimumEigensolver``, and the translation of the results back to an ``OptimizationResult``." -msgstr "" +msgstr "Qiskit Optimization proporciona una clase ``MinimumEigenOptimizer``, que envuelve la traducción a un Hamiltoniano de Ising (en Qiskit Terra también llamado ``SparsePauliOp``), la llamada a un ``MinimumEigensolver`` y la traducción de los resultados de vuelta a un ``OptimizationResult``." #: ../../tutorials/03_minimum_eigen_optimizer.ipynb:47 msgid "In the following we first illustrate the conversion from a ``QuadraticProgram`` to a ``SparsePauliOp`` and then show how to use the ``MinimumEigenOptimizer`` with different ``MinimumEigensolver``\\ s to solve a given ``QuadraticProgram``. The algorithms in Qiskit optimization automatically try to convert a given problem to the supported problem class if possible, for instance, the ``MinimumEigenOptimizer`` will automatically translate integer variables to binary variables or add linear equality constraints as a quadratic penalty term to the objective. It should be mentioned that a ``QiskitOptimizationError`` will be thrown if conversion of a quadratic program with integer variables is attempted." -msgstr "" +msgstr "A continuación, primero ilustramos la conversión de un ``QuadraticProgram`` a un ``SparsePauliOp`` y luego mostramos cómo usar el ``MinimumEigenOptimizer`` con diferentes ``MinimumEigensolver``\\ s para resolver un ``QuadraticProgram`` dado. Los algoritmos en Qiskit Optimization intentan convertir automáticamente un problema determinado a la clase de problema soportada si es posible, por ejemplo, el ``MinimumEigenOptimizer`` traducirá automáticamente las variables enteras a variables binarias o agregará restricciones de igualdad lineal como un término de penalización cuadrática al objetivo. Se debe mencionar que se generará un ``QiskitOptimizationError`` si se intenta la conversión de un programa cuadrático con variables enteras." #: ../../tutorials/03_minimum_eigen_optimizer.ipynb:50 msgid "The circuit depth of ``QAOA`` potentially has to be increased with the problem size, which might be prohibitive for near-term quantum devices. A possible workaround is Recursive QAOA, as introduced in [2]. Qiskit optimization generalizes this concept to the ``RecursiveMinimumEigenOptimizer``, which is introduced at the end of this tutorial." -msgstr "" +msgstr "La profundidad del circuito de ``QAOA`` podría ser incrementada con el tamaño del problema, lo que podría ser prohibitivo para los dispositivos cuánticos a corto plazo. Un posible método alternativo es el QAOA recursivo, como se introduce en la referencia [2]. Qiskit Optimization generaliza este concepto a ``RecursiveMinimumEigenOptimizer``, el cual se introduce al final de este tutorial." #: ../../tutorials/03_minimum_eigen_optimizer.ipynb:53 msgid "References" @@ -84,19 +84,19 @@ msgstr "[2] `S. Bravyi, A. Kliesch, R. Koenig, E. Tang, Obstacles to State Prepa #: ../../tutorials/03_minimum_eigen_optimizer.ipynb:69 msgid "Converting a QUBO to a SparsePauliOp" -msgstr "" +msgstr "Convertir un QUBO a un SparsePauliOp" #: ../../tutorials/03_minimum_eigen_optimizer.ipynb:173 msgid "Next we translate this QUBO into an Ising operator. This results not only in a ``SparsePauliOp`` but also in a constant offset to be taken into account to shift the resulting value." -msgstr "" +msgstr "A continuación traducimos este QUBO en un operador de Ising. Esto no solo resulta en un ``SparsePauliOp``, sino también en un desplazamiento constante que se debe tener en cuenta para cambiar el valor resultante." #: ../../tutorials/03_minimum_eigen_optimizer.ipynb:230 msgid "Sometimes a ``QuadraticProgram`` might also directly be given in the form of a ``SparsePauliOp``. For such cases, Qiskit optimization also provides a translator from a ``SparsePauliOp`` back to a ``QuadraticProgram``, which we illustrate in the following." -msgstr "" +msgstr "A veces, un ``QuadraticProgram`` también podría ser dado directamente en forma de ``SparsePauliOp``. Para tales casos, Qiskit Optimization también proporciona un traductor de un ``SparsePauliOp`` de vuelta a un ``QuadraticProgram``, que ilustramos a continuación." #: ../../tutorials/03_minimum_eigen_optimizer.ipynb:307 msgid "This translator allows, for instance, one to translate a ``SparsePauliOp`` to a ``QuadraticProgram`` and then solve the problem with other algorithms that are not based on the Ising Hamiltonian representation, such as the ``GroverOptimizer``." -msgstr "" +msgstr "Este traductor permite, por ejemplo, traducir un ``SparsePauliOp`` a un ``QuadraticProgram`` y luego resolver el problema con otros algoritmos que no se basan en la representación del Hamiltoniano de Ising, como el ``GroverOptimizer``." #: ../../tutorials/03_minimum_eigen_optimizer.ipynb:319 msgid "Solving a QUBO with the MinimumEigenOptimizer" diff --git a/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/04_grover_optimizer.po b/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/04_grover_optimizer.po index c675cdbc29168..2b29bfdd0aeba 100644 --- a/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/04_grover_optimizer.po +++ b/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/04_grover_optimizer.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-12-08 18:20+0000\n" -"PO-Revision-Date: 2023-12-08 18:26\n" +"PO-Revision-Date: 2024-01-14 21:15\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -72,11 +72,11 @@ msgstr "Si bien las implementaciones de GAS varían según el caso de uso espec #: ../../tutorials/04_grover_optimizer.ipynb:59 msgid "|6ca734fed0024015824561a78d87e967|" -msgstr "" +msgstr "|6ca734fed0024015824561a78d87e967|" #: ../../tutorials/04_grover_optimizer.ipynb:84 msgid "6ca734fed0024015824561a78d87e967" -msgstr "" +msgstr "6ca734fed0024015824561a78d87e967" #: ../../tutorials/04_grover_optimizer.ipynb:65 msgid "``GroverOptimizer`` uses ``QuadraticProgramToNegativeValueOracle`` to construct :math:`A_y` such that it prepares a :math:`n`-qubit register to represent the equal superposition of all :math:`|x\\rangle_n` and a :math:`m`-qubit register to (approximately) represent the corresponding :math:`|Q(x)-y\\rangle_m`. Then, all states with :math:`(Q(x) - y)` negative should be flagged by :math:`O_y`. Note that in the implementation discussed, the oracle operator is actually independent of :math:`y`, but this is not a requirement. For clarity, we will refer to the oracle as :math:`O` when the oracle is independent of :math:`y`." @@ -88,11 +88,11 @@ msgstr "Dicho formalmente, ``QuadraticProgramToNegativeValueOracle`` construye u #: ../../tutorials/04_grover_optimizer.ipynb:74 msgid "|9648e56adaa642578c061c29a05f5e8a|" -msgstr "" +msgstr "|9648e56adaa642578c061c29a05f5e8a|" #: ../../tutorials/04_grover_optimizer.ipynb:87 msgid "9648e56adaa642578c061c29a05f5e8a" -msgstr "" +msgstr "9648e56adaa642578c061c29a05f5e8a" #: ../../tutorials/04_grover_optimizer.ipynb:80 msgid "where :math:`|x\\rangle` is the binary encoding of the integer :math:`x`." @@ -128,11 +128,11 @@ msgstr "Esto resulta en la solución óptima :math:`x_0=1`, :math:`x_1=0`, :math #: ../../tutorials/04_grover_optimizer.ipynb:261 msgid "|152c54029dff4932bf4d15c772493835|" -msgstr "" +msgstr "|152c54029dff4932bf4d15c772493835|" #: ../../tutorials/04_grover_optimizer.ipynb:280 msgid "152c54029dff4932bf4d15c772493835" -msgstr "" +msgstr "152c54029dff4932bf4d15c772493835" #: ../../tutorials/04_grover_optimizer.ipynb:267 msgid "Each graph shows a single iteration of GAS, with the current values of :math:`r` (= iteration counter) and :math:`y` (= threshold/offset) shown in the title. The X-axis displays the integer equivalent of the input (e.g. '101' :math:`\\rightarrow` 5), and the Y-axis shows the possible function values. As there are 3 binary variables, there are :math:`2^3=8` possible solutions, which are shown in each graph. The color intensity indicates the probability of measuring a certain result (with bright intensity being the highest), while the actual color indicates the corresponding phase (see phase color-wheel below). Note that as :math:`y` decreases, we shift all of the values up by that amount, meaning there are fewer and fewer negative values in the distribution, until only one remains (the minimum)." @@ -140,11 +140,11 @@ msgstr "Cada gráfica muestra una sola iteración de GAS, con los valores actual #: ../../tutorials/04_grover_optimizer.ipynb:274 msgid "|e0a7edbeeeb14dc697f5c923604f6328|" -msgstr "" +msgstr "|e0a7edbeeeb14dc697f5c923604f6328|" #: ../../tutorials/04_grover_optimizer.ipynb:283 msgid "e0a7edbeeeb14dc697f5c923604f6328" -msgstr "" +msgstr "e0a7edbeeeb14dc697f5c923604f6328" #: ../../tutorials/04_grover_optimizer.ipynb:295 msgid "Check that GroverOptimizer finds the correct value" @@ -152,5 +152,5 @@ msgstr "Comprobar que GroverOptimizer encuentra el valor correcto" #: ../../tutorials/04_grover_optimizer.ipynb:297 msgid "We can verify that the algorithm is working correctly using the ``MinimumEigenOptimizer`` in Qiskit optimization." -msgstr "" +msgstr "Podemos verificar que el algoritmo está funcionando correctamente usando el ``MinimumEigenOptimizer`` en Qiskit Optimization." diff --git a/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/05_admm_optimizer.po b/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/05_admm_optimizer.po index ca3626baa03b1..73ca698249d8b 100644 --- a/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/05_admm_optimizer.po +++ b/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/05_admm_optimizer.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-14 08:10+0000\n" -"PO-Revision-Date: 2023-11-14 08:54\n" +"PO-Revision-Date: 2024-01-14 21:15\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -188,7 +188,7 @@ msgstr "Solución Clásica" #: ../../tutorials/05_admm_optimizer.ipynb:298 msgid "3-ADMM-H needs a QUBO optimizer to solve the QUBO subproblem, and a continuous optimizer to solve the continuous convex constrained subproblem. We first solve the problem classically: we use the ``MinimumEigenOptimizer`` with the ``NumPyMinimumEigenSolver`` as a classical and exact QUBO solver and we use the ``CobylaOptimizer`` as a continuous convex solver. 3-ADMM-H supports any other suitable solver available in Qiskit optimization. For instance, ``SamplingVQE``, ``QAOA``, and ``GroverOptimizer`` can be invoked as quantum solvers, as demonstrated later. If CPLEX is installed, the ``CplexOptimizer`` can also be used as both, a QUBO and convex solver." -msgstr "" +msgstr "3-ADMM-H necesita un optimizador QUBO para resolver el subproblema QUBO y un optimizador continuo para resolver el subproblema restringido convexo continuo. Primero resolvemos el problema de manera clásica: usamos el ``MinimumEigenOptimizer`` con el ``NumPyMinimumEigenSolver`` como solucionador QUBO clásico y exacto y usamos el ``CobylaOptimizer`` como solucionador convexo continuo. 3-ADMM-H admite cualquier otro solucionador adecuado disponible en Qiskit Optimization. Por ejemplo, ``SamplingVQE``, ``QAOA``, y ``GroverOptimizer`` pueden ser usados como solucionadores cuánticos, como se demuestra más adelante. Si CPLEX está instalado, el ``CplexOptimizer`` también se puede utilizar tanto como solucionador QUBO, como solucionador convexo." #: ../../tutorials/05_admm_optimizer.ipynb:311 msgid "Parameters" diff --git a/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/06_examples_max_cut_and_tsp.po b/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/06_examples_max_cut_and_tsp.po index 34b6957fb4d7c..d562904b948b8 100644 --- a/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/06_examples_max_cut_and_tsp.po +++ b/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/06_examples_max_cut_and_tsp.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-14 08:10+0000\n" -"PO-Revision-Date: 2023-11-14 08:54\n" +"PO-Revision-Date: 2024-01-14 21:15\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -52,7 +52,7 @@ msgstr "Maximización: beneficio, valor, producción, retorno, rendimiento, util #: ../../tutorials/06_examples_max_cut_and_tsp.ipynb:33 msgid "We consider here max-cut problems of practical interest in many fields, and show how they can be mapped on quantum computers manually and how Qiskit optimization module supports this." -msgstr "" +msgstr "Consideramos aquí problemas de máximo corte (max-cut) de interés práctico en muchos campos, y mostramos cómo se pueden mapear manualmente en computadoras cuánticas y cómo el módulo de optimización de Qiskit lo soporta." #: ../../tutorials/06_examples_max_cut_and_tsp.ipynb:36 msgid "Weighted Max-Cut" @@ -100,7 +100,7 @@ msgstr "H = \\sum_i w_i Z_i + \\sum_{i`__. Particularly, it is shown how to setup the ``MinimumEigenOptimizer`` using ``SamplingVQE`` accordingly. For a given set of shots with corresponding objective values of the considered optimization problem, the CVaR with confidence level :math:`\\alpha \\in [0, 1]` is defined as the average of the :math:`\\alpha` best shots. Thus, :math:`\\alpha = 1` corresponds to the standard expected value, while :math:`\\alpha=0` corresponds to the minimum of the given shots, and :math:`\\alpha \\in (0, 1)` is a tradeoff between focusing on better shots, but still applying some averaging to smoothen the optimization landscape." -msgstr "" +msgstr "Este cuaderno muestra cómo utilizar la función objetivo de Valor en Riesgo Condicional (Conditional Value at Risk, CVaR) introducida en [1] dentro de los algoritmos de optimización cuántica variacional proporcionados por `Qiskit Algorithms `__. En particular, se muestra cómo configurar el ``MinimumEigenOptimizer`` usando ``SamplingVQE`` como corresponde. Para un conjunto dado de iteraciones con los valores objetivos correspondientes al problema de optimización considerado, el CVaR con nivel de confianza :math:`\\alpha \\in [0, 1]` se define como el promedio de las mejores iteraciones :math:`\\alpha`. Por lo tanto, :math:`\\alpha = 1` corresponde al valor esperado estándar, mientras que :math:`\\alpha=0` corresponde al mínimo de las iteraciones realizadas, y :math:`\\alpha \\in (0, 1)` es una compensación entre enfocarse en mejores iteraciones, pero aún así aplicar algunos promedios para suavizar el panorama de optimización." #: ../../tutorials/08_cvar_optimization.ipynb:27 msgid "References" diff --git a/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/10_warm_start_qaoa.po b/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/10_warm_start_qaoa.po index fd87380dab17e..09e72ffed805d 100644 --- a/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/10_warm_start_qaoa.po +++ b/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/10_warm_start_qaoa.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-14 08:10+0000\n" -"PO-Revision-Date: 2023-11-14 08:54\n" +"PO-Revision-Date: 2024-01-14 21:15\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -100,7 +100,7 @@ msgstr "QAOA estándar" #: ../../tutorials/10_warm_start_qaoa.ipynb:505 msgid "First, we use standard QAOA to solve the QUBO. To do this, we convert the QUBO to ``QuadraticProgram`` class (note that the resulting problem is still a binary problem)." -msgstr "" +msgstr "Primero, usamos QAOA estándar para resolver el QUBO. Para hacer esto, convertimos QUBO a la clase ``QuadraticProgram`` (ten en cuenta que el problema resultante sigue siendo un problema binario)." #: ../../tutorials/10_warm_start_qaoa.ipynb:580 #: ../../tutorials/10_warm_start_qaoa.ipynb:892 diff --git a/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/11_using_classical_optimization_solvers_and_models.po b/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/11_using_classical_optimization_solvers_and_models.po index cff5befee3aa1..b6faf44fa1aeb 100644 --- a/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/11_using_classical_optimization_solvers_and_models.po +++ b/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/11_using_classical_optimization_solvers_and_models.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-12-08 18:20+0000\n" -"PO-Revision-Date: 2023-12-12 16:13\n" +"PO-Revision-Date: 2024-01-14 19:42\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -40,7 +40,7 @@ msgstr "Si deseas utilizar Gurobi y Gurobipy, debes instalar ``pip install 'qisk #: ../../tutorials/11_using_classical_optimization_solvers_and_models.ipynb:26 msgid "**Note**: these solvers, that are installed via pip, are free versions and come with some limitations, such as number of variables. The following links provide further details:" -msgstr "" +msgstr "**Nota**: estos solucionadores, que se instalan mediante pip, son versiones gratuitas y vienen con algunas limitaciones, como la cantidad de variables. Los siguientes enlaces proporcionan más detalles:" #: ../../tutorials/11_using_classical_optimization_solvers_and_models.ipynb:28 msgid "https://pypi.org/project/cplex/" diff --git a/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/12_quantum_random_access_optimizer.po b/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/12_quantum_random_access_optimizer.po index 5557fd9a16a9b..2efcad85accb6 100644 --- a/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/12_quantum_random_access_optimizer.po +++ b/optimization/docs/locale/es_UN/LC_MESSAGES/tutorials/12_quantum_random_access_optimizer.po @@ -3,7 +3,7 @@ msgstr "" "Project-Id-Version: qiskit-docs\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-11-14 08:10+0000\n" -"PO-Revision-Date: 2023-11-14 09:00\n" +"PO-Revision-Date: 2024-01-15 03:20\n" "Last-Translator: \n" "Language: es_UN\n" "Language-Team: Spanish (United)\n" @@ -20,221 +20,221 @@ msgstr "" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:9 msgid "This page was generated from `docs/tutorials/12_quantum_random_access_optimizer.ipynb`__." -msgstr "" +msgstr "Esta página fue generada a partir de `docs/tutorials/12_quantum_random_access_optimizer.ipynb`__." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:9 msgid "Quantum Random Access Optimization" -msgstr "" +msgstr "Optimización Cuántica de Acceso Aleatorio" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:20 msgid "The Quantum Random Access Optimization (QRAO) module is designed to enable users to leverage a new quantum method for combinatorial optimization problems [1]. This approach incorporates Quantum Random Access Codes (QRACs) as a tool to encode multiple classical binary variables into a single qubit, thereby saving quantum resources and enabling exploration of larger problem instances on a quantum computer. The encodings produce a local quantum Hamiltonian whose ground state can be approximated with standard algorithms such as VQE, and then rounded to yield approximation solutions of the original problem." -msgstr "" +msgstr "El módulo Quantum Random Access Optimization (QRAO) está diseñado para permitir a los usuarios aprovechar un nuevo método cuántico para problemas de optimización combinatoria [1]. Este enfoque incorpora Códigos Cuánticos de Acceso Aleatorio (Quantum Random Access Codes, QRAC) como herramienta para codificar múltiples variables binarias clásicas en un solo qubit, ahorrando así recursos cuánticos y permitiendo la exploración de instancias de problemas más grandes en una computadora cuántica. Las codificaciones producen un Hamiltoniano cuántico local cuyo estado fundamental puede aproximarse con algoritmos estándar como VQE y luego redondearse para producir soluciones aproximadas del problema original." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:23 msgid "QRAO through a series of 3 classes: 1. The encoding class (``QuantumRandomAccessEncoding``): This class encodes the original problem into a relaxed problem that requires fewer resources to solve. 2. The rounding schemes (``SemideterministicRounding`` and ``MagicRounding``): This scheme is used to round the solution obtained from the relaxed problem back to a solution of the original problem. 3. The optimizer class (``QuantumRandomAccessOptimizer``): This class performs the high-level optimization algorithm, utilizing the capabilities of the encoding class and the rounding scheme." -msgstr "" +msgstr "QRAO a través de una serie de 3 clases: 1. La clase de codificación (``QuantumRandomAccessEncoding``): esta clase codifica el problema original en un problema relajado que requiere menos recursos para resolver. 2. Los esquemas de redondeo (``SemidterministicRounding`` y ``MagicRounding``): Este esquema se utiliza para redondear la solución obtenida del problema relajado a una solución del problema original. 3. La clase optimizadora (``QuantumRandomAccessOptimizer``): esta clase realiza el algoritmo de optimización de alto nivel, utilizando las capacidades de la clase de codificación y el esquema de redondeo." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:26 msgid "*References*" -msgstr "" +msgstr "*Referencias*" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:28 msgid "[1] Bryce Fuller et al., *Approximate Solutions of Combinatorial Problems via Quantum Relaxations,* `arXiv:2111.03167 `__" -msgstr "" +msgstr "[1] Bryce Fuller et al., *Approximate Solutions of Combinatorial Problems via Quantum Relaxations,* `arXiv:2111.03167 `__" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:54 msgid "Set up a combinatorial optimization problem" -msgstr "" +msgstr "Configurar un problema de optimización combinatoria" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:56 msgid "In this tutorial, we will consider a random max-cut problem instance and use QRAO to try to find a maximum cut; in other words, a partition of the graph's vertices (nodes) into two sets that maximizes the number of edges between the sets." -msgstr "" +msgstr "En este tutorial, consideraremos una instancia de problema max-cut aleatorio y usaremos QRAO para intentar encontrar un corte máximo; en otras palabras, una partición de los vértices (nodos) del grafo en dos conjuntos que maximiza el número de aristas entre los conjuntos." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:58 msgid "To begin, we utilize the ``Maxcut`` class from Qiskit Optimization's application module. It allows us to generate a ``QuadraticProgram`` representation of the given graph." -msgstr "" +msgstr "Para comenzar, utilizamos la clase ``Maxcut`` del módulo de aplicación de Qiskit Optimization. Nos permite generar una representación ``QuadraticProgram`` del grafo dado." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:60 msgid "Note that once our problem has been represented as a ``QuadraticProgram``, it will need to be converted to the correct type, a `quadratic unconstrained binary optimization (QUBO) `__ problem, so that it is compatible with QRAO. A ``QuadraticProgram`` generated by ``Maxcut`` is already a QUBO, but if you define your own problem be sure you convert it to a QUBO before proceeding. Here is `a tutorial `__ on converting ``QuadraticPrograms``." -msgstr "" +msgstr "Ten en cuenta que una vez que nuestro problema se haya representado como un ``QuadraticProgram``, será necesario convertirlo al tipo correcto, un problema de `optimización binaria cuadrática sin restricciones (QUBO) `__, para que sea compatible con QRAO. Un ``QuadraticProgram`` generado por ``Maxcut`` ya es un QUBO, pero si defines tu propio problema, asegúrate de convertirlo en un QUBO antes de continuar. Aquí hay `un tutorial `__ sobre la conversión de ``QuadraticPrograms``." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:163 msgid "Encode the problem into a quantum Hamiltonian" -msgstr "" +msgstr "Codificar el problema en un Hamiltoniano cuántico" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:165 msgid "Once we have appropriately configured our problem, we proceed to encode it using the ``QuantumRandomAccessEncoding`` class from the ``qrao`` module. This encoding step allows us to generate a quantum Hamiltonian operator that represents our problem. In particular, we employ a Quantum Random Access Code (QRAC) to encode multiple classical binary variables (corresponding to the nodes of our max-cut graph) into each qubit." -msgstr "" +msgstr "Una vez que hemos configurado adecuadamente nuestro problema, procedemos a codificarlo usando la clase ``QuantumRandomAccessEncoding`` del módulo ``qrao``. Este paso de codificación nos permite generar un operador Hamiltoniano cuántico que representa nuestro problema. En particular, empleamos un código cuántico de acceso aleatorio (QRAC) para codificar múltiples variables binarias clásicas (correspondientes a los nodos de nuestro grafo max-cut) en cada qubit." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:167 msgid "It's important to note that the resulting \"relaxed\" Hamiltonian, produced by this encoding, will not be diagonal. This differs from the standard workflow in ``qiskit-optimization``, which typically generates a diagonal (Ising) Hamiltonian suitable for optimization using a ``MinimumEigenOptimizer``. You can find a tutorial on the ``MinimumEigenOptimizer`` `here `__." -msgstr "" +msgstr "Es importante señalar que el Hamiltoniano \"relajado\" resultante, producido por esta codificación, no será diagonal. Esto difiere del flujo de trabajo estándar en ``qiskit-optimization``, que normalmente genera un Hamiltoniano diagonal (Ising) adecuado para la optimización utilizando un ``MinimumEigenOptimizer``. Puedes encontrar un tutorial sobre ``MinimumEigenOptimizer`` `aquí `__." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:169 msgid "In our encoding process, we employ a :math:`(3,1,p)-`\\ QRAC, where each qubit can accommodate a maximum of 3 classical binary variables. The parameter :math:`p` represents the bit recovery probability achieved through measurement. Depending on the nature of the problem, some qubits may have fewer than 3 classical variables assigned to them. To evaluate the compression achieved, we can examine the ``compression_ratio`` attribute of the encoding, which provides the ratio between the number of original binary variables and the number of qubits used (at best, a factor of 3)." -msgstr "" +msgstr "En nuestro proceso de codificación, empleamos un :math:`(3,1,p)-`\\ QRAC, donde cada qubit puede acomodar un máximo de 3 variables binarias clásicas. El parámetro :math:`p` representa la probabilidad de recuperación de bits lograda mediante la medición. Dependiendo de la naturaleza del problema, algunos qubits pueden tener asignadas menos de 3 variables clásicas. Para evaluar la compresión lograda, podemos examinar el atributo ``compression_ratio`` de la codificación, que proporciona la relación entre el número de variables binarias originales y el número de qubits utilizados (en el mejor de los casos, un factor de 3)." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:249 msgid "Solve the problem using the ``QuantumRandomAccessOptimizer``" -msgstr "" +msgstr "Resolver el problema usando el ``QuantumRandomAccessOptimizer``" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:251 msgid "Having successfully encoded our input problem as a relaxed Hamiltonian, we proceed to solve it using the ``QuantumRandomAccessOptimizer``. This optimizer allows us to find an approximate solution to the relaxed problem by leveraging quantum computing techniques." -msgstr "" +msgstr "Habiendo codificado con éxito nuestro problema de entrada como un Hamiltoniano relajado, procedemos a resolverlo usando el ``QuantumRandomAccessOptimizer``. Este optimizador nos permite encontrar una solución aproximada al problema relajado aprovechando técnicas de computación cuántica." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:253 msgid "To set up the optimizer, we need to specify two crucial components:" -msgstr "" +msgstr "Para configurar el optimizador, necesitamos especificar dos componentes cruciales:" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:255 msgid "**Minimum Eigensolver**: We specify a minimum eigensolver to heuristically search for the ground state of the relaxed problem Hamiltonian. As an example, we can use the Variational Quantum Eigensolver (VQE). For simulation purposes, we'll employ an simulator, but you can choose a quantum device as the backend if desired." -msgstr "" +msgstr "**Solucionador Propio Mínimo**: Especificamos un solucionador propio mínimo para buscar heurísticamente el estado fundamental del problema de Hamiltoniano relajado. Como ejemplo, podemos utilizar el Solucionador Propio Variacional Cuántico (Variational Quantum Eigensolver, VQE). Para fines de simulación, emplearemos un simulador, pero puedes elegir un dispositivo cuántico como backend si lo deseas." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:256 msgid "**Rounding Scheme**: To map the ground state results back to a solution for the original problem, we specify a rounding scheme. By default, the ``SemideterministicRounding`` is used, but alternative scheme, ``MagicRounding``, is also available." -msgstr "" +msgstr "**Esquema de Redondeo**: Para asignar los resultados del estado fundamental a una solución para el problema original, especificamos un esquema de redondeo. De forma predeterminada, se utiliza el ``SemideterministicRounding``, pero también está disponible el esquema alternativo, ``MagicRounding``." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:302 msgid "Finally, we move forward with solving the problem by invoking the ``solve()`` method. It's important to note that when calling ``solve()``, we pass the ``problem`` itself as an argument. Although we previously used ``encode()`` in ``QuantumRandomAccessEncoding`` to provide a clear understanding of the flow, ``solve(problem)`` automatically encodes the problem internally using ``QuantumRandomAccessEncoding``. This provides a streamlined and simplified workflow that eliminates the need for explicit encoding steps." -msgstr "" +msgstr "Finalmente, avanzamos en la resolución del problema invocando el método ``solve()``. Es importante tener en cuenta que cuando llamamos a ``solve()``, pasamos el ``problem`` mismo como argumento. Aunque anteriormente usamos ``encode()`` en ``QuantumRandomAccessEncoding`` para proporcionar una comprensión clara del flujo, ``solve(problem)`` codifica automáticamente el problema internamente usando ``QuantumRandomAccessEncoding``. Esto proporciona un flujo de trabajo optimizado y simplificado que elimina la necesidad de pasos de codificación explícitos." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:305 msgid "The result is provides us as a ``QuantumRandomAccessOptimizationResult``. The ``x`` contains the binary values representing the best solution found, while the ``fval`` contains the corresponding objective value." -msgstr "" +msgstr "El resultado se nos proporciona como ``QuantumRandomAccessOptimizationResult``. La ``x`` contiene los valores binarios que representan la mejor solución encontrada, mientras que el ``fval`` contiene el valor objetivo correspondiente." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:307 msgid "The ``relaxed_fval`` provides the expectation value of the relaxed Hamiltonian, adjusted to be in the units of the original optimization problem. For maximization problems, the best possible relaxed function value will always be greater than or equal to the best possible objective function value of the original problem. In practice, this often holds true for the best found value and best found objective function value as well." -msgstr "" +msgstr "El ``relaxed_fval`` proporciona el valor esperado del Hamiltoniano relajado, ajustado para estar en las unidades del problema de optimización original. Para problemas de maximización, el mejor valor posible de la función relajada siempre será mayor o igual al mejor valor posible de la función objetivo del problema original. En la práctica, esto suele ser válido también para el mejor valor encontrado y el mejor valor de la función objetivo encontrado." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:369 msgid "Interpret the solution" -msgstr "" +msgstr "Interpretar la solución" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:380 msgid "In the context of `max-cut `__, the result's \"optimal value\" tells us which subset each node belongs to given the partition found by the optimizer." -msgstr "" +msgstr "En el contexto de `max-cut `__, el \"valor óptimo\" del resultado nos dice a qué subconjunto pertenece cada nodo dada la partición encontrada por el optimizador." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:440 msgid "Inspect the results of subroutines" -msgstr "" +msgstr "Inspeccionar los resultados de las subrutinas" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:451 msgid "The `MinimumEigensolverResult `__ that results from performing VQE on the relaxed Hamiltonian is available:" -msgstr "" +msgstr "El `MinimumEigensolverResult `__ que resulta de aplicar VQE en el Hamiltoniano relajado está disponible:" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:497 msgid "The result of the rounding scheme is also worth considering. In this example, we used the ``SemideterministricRounding``. It's important to note that with semi-deterministic rounding, a single sample is generated as the result, making it the optimal solution candidate." -msgstr "" +msgstr "También vale la pena considerar el resultado del esquema de redondeo. En este ejemplo, utilizamos el ``SemideterministricRounding``. Es importante tener en cuenta que con el redondeo semideterminista, se genera una única muestra como resultado, lo que la convierte en la solución candidata óptima." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:499 msgid "However, if we use the ``MagicRounding`` instead, multiple samples would be generated, each with a probability associated with it. These probabilities sum up to one, providing a distribution of potential optimal solutions." -msgstr "" +msgstr "Sin embargo, si utilizamos ``MagicRounding`` en su lugar, se generarían múltiples muestras, cada una con una probabilidad asociada. Estas probabilidades suman uno, lo que proporciona una distribución de posibles soluciones óptimas." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:546 msgid "Exact Problem Solution with the ``NumpyMinimumEigensolver``" -msgstr "" +msgstr "Solución Exacta del Problema con ``NumpyMinimumEigensolver``" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:548 msgid "To assess the performance of QRAO in approximating the optimal solution, we can utilize the ``NumpyMinimumEigensolver``, an exact classical optimizer. We can obtain the exact optimal solution to the problem as follows:" -msgstr "" +msgstr "Para evaluar el rendimiento de QRAO en la aproximación de la solución óptima, podemos utilizar ``NumpyMinimumEigensolver``, un optimizador clásico exacto. Podemos obtener la solución óptima exacta del problema de la siguiente manera:" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:606 msgid "The approximation ratio (QRAO's objective function value divided by the optimal objective function value) tells us how closely QRAO approximated the optimal solution to the problem." -msgstr "" +msgstr "La relación de aproximación (el valor de la función objetivo de QRAO dividido por el valor de la función objetivo óptima) nos dice qué tan cerca se aproximó QRAO a la solución óptima del problema." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:660 msgid "Solve the problem using the ``QuantumRandomAccessOptimizer`` with ``MagicRounding``" -msgstr "" +msgstr "Resolver el problema usando el ``QuantumRandomAccessOptimizer`` con ``MagicRounding``" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:662 msgid "Magic rounding is a quantum technique employed to map the ground state results of our encoded Hamiltonian back to a solution of the original problem. Unlike semi-deterministic rounding, magic rounding requires a quantum backend, which can be either hardware or a simulator. The backend is passed to the ``MagicRounding`` class through a ``Sampler``, which also determines the total number of shots (samples) that magic rounding will utilize. Note that to specify the backend, you need to choose a ``Sampler`` from providers such as Aer or IBM Runtime. Consequently, we need to specify ``Estimator`` and ``Sampler`` for the optimizer and the rounding scheme, respectively." -msgstr "" +msgstr "El redondeo mágico es una técnica cuántica empleada para mapear los resultados del estado fundamental de nuestro Hamiltoniano codificado hasta una solución del problema original. A diferencia del redondeo semideterminista, el redondeo mágico requiere un backend cuántico, que puede ser hardware o un simulador. El backend se pasa a la clase ``MagicRounding`` a través de un ``Sampler``, que también determina el número total de iteraciones (muestras) que utilizará el redondeo mágico. Ten en cuenta que para especificar el backend, debes elegir un ``Sampler`` de proveedores como Aer o IBM Runtime. En consecuencia, necesitamos especificar ``Estimador`` y ``Sampler`` para el optimizador y el esquema de redondeo, respectivamente." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:665 msgid "In practice, users may choose to set a significantly higher number of magic rounding shots compared to the shots used by the minimum eigensolver for the relaxed problem. This difference arises because the minimum eigensolver estimates expectation values, while the magic rounding scheme returns the sample corresponding to the maximum function value found. The number of magic rounding shots directly impacts the diversity of the computational basis we can generate. When estimating an expectation value, increasing the number of shots enhances the convergence to the true value. However, when aiming to identify the largest possible function value, we often sample from the tail of a distribution of outcomes. As a result, until we observe the highest value outcome in our distribution, each additional shot increases the expected return value." -msgstr "" +msgstr "En la práctica, los usuarios pueden optar por establecer un número significativamente mayor de iteraciones de redondeo mágico en comparación con los disparos utilizados por el solucionador propio mínimo para el problema relajado. Esta diferencia surge porque el solucionador propio mínimo estima los valores esperados, mientras que el esquema de redondeo mágico devuelve la muestra correspondiente al valor máximo de función encontrado. La cantidad de iteraciones de redondeo mágico impacta directamente en la diversidad de la base computacional que podemos generar. Al estimar un valor esperado, aumentar el número de iteraciones mejora la convergencia al valor real. Sin embargo, cuando pretendemos identificar el valor de función más grande posible, a menudo tomamos muestras de la cola de una distribución de resultados. Como resultado, hasta que observemos la salida de mayor valor en nuestra distribución, cada iteración adicional aumenta el valor de retorno esperado." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:668 msgid "In this tutorial, we use the ``Estimator`` for solving the relaxed Hamiltonian and the ``Sampler`` for performing magic rounding. Here, 10 times as many shots are used in the ``Sampler``. As the number of qubits increases, you may need more shots or ``weighted`` basis sampling, as explained above.\"" -msgstr "" +msgstr "En este tutorial, utilizamos el ``Estimator`` para resolver el Hamiltoniano relajado y el ``Sampler`` para realizar el redondeo mágico. Aquí se utilizan 10 veces más iteraciones en el ``Sampler``. A medida que aumenta el número de qubits, es posible que necesites más iteraciones o muestreos de base``weighted``, como se explicó anteriormente." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:759 msgid "Since magic rounding relies on nondeterministic measurements, the method collects a number of samples based on the shots count provided to the ``Sampler`` mentioned earlier. These samples are then consolidated, taking into account duplicates and calculating the empirical probability for each ``SolutionSample``. Each sample in the consolidation process includes a corresponding function value (``fval``)." -msgstr "" +msgstr "Dado que el redondeo mágico se basa en mediciones no deterministas, el método recopila una cantidad de muestras en función del recuento de iteraciones proporcionado al ``Sampler`` mencionado anteriormente. Luego, estas muestras se consolidan, teniendo en cuenta los duplicados y calculando la probabilidad empírica para cada ``SolutionSample``. Cada muestra en el proceso de consolidación incluye un valor de función correspondiente (``fval``)." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:761 msgid "From the consolidated samples, we select the sample with the \"optimal\" function value. In the case of a max-cut problem, this means choosing the sample with the largest function value as our solution." -msgstr "" +msgstr "De las muestras consolidadas, seleccionamos la muestra con el valor de función \"óptimo\". En el caso de un problema de máximo corte, esto significa elegir la muestra con el valor de función más grande como nuestra solución." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:843 msgid "Alternative: Solve the Problem in Two Explicit Steps" -msgstr "" +msgstr "Alternativa: Resolver el Problema en dos Pasos Explícitos" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:845 msgid "In the previous part of this tutorial, we utilized the ``qrao.solve()`` method, which solved the encoded problem (the ground state of the relaxed Hamiltonian) and performed rounding to map the ground state results back to a solution of the original problem. However, it is also possible to explicitly break down the calculation into these two distinct steps. This can be beneficial, especially when comparing solutions obtained across multiple rounding schemes applied to a candidate ground state." -msgstr "" +msgstr "En la parte anterior de este tutorial, utilizamos el método ``qrao.solve()``, que resolvió el problema codificado (el estado fundamental del Hamiltoniano relajado) y realizamos un redondeo para mapear los resultados del estado fundamental a una solución del problema original. Sin embargo, también es posible dividir explícitamente el cálculo en estos dos pasos distintos. Esto puede resultar beneficioso, especialmente al comparar soluciones obtenidas a través de múltiples esquemas de redondeo aplicados a un estado fundamental candidato." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:847 msgid "In this section, we will explore how to perform each of these steps explicitly." -msgstr "" +msgstr "En esta sección, exploraremos cómo realizar cada uno de estos pasos de forma explícita." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:850 msgid "Manually solve the relaxed problem." -msgstr "" +msgstr "Resuelve manualmente el problema relajado." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:852 msgid "Let's start by invoking the ``qrao.solve_relaxed()`` method to directly solve the relaxed problem encoded by ``QuantumRandomAccessEncoding``. This method allows us to focus solely on solving the relaxed problem without performing rounding." -msgstr "" +msgstr "Comencemos invocando al método ``qrao.solve_relaxed()`` para resolver directamente el problema relajado codificado por ``QuantumRandomAccessEncoding``. Este método nos permite centrarnos únicamente en resolver el problema relajado sin realizar redondeo." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:854 msgid "By invoking ``qrao.solve_relaxed()``, we obtain two essential outputs:" -msgstr "" +msgstr "Al invocar ``qrao.solve_relaxed()``, obtenemos dos salidas esenciales:" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:856 msgid "``MinimumEigensolverResult``: This object contains the results of running the minimum eigen optimizer such as the VQE on the relaxed problem. It provides information about the eigenvalue, and other relevant details. You can refer to the Qiskit Algorithms `documentation `__ for a comprehensive explanation of the entries within this object." -msgstr "" +msgstr "``MinimumEigensolverResult``: este objeto contiene los resultados de ejecutar el optimizador propio mínimo, como el VQE, en el problema relajado. Proporciona información sobre el valor propio y otros detalles relevantes. Puedes consultar la `documentación `__ de Qiskit Algorithms para obtener una explicación completa de las entradas dentro de este objeto." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:857 msgid "``RoundingContext``: This object encapsulates essential information about the encoding and the solution of the relaxed problem in a form that is ready for consumption by the rounding schemes." -msgstr "" +msgstr "``RoundingContext``: este objeto encapsula información esencial sobre la codificación y la solución del problema relajado en una forma que esté lista para ser consumida por los esquemas de redondeo." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:983 msgid "Manually perform rounding on the relaxed problem results" -msgstr "" +msgstr "Realiza manualmente el redondeo de los resultados del problema relajado" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:985 msgid "Next, we proceed with rounding the results obtained from solving the relaxed problem. To achieve this, we call the ``round()`` method on an instance of the desired rounding scheme and pass it the ``RoundingContext`` object. Below, we provide an example for both rounding schemes, utilizing the relaxed solution obtained in the previous step." -msgstr "" +msgstr "Luego, se procede a redondear los resultados obtenidos al resolver el problema relajado. Para lograr esto, llamamos al método ``round()`` en una instancia del esquema de redondeo deseado y le pasamos el objeto ``RoundingContext``. A continuación, proporcionamos un ejemplo para ambos esquemas de redondeo, utilizando la solución relajada obtenida en el paso anterior." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:987 msgid "By manually performing the rounding step, we have more flexibility and control over the rounding scheme applied to the relaxed problem results. This allows for greater exploration and comparison of different rounding strategies." -msgstr "" +msgstr "Al realizar manualmente el paso de redondeo, tenemos más flexibilidad y control sobre el esquema de redondeo aplicado a los resultados relajados del problema. Esto permite una mayor exploración y comparación de diferentes estrategias de redondeo." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:1108 msgid "Appendix" -msgstr "" +msgstr "Apéndice" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:1111 msgid "How to verify correctness of your encoding" -msgstr "" +msgstr "Cómo verificar la exactitud de tu codificación" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:1113 msgid "We assume for sake of the QRAO method that **the relaxation commutes with the objective function.** This notebook demonstrates how one can verify this for any problem (a ``QuadraticProgram`` in the language of Qiskit Optimization). One might want to verify this for pedagogical purposes, or as a sanity check when investigating unexpected behavior with the QRAO. Any problem that does not commute should be considered a bug, and if such a problem is discovered, we encourage that you submit it as `an issue on GitHub `__." -msgstr "" +msgstr "Por el método QRAO, asumimos que **la relajación conmuta con la función objetivo.** Este cuaderno demuestra cómo se puede verificar esto para cualquier problema (un ``QuadraticProgram`` en el lenguaje de Qiskit Optimization). Es posible que desees verificar esto con fines pedagógicos o como punto de control al investigar un comportamiento inesperado con el QRAO. Cualquier problema que no conmute debe considerarse un error y, si se descubre dicho problema, te recomendamos que lo envíes como `un problema en GitHub `__." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:1116 msgid "The ``EncodingCommutationVerifier`` class allows one to conveniently iterate over all decision variable states and compare each objective value with the corresponding encoded objective value, in order to identify any discrepancy." -msgstr "" +msgstr "La clase ``EncodingCommutationVerifier`` permite iterar convenientemente sobre todos los estados de las variables de decisión y comparar cada valor objetivo con el valor objetivo codificado correspondiente, para identificar cualquier discrepancia." #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:1215 msgid "As before, we ``encode()`` the problem using the QuantumRandomAccessEncoding class:" -msgstr "" +msgstr "Como antes, ``encode()`` el problema usando la clase QuantumRandomAccessEncoding:" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:1284 msgid "Finally, we iterate over every decision variable state using ``EncodingCommutationVerifier`` and verify that, in each case, the problem objective value matches the encoded objective value:" -msgstr "" +msgstr "Finalmente, iteramos sobre cada estado de variable de decisión usando ``EncodingCommutationVerifier`` y verificamos que, en cada caso, el valor objetivo del problema coincida con el valor objetivo codificado:" #: ../../tutorials/12_quantum_random_access_optimizer.ipynb:1316 msgid "If you are able to construct a problem that causes a violation, it is quite possible that you have discovered a bug in the ``QuantumRandomAccessEncoding`` logic. We would greatly appreciate it if you could share the problem with us by `submitting it as an issue `__ on GitHub." -msgstr "" +msgstr "Si puedes crear un problema que cause una infracción, es muy posible que hayas descubierto un error en la lógica de ``QuantumRandomAccessEncoding``. Te agradeceríamos mucho si pudieras compartir el problema con nosotros `enviándolo como un problema `__ en GitHub."