From 3dbb4059e946ae916c1403bcb9fe11c05952cdb7 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Mon, 5 Feb 2024 13:07:00 -0500 Subject: [PATCH] New Crowdin translations by GitHub Action (#757) Co-authored-by: Crowdin Bot --- .../ja/api/migration-guides/_toc.json | 2 +- .../ja/api/migration-guides/qiskit-1.0.mdx | 684 ++++++++++++++++++ translations/ja/run/_toc.json | 4 + translations/ja/run/native-gates.mdx | 103 +++ translations/ja/run/primitives.mdx | 6 +- translations/ja/run/processor-types.mdx | 6 + translations/ja/start/install.mdx | 48 +- .../ja/transpile/transpiler-stages.ipynb | 67 +- 8 files changed, 908 insertions(+), 12 deletions(-) create mode 100644 translations/ja/api/migration-guides/qiskit-1.0.mdx create mode 100644 translations/ja/run/native-gates.mdx diff --git a/translations/ja/api/migration-guides/_toc.json b/translations/ja/api/migration-guides/_toc.json index cf22b2e430..def59a0ce9 100644 --- a/translations/ja/api/migration-guides/_toc.json +++ b/translations/ja/api/migration-guides/_toc.json @@ -41,4 +41,4 @@ ] } ] -} \ No newline at end of file +} diff --git a/translations/ja/api/migration-guides/qiskit-1.0.mdx b/translations/ja/api/migration-guides/qiskit-1.0.mdx new file mode 100644 index 0000000000..674bb89ab5 --- /dev/null +++ b/translations/ja/api/migration-guides/qiskit-1.0.mdx @@ -0,0 +1,684 @@ +--- +title: Qiskit 1.0 installation and packaging changes +description: Adapt to changes in installing and depending on Qiskit 1.0 +--- + +# Qiskit 1.0 packaging changes + +Qiskit 1.0 uses a different packaging structure than previous Qiskit versions and might cause problems in environments that use packages that are not ready for Qiskit 1.0. + + +Do not try to upgrade an existing Python virtual environment to Qiskit 1.0 in-place. + + +This guide is divided into the following sections. You only need to review the sections that are relevant to you. + +- Users should read the [For users](#for-users) section. +- If you develop or maintain a package that depends on Qiskit, read the [For developers](#for-developers) section. +- If you are interested, review the [What is changing and why it changed](#why-did-this-happen) section. +- If you encounter problems installing or importing Qiskit 1.0, review the [Troubleshooting](#troubleshooting) section. + + +## For users + +You must start a new virtual environment to install Qiskit 1.0. +It is very tricky and error-prone to upgrade an existing installation in-place to Qiskit 1.0. + + +The examples in this section use the `venv` module that is part of the Python standard library. +If you use a different tool, such as `virtualenv` or `conda`, consult its documentation for help. + +For Linux and macOS commands, a bash-like syntax is used. +PowerShell is used for Windows commands. + + + + +### Create the new environment + +1. Create a new virtual environment, using your preferred version of Python 3.8 or later. Use any path you choose in place of `/path/to/qiskit-1.0-venv`. + + ```` + + + ```bash + python3 -m venv /path/to/qiskit-1.0-venv + ``` + + + + ```bash + python3 -m venv /path/to/qiskit-1.0-venv + ``` + + + + ```powershell + python3 -m venv C:\path\to\qiskit-1.0-venv + ``` + + + ```` + + +2. Activate the environment. + +```` + + + ```bash + source /path/to/qiskit-1.0-venv/bin/activate + ``` + + + + ```bash + source /path/to/qiskit-1.0-venv/bin/activate + ``` + + + + ```powershell + C:\path\to\qiskit-1.0-venv\Scripts\activate.ps1 + ``` + + +```` + +3. Install packages as desired. + You should do this by using only one `pip install` command with all the dependencies on it. + + ```bash + pip install 'qiskit>=1' + ``` + + You can optionally include additional packages by including them as arguments. For example: + + ```bash + pip install 'qiskit>=1' jupyterlab pandas matplotlib + ``` + + Qiskit 1.0 includes breaking changes, so several packages are marked as not-yet-compatible with it. Therefore, you might see errors from `pip` until new versions of those packages are released. Old versions of packages might also depend on the legacy `qiskit-terra` package. Such packages might not return errors when running this command, but might raise an error when running `import qiskit`. You should not install any packages that depend directly on `qiskit-terra`. + + + One way to require `pip` to forbid `qiskit-terra` from individual `install` commands is to use [a constraints file](https://pip.pypa.io/en/stable/user_guide/#constraints-files) that requires that `qiskit-terra` is set to an impossible version. + For example, a constraints file that includes the line `qiskit-terra>=1.0` will mean that if a dependency attempts to install `qiskit-terra`, no published versions will match the requirements. + + We have provided such a file in a GitHub Gist at , which you can use like this: + + ```bash + pip install -c https://qisk.it/1-0-constraints qiskit [other packages] + ``` + + If a package requires `qiskit-terra`, you will see [a resolution failure](#pip-resolution-impossible). + + + + + Do not install packages that are incompatible with Qiskit 1.0 on this virtual environment. If you need to use such packages, install them in a separate virtual environment with Qiskit 0.45 or 0.46. + + + If you have an existing environment, you can use [`pipdeptree`](https://github.com/tox-dev/pipdeptree/blob/main/README.md#pipdeptree) to query the requirements of your installed packages to see if they require `qiskit<1`. For any that require `qiskit<1`, check for updates that make it compatible with Qiskit 1.0. + + If you encounter issues, consult the [troubleshooting](#troubleshooting) section, or ask on [Qiskit Slack](https://qisk.it/join-slack). If you think there is a bug, you can [create an issue against Qiskit](https://github.com/Qiskit/qiskit/issues/new/choose). + +4. If you are not planning to use the environment immediately, use the `deactivate` command to leave it. + + +### Use the new environment + +Each time you start a new command line session, you must "activate" the environment by running the `activate` command: + +```` + + + ```bash + source /path/to/qiskit-1.0-venv/bin/activate + ``` + + + + ```bash + source /path/to/qiskit-1.0-venv/bin/activate + ``` + + + + ```powershell + C:\path\to\qiskit-1.0-venv\Scripts\activate.ps1 + ``` + + +```` + + +## For developers + +If you maintain a package that depends on Qiskit, use this information to learn how to correctly express your compatibility and test against Qiskit 1.0. + +### Recommendations for requirements + +We recommend that your package requires `qiskit>=0.45,<1` (or other appropriate lower bound) if you are not certain whether the package is compatible with Qiskit 1.0. +This is [the same recommendation being made for NumPy 2.0 compatibility.](https://github.com/numpy/numpy/issues/24300) + +A Qiskit 1.0 release candidate, version 1.0.0rc1, will be released on 1 February 2024. +You should test your package against this, and as soon as possible, release a new (compatible) version of your package with its upper requirement unpinned. + +### Recommendations for testing against Qiskit 1.0 + +These recommendations apply to testing proactively against the Qiskit `main` branch, and to testing against the 1.0.0rc1 (and later, if applicable) release candidate. + +We do not recommend initially branch-protecting on CI success against the Qiskit `main` branch because Qiskit changes could prevent you from merging PRs. +After the release of Qiskit release candidates, and after all of your package's dependencies support Qiskit 1.0, we _do_ recommend branch-protecting on success against the latest release candidate, to ensure that the package remains compatible with Qiskit 1.0. + +If neither your package, nor any of its transitive dependencies, has a requirement pin on `qiskit<1`, you should create a testing virtual environment as you normally would, in a single `pip install` command, and directly specify `qiskit==1.0.0rc1` or `qiskit==git+https://github.com/Qiskit/qiskit.git@main` as appropriate. +This is the most reliable way to ensure that you have a completely valid environment. + +If the only component of your package's dependency graph that has a requirement pin on `qiskit<1` is your own package, you might want to have your CI suite first temporarily patch your requirements file to allow Qiskit 1.0, and then install the environment in a single step as before. +Alternatively, use the following rules for general-purpose environment upgrades, but switch to single-environment resolution as soon as feasible. + +If at least one of your transitive dependencies does not yet have a release version that allows Qiskit 1.0 support, you must make manual changes. +There are several strategies to try, in approximate order of preference (most preferable to least): + +- Install the problematic dependency from its own `main` branch, if its development version has relaxed the pin, so you can build the test environment in a single step. +- Exclude the use of that dependency from the test environment, if possible. +- Create a test environment in the same way you would normally, and then manually override it to use Qiskit 1.0. + +#### Manually upgrade an existing environment + + +This process deliberately creates an invalid environment. Therefore, any test using it is less valid. Tests might appear to pass, but this does not guarantee that the package is compatible with Qiskit 1.0. This could happen because the environment is not self-consistent and could contain files that do not exist in a valid environment, or the behavior of an overridden package might change with Qiskit 1.0. + + + +If one of your dependencies pins `qiskit<1` even on their development branch, it might not work in any way with Qiskit 1.0, and if your tests cannot run because of this, you might have to wait for them (or work with them) to become compatible. + + +To upgrade an environment in situ, follow these steps: + +1. Create an environment as usual, ensuring that there are no packages that extend the `qiskit` or `qiskit.providers` namespace installed. + +2. Uninstall both `qiskit` and `qiskit-terra` to make sure that neither is present: + +```bash +pip uninstall --yes qiskit qiskit-terra +``` + + At this point, the environment's `site-packages` should not contain a `qiskit` directory. You don't need to verify this on every CI run, but if you are debugging a script locally, follow these steps to verify: + +1. Run the follwing command from within the `python` of the virtual environment: + +```` +```python +import site +print(site.getsitepackages()) +``` +```` + +2. Verify that those directories do not contain a `qiskit` directory. If they do, you likely have namespace-extending packages installed, and you should find these and remove the dependency. + +3. Install the target version of Qiskit 1.0 with one of these commands: + +- After the desired release candidate has been published: + ```bash + pip install 'qiskit==1.0.0rc1' + ``` +- For a `main`-branch dependency (or substitute whatever `git` revision identifier you prefer after the `@`). + ```bash + pip install 'git+https://github.com/Qiskit/qiskit.git@main' + ``` + +You now have an environment that Qiskit allows you to test in. If `import qiskit` results in an `ImportError`, or if you are struggling to find your dependencies, see the advice in the section about the [invalid-environment protections](#qiskit-1.0-import-error) in Qiskit. + +#### Sample manual GitHub Actions workflows + +The following workflows set up a scheduled job to run overnight. This job sets up a testing environment for Qiskit 1.0 and runs `pytest` (or whatever test steps you need). + +For a package that has no transitive dependencies `qiskit<1`: + +```yaml +on: + schedule: + - cron: '0 3 * * *' +jobs: + test_main: + name: Test Qiskit main + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.10' + - name: Create environment + run: | + set -e + # First ensure the standard tools are up-to-date. + python -m pip install --upgrade pip wheel setuptools + # Note that this resolves everything in a single command. + # If it fails, at least one package likely requires `qiskit<1`. + python -m pip install --upgrade \ + -c constraints.txt \ + -r requirements-dev.txt \ + . \ + 'git+https://github.com/Qiskit/qiskit.git@main' + - name: Run tests + run: pytest +``` + +For a package that has unavoidable transitive dependencies that pin `qiskit<1`, build an invalid environment: + +```yaml +on: + schedule: + - cron: '0 3 * * *' +jobs: + test_main: + name: Test Qiskit main + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.10' + - name: Create environment + run: | + set -e + python -m pip install --upgrade pip wheel setuptools + # Install the regular test environment. + python -m pip install --upgrade \ + -c constraints.txt \ + -r requirements-dev.txt \ + . + # Uninstall `qiskit` and `qiskit-terra`. + python -m pip uninstall --yes qiskit qiskit-terra + # Install the new version of Qiskit + python -m pip install 'git+https://github.com/Qiskit/qiskit.git@main' + - name: Run tests + run: pytest +``` + +#### Sample `tox` configuration + +The following are examples of `tox.ini` sections to build a testing environment for Qiskit 1.0 and run `pytest` (or whatever test steps you need). + +If nothing prevents Qiskit 1.0 from being installed in a valid environment: + +```ini +[tox] +minversion = 4.0.0 + +# This environment section should set up your regular test build. +# We'll extend it after, and this one is just an example. +[testenv] +install_command = pip install -c {toxinidir}/constraints.txt -U {opts} {packages} +deps = + -r{toxinidir}/requirements-dev.txt +commands = + pytest + +# This is an override environment to install Qiskit main. +# We're assuming that you have a requirement like `qiskit>=0.45` +# in your packages metadata requirements. +[testenv:qiskit-main] +# Inherit the base dependencies, and add the additional requirement. +deps = + [{testenv}deps] + git+https://github.com/Qiskit/qiskit@main +# All other options, like the `commands` section, are inherited from `testenv`. +``` + +If your package or a transitive dependency has an unavoidable pin on `qiskit<1`, we recommend doing this testing using the manual environment construction as in the above section, because `tox` introduces several complexities by being more strict about environment isolation and installation order. +This is correct behavior by `tox` (we shouldn't construct an invalid environment), but because we already know we're building an invalid environment, these checks get in the way. + +```ini +[tox] +minversion = 4.0.0 + +# This environment section should set up your regular test build. +# We'll extend it later. This is just an example. +[testenv] +install_command = pip install -c {toxinidir}/constraints.txt -U {opts} {packages} +deps = + -r{toxinidir}/requirements-dev.txt +commands = + pytest + +[testenv:qiskit-main] +# Set a sequence of commands to run in the environment after everything has been installed, +# but before the main test suite. +commands_pre = + pip uninstall --yes qiskit qiskit-terra + pip install 'git+https://github.com/Qiskit/qiskit@main' +# All other sections, like the dependencies and the 'commands' section are inherited. +``` + + +## Why these changes happened + +This section contains detailed information about pre-1.0 Qiskit packaging and why we made the breaking packaging change. + +We know that the change is inconvenient, but this restores Qiskit to the simple package structure that most Python packages use, which will be easier for users, developers, and library authors after the Qiskit 1.0 transition is complete. + + +This section uses some Python-packaging jargon to better explain what was happening. +The following words have special meanings: + +- _module_: A single Python file. + +- _package_: A directory containing an `__init__.py` and other files or packages that Python can read. + This is the actual code as installed on your system, and is what executes when you run `import something`. + Python considers any directory that is on the search path to be something you can import (and will import many additional items). + + This is not the same object that you `pip install` (which is a _distribution_), but typically what you `pip install` and what you `import` have the same name. + +- _submodule_, _subpackage_: These are imprecise terms, but are commonly used. + The _sub_ part means "contained inside a package". + A submodule is a module and a subpackage is a package, but they are part of a larger package. + +- _namespace package_: A package that can have submodules or subpackages installed into it by other _distributions_. + Critically, no one distribution contributing to a namespace package necessarily owns all the installed files, so it can be tricky to completely uninstall + or upgrade one. + +- _distribution_: The compressed Python files, data files, and metadata that are downloaded when you run `pip install something`. + Often, a distribution contains exactly one package and the metadata about how to install it (its requirements and so on), but this is not required. + A distribution can contain zero or more modules or packages. + + If you are familiar with "package managers" outside the context of Python, such as `apt` from Debian/Ubuntu or Homebrew on macOS, then what they call a "package", Python calls a distribution, and there is no exact match for what Python calls a package. + + Most sources talking about Python packaging use the term _package_ to mean both distributions and packages, and you must refer to the context to understand what is meant. + In general, if you `import` it, the source means "package", and if you `pip install` it, the source means "distribution". + +- _search path_: When trying to `import something`, Python searches a predefined list of places for a module or package called `something`. + The list of places is the _search path_. + You can see and modify the search path in `sys.path`. + +- _requirement_: A distribution contains information on other distributions it depends on when installed. + Any other distribution that is necessary is a _requirement_, and the package manager (usually `pip` or `conda`) should ensure that all requirements are installed with compatible versions. + +Python is highly dynamic, and many complexities can arise; for example, it's possible that a module or package does not correspond to files on disk, or that they are compiled extensions. +The search path is not only a search over directories, but for this discussion, only files on disk are relevant. +Further complications aren't necessary to understand the problems described in this section, so you can use the model described above. + + + +### The old Qiskit structure + +Historically, Qiskit was comprised of many Python distributions: `qiskit-terra`, the compiler core; `qiskit-aer`, the high-performance simulator; the original IBM Quantum provider; and several now-obsolete packages providing particular exploratory algorithmic or experiment-running features. +For user ease, we also provided a Python distribution called `qiskit`, which contained no code of its own, but caused all the other components to be installed. +We called this the _metapackage_, by analogy to similar concepts in other package managers. +The code of the core of Qiskit lived in `qiskit-terra`, which owned the root of the Python package `qiskit`. In other words, `qiskit-terra` controlled what happened when you ran `import qiskit`. +Until Qiskit 1.0, the `qiskit` package was a namespace package and contained a second namespace package at `qiskit.providers`. + +This organization caused us and our users quite a few problems. + +For example, downstream libraries that depended on Qiskit often only actually needed the compiler core, and did not require the rest of the large ecosystem that came with `pip install qiskit`. +They would therefore correctly specify their requirement as `qiskit-terra`. +However, when people tried to uninstall Qiskit by running `pip uninstall qiskit`, `pip` encountered problems: + +- `pip` does not remove distributions that are now unused. So `pip uninstall qiskit` did almost nothing; there was no code in the distribution, so no code was removed. +- Even if it were to remove code, many downstream distributions would remain installed because they depended on `qiskit-terra`. +- Even if `qiskit-terra` was uninstalled, it might still leave an importable `qiskit` directory with no usable code, because it was a namespace package. + +When installing or upgrading distributions with a `pip install` command, `pip` also does not take into account previous requirement resolutions. +Because there were two packages, upgrading a package that required `qiskit-terra` to be upgraded caused an invalid environment; `pip` upgraded `qiskit-terra` but left `qiskit` untouched. +It issued a warning on this and all subsequent `pip install` commands, but because nothing appeared broken, users typically ignored the warning, and `pip` did not raise an error status or forbid operations. + +Over time, we removed elements from the `qiskit` metapackage until, starting with Qiskit 0.44, only `qiskit-terra` remains. +Of these components, `qiskit-aer` still exists and is actively updated, but it is now installed as a separate distribution. + +Similarly, we ever more strongly discouraged other libraries from using the namespace hooks. +We removed the last Qiskit use of the hooks in non-obsolete packages with the release of Qiskit Aer 0.11 and its new `qiskit_aer` Python package, although until Qiskit 1.0 we also forced the namespace path `qiskit.providers.aer` to work. +Starting with Qiskit 1.0, we have removed the ability for packages to extend any `qiskit` namespace. Thus, `pip uninstall` on the correct distribution in a valid environment now works as expected. + +### The new Qiskit structure + +Starting with version 1.0, Qiskit comprises a single distribution, called `qiskit`, which installs one single package, also called `qiskit`, which owns all the code contained in its directory. +This is the normal structure of Python code, and is the simplest and least error-prone structure. + +The `qiskit-terra` distribution on PyPI will never be updated to version 1.0 or beyond; it is entirely superseded by `qiskit`. +The name `qiskit-terra` is no longer involved in the installation. +However, the `qiskit-terra` package is not being removed from PyPI, and we will leave its most recent version in a working state, so old scientific code and legacy packages can more easily continue to use it. + +Unfortunately, because of the metapackage legacy and deficiencies in `pip` as a package manager, it is not possible for us to make a completely smooth upgrade path for users to Qiskit 1.0, especially while some packages depend on earlier versions of Qiskit, and some require only Qiskit 1.0+. +These problems will lessen as more of the ecosystem migrates to Qiskit 1.0. + + +We will not make similar breaking packaging changes in the future. +This is a one-time event, at the release of Qiskit 1.0, specifically so that our packaging story will be as easy as possible in the future. + + + +## Troubleshooting + +The packaging changes around Qiskit 1.0 are tricky, and Python's standard tool `pip` is not rich enough in some ways for us to communicate the changes in the distribution structures to it, which unfortunately might cause issues for users. +We have tried to make Qiskit fail quickly and loudly if it detects an invalid environment, without false positives. +We understand that users might find it annoying to get the error message, but in our experience, it's much better to be aware of the problem right away than for things to appear to be working on the surface, only to fail in subtle ways in the future. + +This section contains packaging errors that you might see, and describes how to resolve them. + +Most of these problems are not unique to Qiskit, so the advice is likely relevant, even if the problematic parts are not related to Qiskit. + +### `import qiskit` says "ModuleNotFoundError: No module named 'qiskit'" + +Python cannot find your Qiskit installation. + +If you definitely installed Qiskit, then you probably do not have the correct virtual environment activated. +See the [section on activating a virtual environment](#activating-a-venv) for instructions. + +If you are using Jupyter and see this, ensure that Jupyter is installed into the same virtual environment as Qiskit. +Exit Jupyter, activate the Qiskit virtual environment on the command line, run `pip install jupyterlab` (or whichever notebook interface you use), then reopen Jupyter. + +### `import qiskit` succeeds, but trying to do anything returns "AttributeError: module 'qiskit' has no attribute '...'" + +This likely means that your environment had an old version of Qiskit in it alongside a package that extended its namespace (such as old versions of Qiskit Aer, or the long-obsolete Qiskit IBMQ Provider), and then Qiskit was uninstalled. +The easiest thing to do is to start a new virtual environment, and only install recent, non-obsolete packages into it. + +If you have just started a new virtual environment, or you're sure that legacy packages are not the problem, make sure that your current working directory (the directory your shell session was in when you launched Python / Jupyter) does not contain a folder called `qiskit`. +Python's default rules search the current working directory very early in the search path when trying to `import` a module, so a directory with a duplicate name can cause import problems. + + +### `pip` refuses to install some packages together + +After running a `pip install` command with many items on it, you might see an error such as: + +```text +ERROR: Cannot install qiskit-dynamics==0.4.4 and qiskit==1.0.0 because these package versions have conflicting dependencies. + +The conflict is caused by: + The user requested qiskit==1.0.0 + qiskit-dynamics 0.4.4 depends on qiskit<1.0 + +To fix this you could try to: +1. loosen the range of package versions you've specified +2. remove package versions to allow pip attempt to solve the dependency conflict + +ERROR: ResolutionImpossible: for help visit https://pip.pypa.io/en/latest/topics/dependency-resolution/#dealing-with-dependency-conflicts +``` + +This describes a true resolution conflict; there is no valid way to install all of these distributions at the same time. + +In the context of Qiskit 1.0, this is likely because one of the distributions you are trying to install contains a requirement like `qiskit<1.0`. +This means that the developers of that distribution have marked it as not (yet) compatible with Qiskit 1.0. + +You can (politely) ask those developers when they will release a new version of their package that is compatible with Qiskit 1.0, but first check that they have no open issue or pull request already asking for this wherever they accept comments. +Be mindful that this takes time; please give the developers a month or so to prepare new versions of their distributions! +Until then, you cannot install that distribution alongside Qiskit 1.0. +To continue using that distribution, create a new virtual environment and use Qiskit 0.45 or 0.46 (or whichever version it supports) alongside that other package. + + +If you get this error, **do not** try to build the environment by calling `pip install` several times. +Those commands will probably not fail, but you will have created an invalid environment. +You would likely then see some of the other error messages described in this section. + + +You can also read [the documentation from the Python packaging authority about conflict resolution](https://pip.pypa.io/en/latest/topics/dependency-resolution/#dealing-with-dependency-conflicts). + +### `pip` succeeds but prints errors after running `pip install` commands + +You might see an error in the output of `pip`, such as the following: + +```text +ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behavior is the source of the following dependency conflicts. +some-distribution 0.4.4 requires qiskit>=0.44,<1, but you have qiskit 1.0.0 which is incompatible. +``` + +The top line usually appears verbatim (as of `pip` 23.3), but second line changes depending on the exact problem, and there may be several lines like it. +`pip` is likely to then indicate that it did whatever you wanted successfully, despite the error message. + +This means that the environment is in conflict and you cannot be sure that it will work correctly. +To solve the problem, examine the list of messages from `pip` and determine if you need all of the packages that have conflicting requirements. +Sometimes there will be true conflicts between dependencies; you might need multiple virtual environments to separate out dependencies that have incompatible requirements. + +The safest choice is to begin a new virtual environment (or more than one, if there are true conflicts), then delete the one in conflict. + +When setting up virtual environments, run only one `pip install` command that includes all the dependencies you need. +This is the most reliable way for `pip` to find a properly resolved environment with no conflicts. +If you keep having problems with conflicts after setting up environments, avoid running any further `pip install` or `pip uninstall` commands; `pip` does not guarantee to keep the environment coherent on subsequent commands. + + +If you are concerned about working with multiple virtual environments, rest assured that Python development and use often involve several virtual environments. It's common and good practice to create new ones to work on separate projects. +When you're done with a virtual environment, you can simply delete its directory; there is no reason to keep multiple environments permanently. + + + +### `import qiskit` raises `ImportError` + +When running `import qiskit`, you might see an error such as: + +> ImportError: Qiskit is installed in an invalid environment that has both Qiskit 1.0+ and an earlier version. +> You should create a new virtual environment, and ensure that you do not mix dependencies between Qiskit pre-1.0 and post-1.0. +> Any packages that depend on 'qiskit-terra' are not compatible with Qiskit 1.0 and will need to be updated. +> Qiskit unfortunately cannot enforce this requirement during environment resolution. + + +You might have run a completely valid `pip install` command, following all the recommendations in this guide, and still see this error message. +This is not your fault, but the error message is still correct, and Qiskit cannot safely load. + + +The error means that Qiskit is installed in an invalid environment that includes both Qiskit 1.0 and an earlier version. +This is characterized by the `qiskit-terra` distribution being installed alongside Qiskit 1.0. +You can check what distributions are installed by running `pip list`, but you cannot fix this by simply uninstalling `qiskit-terra`. + +Unfortunately, `qiskit>=1.0` and `qiskit-terra` are conflicting distributions, and cannot both be installed together. +Even more unfortunately, _we cannot communicate this conflict to `pip`_ because of limitations in its metadata system. + +This error most frequently arises in one of two situations: + +- You ran something like `pip install 'qiskit>=1' something-else`, and `something-else` has a requirement on `qiskit-terra`. +- You tried to run `pip install -U qiskit` in an existing environment. + +In both of these cases, there is no guarantee that `pip` will return a helpful message to you. + + +One way to require `pip` to forbid `qiskit-terra` from individual `install` commands is to use [a constraints file](https://pip.pypa.io/en/stable/user_guide/#constraints-files) that requires that `qiskit-terra` is set to an impossible version. +For example, a constraints file that includes the line `qiskit-terra>=1.0` will mean that if a dependency attempts to install `qiskit-terra`, no published versions will match the requirements. + +We have provided such a file in a GitHub Gist at , which you can use like this: + +```bash +pip install -c https://qisk.it/1-0-constraints qiskit [other packages] +``` + +If a package requires `qiskit-terra`, you will see [a resolution failure](#pip-resolution-impossible). + + + + +#### Create a working environment for Qiskit 1.0 + +No matter how this happened, it is much easier to make a new virtual environment. + +First, we need to find out which packages are introducing a dependency on `qiskit-terra`. +Using the broken environment, install `pipdeptree` from PyPI. This is a tool for generating dependency graphs: + +```bash +pip install pipdeptree +``` + +Ask it which packages are introducing dependencies on `qiskit-terra` and `qiskit` (these are two separate commands): + +```bash +pipdeptree --reverse --package qiskit-terra +``` + +```bash +pipdeptree --reverse --package qiskit +``` + +The outputs might look something like: + +```text +qiskit-terra==0.45.2 +└── qiskit-dynamics==0.4.2 [requires: qiskit-terra>=0.23.0] +``` + +```text +qiskit==1.0.0 +├── qiskit-aer==0.13.2 [requires: qiskit>=0.45.0] +└── qiskit-ibm-provider==0.8.0 [requires: qiskit>=0.45.0] +``` + +In the above example, we have two distributions that have declared themselves compatible with Qiskit 1.0 (`qiskit-aer` and `qiskit-ibm-provider`), and one that still has a dependency on `qiskit-terra`. + + +This example is a flat dependency structure. +You might see a much deeper tree than this. +The packages that are directly dependent on `qiskit-terra` (lowest indentation) are most likely to be the problematic ones, but one farther down the tree could be problematic if it depends on a specific old version of some other package that has already been updated. + + +Seeing a dependency on `qiskit-terra` can mean one of a few things: + +- The dependent is an old package, and will not be updated to support Qiskit 1.0. + + In this case, there is no chance of using the package with Qiskit 1.0, and you will need to continue using a previous version of Qiskit. + Typically this is characterized by the dependent being at its latest version (assuming the environment is new, and you didn't pin it lower) and having a direct requirement on `qiskit-terra`. + +- The dependent is a package that is actively maintained, but does not yet support Qiskit 1.0. + + In this case, you will need to wait for the developers to release a compatible version - please be patient! + Typically this is characterized by the installed distribution _not_ being at its latest version, even though your installation command did not specify a version. + You can check the latest release version of the distribution by finding its page on https://pypi.org/. + + `pip` likely searched old versions of the package until it found one (possibly from months or years ago) that depended only on `qiskit-terra`. + + This is what has happened in the example above. At the time this document was created, `qiskit-dynamics==0.4.4` was the latest release version. + +If you constructed this environment out of several `pip install` commands (such as if the environment is old and has been updated), first try to install all of your packages by using a single `pip install` command when you build a new environment. +If the problem persists, at least one of the packages you want likely does not support Qiskit 1.0 yet, and `pip` is finding an old version that it believes will work because it doesn't know about the `qiskit>=1`/`qiskit-terra` conflict. + +Instead, use the `pipdeptree` commands to identify which dependencies do not yet support Qiskit 1.0. +Exclude any packages that do not yet support Qiskit 1.0 when constructing a Qiskit 1.0 environment, or continue to use a prior version of Qiskit. +See [Create the new environment](#creating-a-venv) for instructions. + + +The example in this section was generated before Qiskit 1.0 was released. + +The "old" distribution in question (`qiskit-dynamics`) was behaving correctly; it was not known to support Qiskit 1.0 yet, so it marked that in its requirements. +It's not possible to backdate requirements changes to previously released versions, and `pip` will search arbitrarily far back to locate something that works when building an environment. + + + + +#### Create a working environment for Qiskit 0.45 or 0.46 + +If you have a broken environment after trying to install Qiskit 0.45 or 0.46, the most likely situation is that `pip` installed Qiskit 1.0 because it tried to pick the latest versions of packages, even though it was not required. +The easiest way to fix this is to create a new virtual environment, then run a single `pip install` command that has all the packages you need, plus an explicit `'qiskit<1'` entry. +If `pip` successfully resolves this dependency graph, you should have a working virtual environment. +If at least one distribution requires Qiskit 1.0 or greater, `pip` should give you an error message explaining this, which looks like the one in [the section on failed resolutions](#pip-resolution-impossible). + +You can also use the `pipdeptree` commands listed in [Create a working environment for Qiskit 1.0](#debug-venv-for-1.0) from within the broken environment to determine which distributions have an explicit requirement on `qiskit>=1`. + +#### I'm a developer, my environments are definitely right, and I'm still getting the error + +First: you must be _absolutely_ certain that your environments are correct. +The test that Qiskit uses to determine a broken environment is quite robust; specifically, it queries `importlib.metadata` for distribution information on installed packages and checks the version numbers returned. +The Qiskit 1.0 side of the test also checks for sentinel files that were present in old Qiskit versions and not Qiskit 1.0. + +If you are a Qiskit developer, it's possible that you have old `qiskit.egg-info` or `qiskit-terra.egg-info` (or `*.dist-info`) directories present on your meta path (see `sys.meta_path`), left over from old editable installations. +In particular, check your working directory for any `*.egg-info` and `*.dist-info` directories. +If they're in the root of one of your checked out repositories, you can delete them. The worst that can happen is you might need to `pip install -e .` again, and even that is unlikely, because these are typically just part of the `setuptools` build process that doesn't get cleaned up. + +If the above information does not help you and you are 100% sure that your environment is sound (or you are deliberately trying to test a broken environment): + +1. [Create an issue in Qiskit](https://github.com/Qiskit/qiskit/issues/new/choose) explaining how this happened and why you are sure the environment is correct so we can fix it. +2. You can suppress the exception by setting the environment variable `QISKIT_SUPPRESS_1_0_IMPORT_ERROR=1`. diff --git a/translations/ja/run/_toc.json b/translations/ja/run/_toc.json index fd17b68342..3d39037251 100644 --- a/translations/ja/run/_toc.json +++ b/translations/ja/run/_toc.json @@ -97,6 +97,10 @@ "title": "Get backend information with Qiskit", "url": "/run/get-backend-information" }, + { + "title": "Native gates and operations", + "url": "/run/native-gates" + }, { "title": "Retired systems", "url": "/run/retired-systems" diff --git a/translations/ja/run/native-gates.mdx b/translations/ja/run/native-gates.mdx new file mode 100644 index 0000000000..e70db29044 --- /dev/null +++ b/translations/ja/run/native-gates.mdx @@ -0,0 +1,103 @@ +--- +title: Native gates and operations +description: Summary of the native gates and operations supported by IBM Quantum systems +--- + +# Native gates and operations + +Each [processor family](processor-types) has a native gate set. By default, the systems in each family only support running the gates and operations in the native gate set. Thus, every gate in the circuit must be translated (by the transpiler) to the elements of this set. + +You can view the native gates and operations for a system either [with Qiskit](#native-gates-with-qiskit) or on the IBM Quantum Platform [Compute resources page](#native-gates-on-platform). + + +The terms native gates and basis gates are often used interchangeably. However, you can specify a different set of basis gates to use, while the native gate set never changes. For information about changing the basis gates, see the [Represent quantum computers](../transpile/representing_quantum_computers#basis-gates) topic. + + +## Find the native gate set for a system + + +### With Qiskit + +```python + +from qiskit_ibm_runtime import QiskitRuntimeService + +service = QiskitRuntimeService(channel="ibm_quantum") + +for backend in service.backends(): + config = backend.configuration() + if "simulator" in config.backend_name: + continue + print(f"Backend: {config.backend_name}") + print(f" Processor type: {config.processor_type}") + print(f" Supported instructions:") + for instruction in config.supported_instructions: + print(f" {instruction}") + print() +``` + + +### On IBM Quantum Platform + +Select any system on the [Compute resources](https://quantum.ibm.com/services/resources) tab. The default gates for that system are listed under Details. Note that the non-unitary operations are not listed here; use the method in Qiskit described above to see all native gates and operations for a system. + +## Tables of gates and operations, by processor family + +### Heron + +| Name | Notes | +| :----------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | +| [CZ](/api/qiskit/qiskit.circuit.library.CZGate) | two-qubit gate | +| [RZ](/api/qiskit/qiskit.circuit.library.RZGate) | single-qubit gate | +| [SX](/api/qiskit/qiskit.circuit.library.SXGate) | single-qubit gate | +| [X](/api/qiskit/qiskit.circuit.library.XGate) | single-qubit gate | +| [ID](/api/qiskit/qiskit.circuit.library.IGate) | single-qubit gate wait cycle | +| [reset](/api/qiskit/qiskit.circuit.library.Reset) | single-qubit gate, non-unitary; not the same as the initialization done at the start of a circuit to prepare the all 0's state | +| [if_else](/api/qiskit/qiskit.circuit.IfElseOp) | control flow for classical feedforward | +| [for_loop](/api/qiskit/qiskit.circuit.ForLoopOp) | control flow for classical feedforward | +| [switch_case](/api/qiskit/qiskit.circuit.SwitchCaseOp) | control flow for classical feedforward | +| [measure](/api/qiskit/qiskit.circuit.library.Measure) | | +| [delay](/api/qiskit/qiskit.circuit.Delay) | | + +### Eagle + +| Name | Notes | +| :----------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | +| [ECR](/api/qiskit/qiskit.circuit.library.ECRGate) | two-qubit gate | +| [RZ](/api/qiskit/qiskit.circuit.library.RZGate) | single-qubit gate | +| [SX](/api/qiskit/qiskit.circuit.library.SXGate) | single-qubit gate | +| [X](/api/qiskit/qiskit.circuit.library.XGate) | single-qubit gate | +| [ID](/api/qiskit/qiskit.circuit.library.IGate) | single-qubit gate wait cycle | +| [reset](/api/qiskit/qiskit.circuit.library.Reset) | single-qubit gate, non-unitary; not the same as the initialization done at the start of a circuit to prepare the all 0's state | +| [if_else](/api/qiskit/qiskit.circuit.IfElseOp) | control flow for classical feedforward | +| [for_loop](/api/qiskit/qiskit.circuit.ForLoopOp) | control flow for classical feedforward | +| [switch_case](/api/qiskit/qiskit.circuit.SwitchCaseOp) | control flow for classical feedforward | +| [measure](/api/qiskit/qiskit.circuit.library.Measure) | | +| [delay](/api/qiskit/qiskit.circuit.Delay) | | + +### Falcon + +| Name | Notes | +| :----------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------- | +| [CX](/api/qiskit/qiskit.circuit.library.CXGate) | two-qubit gate | +| [RZ](/api/qiskit/qiskit.circuit.library.RZGate) | single-qubit gate | +| [ID](/api/qiskit/qiskit.circuit.library.IGate) | single-qubit gate wait cycle | +| [reset](/api/qiskit/qiskit.circuit.library.Reset) | single-qubit gate, non-unitary; not the same as the initialization done at the start of a circuit to prepare the all 0's state | +| [if_else](/api/qiskit/qiskit.circuit.IfElseOp) | control flow for classical feedforward | +| [for_loop](/api/qiskit/qiskit.circuit.ForLoopOp) | control flow for classical feedforward | +| [switch_case](/api/qiskit/qiskit.circuit.SwitchCaseOp) | control flow for classical feedforward | +| [measure](/api/qiskit/qiskit.circuit.library.Measure) | | +| [delay](/api/qiskit/qiskit.circuit.Delay) | | + + + +The `init_qubits` flag, set as a [primitive execution option,](/api/qiskit-ibm-runtime/qiskit_ibm_runtime.options.ExecutionOptions) controls whether qubits are reset to the zero state at the start of each circuit. Its default value is `True`, indicating that the qubits should be reset. If `False`, the qubits will begin in the final state from the previous shot, and you must manually insert [resets](/api/qiskit/qiskit.circuit.library.Reset) if you want to reset them to the zero state. If a job consists of multiple circuits, then the shots are executed in a "round-robin" fashion. That is, each circuit will be executed in sequence to obtain one shot from each circuit. This process is then repeated until the requested number of shots has been obtained from all circuits. + + + +## Next steps + + + - Read about basis gates in the [Represent quantum computers](../transpile/representing_quantum_computers#basis-gates) topic. + - Apply your knowledge of basis gates to one of these [workflow example tutorials.](https://learning.quantum.ibm.com/catalog/tutorials?category=workflow-example) + diff --git a/translations/ja/run/primitives.mdx b/translations/ja/run/primitives.mdx index cbf3240a77..e0f9a96578 100644 --- a/translations/ja/run/primitives.mdx +++ b/translations/ja/run/primitives.mdx @@ -5,15 +5,15 @@ description: Introduction to primitives in Qiskit and Qiskit Runtime, and an exp # Introduction to primitives -Computing systems are built upon multiple layers of **abstraction**. Abstractions allow to focus on a +Computing systems are built upon multiple layers of abstraction. Abstractions allow us to focus on a particular level of detail relevant to the task at hand. The closer you get to the hardware, the lower the level of abstraction you'll need (for example, you could want to manipulate electrical signals), and vice versa, the more complex the task you want to perform, the higher-level the abstractions will be (for example, you could be using a programming library to perform algebraic calculations). -In this context, a **primitive** is the smallest processing instruction, the simplest building block from which -one can create something **useful** for a given **abstraction** level. +In this context, a primitive is the smallest processing instruction, the simplest building block from which +one can create something useful for a given abstraction level. The recent progress in quantum computing has increased the need to work at higher levels of abstraction. As we move towards larger systems and more complex workflows, the focus shifts from interacting with individual diff --git a/translations/ja/run/processor-types.mdx b/translations/ja/run/processor-types.mdx index 8613d7dcd3..c780a659e5 100644 --- a/translations/ja/run/processor-types.mdx +++ b/translations/ja/run/processor-types.mdx @@ -19,6 +19,8 @@ At 133 qubits, Heron is an [Eagle](#eagle)-sized upgrade to [Egret](#egret) that - [View available Heron systems](https://quantum.ibm.com/services/resources?tab=systems&type=Heron) +- [Native gates and operations](native-gates): `cz, id, delay, measure, reset, rz, sx, x, if_else, for_loop, switch_case` + ## Osprey ![Osprey processor icon](/images/run/processor-types/osprey.svg) @@ -39,6 +41,8 @@ See [this blog post](https://research.ibm.com/blog/127-qubit-quantum-processor-e - [View available Eagle systems](https://quantum.ibm.com/services/resources?tab=systems&type=Eagle) +- [Native gates and operations](native-gates): `ecr, id, delay, measure, reset, rz, sx, x, if_else, for_loop, switch_case` + `r3` (December 2022) Eagle r3 is a version of the 127-qubit processor with enhanced coherence properties but otherwise similar design parameters to Eagle r1. @@ -89,6 +93,8 @@ The Falcon family of devices offers a valuable platform for medium-scale circuit - [View available Falcon systems](https://quantum.ibm.com/services/resources?tab=systems&type=Falcon) +- [Native gates and operations](native-gates): `cx, id, delay, measure, reset, rz, sx, x, if_else, for_loop, switch_case` + `r8` (September 2021) In addition to the features of r5.11, Falcon r8 has enhanced coherence properties. diff --git a/translations/ja/start/install.mdx b/translations/ja/start/install.mdx index 7a51f9df18..f0ed155728 100644 --- a/translations/ja/start/install.mdx +++ b/translations/ja/start/install.mdx @@ -11,7 +11,7 @@ description: Qiskit および Qiskit Runtime を様々なオペレーティン ## Install and set up Qiskit with the Qiskit Runtime client -1. Python をインストールします。 どのバージョンの Python がサポートされているかを判別するには、[setup.py](https://github.com/Qiskit/qiskit/blob/main/setup.py) ファイルで要件を確認してください。 ダウンロード手順については、[Python Beginners Guide（Python 初心者ガイド）](https://wiki.python.org/moin/BeginnersGuide/Download) をご覧ください。 +1. Python をインストールします。 Check the "Programming Language" section on the [Qiskit PyPI project page](https://pypi.org/project/qiskit/) to determine which Python versions are supported by the most recent release. ダウンロード手順については、[Python Beginners Guide（Python 初心者ガイド）](https://wiki.python.org/moin/BeginnersGuide/Download) をご覧ください。 Qiskit と他のアプリケーションを分離するには、[Python 仮想環境](https://docs.python.org/3.10/tutorial/venv.html) を使用することをお勧めします。 また、Qiskit の操作には、[Jupyter](https://jupyter.org/install) 開発環境の使用をお勧めします。 @@ -211,6 +211,52 @@ described in more detail below. Release schedule + +A tentative release schedule is included below: + +![Tentative Qiskit release schedule](/images/start/install/release_schedule.png) + +For an up-to-date release schedule, refer to the Qiskit Github project's [milestones list](https://github.com/Qiskit/qiskit/milestones), which will always contain the current release plan. + +With the release of a new major version, the previous major version is supported +for at least six months; only bug and security fixes are accepted during this time and only patch releases are published for this major version. A final +patch version is published when support is dropped, and that release +also documents the end of support for that major version series. A longer +support window is needed for the previous major version as this gives downstream +Qiskit consumers and their users a chance to migrate their code. +Downstream libraries that +depend on Qiskit should not raise their minimum required Qiskit version to a new +major version immediately after its release because the library's user base needs time +to migrate to the new API changes. Having an extended support window +for the previous major Qiskit version gives downstream projects time to ensure +compatibility with the next major version. Downstream projects can provide +support for two release series at a time to give their users a migration path. + +For the purposes of semantic versioning, the Qiskit public API is considered +any documented module, class, function, or method that is not marked as private +(with an underscore `_` prefix). However, there can be explicit exceptions made for +specific documented APIs. In such cases, these APIs will be clearly documented +as not being considered stable interfaces yet, and a user-visible warning will be +actively emitted on any use of these unstable interfaces. Additionally, in some +situations, an interface marked as private is considered part of the public +API. Typically this only occurs in two cases: either an abstract interface +definition where subclasses are intended to override/implement a private method +as part of defining an implementation of the interface, or advanced-usage +low-level methods that have stable interfaces but are not considered safe to use, +as the burden is on the user to uphold the class/safety invariants themselves +(the canonical example of this is the `QuantumCircuit._append` method). + +The supported Python versions, minimum supported Rust version (for building +Qiskit from source), and any Python package dependencies (including the minimum +supported versions of dependencies) used by Qiskit are not part of the backwards +compatibility guarantees and may change during any release. Only minor or major +version releases will raise minimum requirements for using or building Qiskit +(including adding new dependencies), but patch fixes might include support for +new versions of Python or other dependencies. Usually the minimum version of a +dependency is only increased when older dependency versions go out of support or +when it is not possible to maintain compatibility with the latest release of the +dependency and the older version. +
diff --git a/translations/ja/transpile/transpiler-stages.ipynb b/translations/ja/transpile/transpiler-stages.ipynb index fce23d68cb..499092d0b4 100644 --- a/translations/ja/transpile/transpiler-stages.ipynb +++ b/translations/ja/transpile/transpiler-stages.ipynb @@ -39,7 +39,7 @@ "The next stage involves the layout or connectivity of the backend a circuit will be sent to. In general, quantum circuits are abstract entities whose qubits are \"virtual\" or \"logical\" representations of actual qubits used in computations. To execute a sequence of gates, a one-to-one mapping from the \"virtual\" qubits to the \"physical\" qubits in an actual quantum device is necesary. This mapping is stored as a `Layout` object.\n", "\n", "\n", - "![This image illustrates qubits being mapped from the wire representation to a diagram that represents how the qubits are connected on the system.](/images/transpile/layout-mapping.png \"Qubit mapping\")\n", + "![This image illustrates qubits being mapped from the wire representation to a diagram that represents how the qubits are connected on the system.](/images/transpile/transpiler-stages/layout-mapping.png \"Qubit mapping\")\n", "\n", "The choice of mapping is extremely important for minimizing the number of SWAP operations needed to map the input circuit onto the device topology and ensure the most well-calibrated qubits are used. Due to the importance of this stage, the preset pass managers try a few different methods to find the best layout. Typically this involves two steps: first, try to find a \"perfect\" layout (a layout that does not require any SWAP operations), and then, a heuristic pass that tries to find the best layout to use if a perfect layout cannot be found. There are two `Passes` typically used for this first step:\n", "\n", @@ -62,8 +62,7 @@ "\n", "However, finding the optimal SWAP mapping is hard. In fact, it is an NP-hard problem, and is thus prohibitively expensive to compute for all but the smallest quantum devices and input circuits. To work around this, Qiskit uses a stochastic heuristic algorithm called `SabreSwap` to compute a good, but not necessarily optimal, SWAP mapping. The use of a stochastic method means that the circuits generated are not guaranteed to be the same over repeated runs. Indeed, running the same circuit repeatedly results in a distribution of circuit depths and gate counts at the output. It is for this reason that many users choose to run the routing function (or the entire `StagedPassManager`) many times and select the lowest-depth circuits from the distribution of outputs.\n", "\n", - "For example, this is a GHZ circuit executed 100 times, using a “bad” (disconnected) `initial_layout`:\n", - "![This image shows a circuit with 14 qubits.](/images/transpile/transpiler-11.png \"Result from a disconnected initial layout\")\n" + "For example, let's take a 15-qubit GHZ circuit executed 100 times, using a “bad” (disconnected) `initial_layout`." ] }, { @@ -85,7 +84,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAArwAAAISCAYAAAAurBzdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAs7UlEQVR4nO3de5TVdb34/9ceLgMiM8CowAgIiIXmFS84eckLgawOaKBYmSJ6TstCT8q3MirEG2GWWa4wtYPDspORZnnpoikKpoIgimnnRMDBIGEGRZkJlAGdz++PlvNz4joDw97z5vFYa6/VfD6f/dkv3gz2XJ/12XvnsizLAgAAElWU7wEAAKAlCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaW3zPUA+1NfXx6pVq6Jz586Ry+XyPQ4AAP8iy7L4xz/+EeXl5VFUtGvXaPfK4F21alX07t0732MAALADK1eujF69eu3SOfbK4O3cuXNE/HMBS0pK8jwNAAD/qra2Nnr37t3QbbtirwzeD25jKCkpEbwAAAVsd9x+6k1rAAAkTfACAJA0wQsAQNIELwAASRO8AAAkTfACAJA0wQsAQNIELwAASRO8AAAkTfACAJA0wQsAQNIELwAASRO8AAAkTfACAJA0wQsAQNIELwAASRO8AAAkTfACAJA0wQsAQNLa5nsAoDA8MGZSvkdocaPvuyHfIwCQB67wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkruOC99tprI5fLNXoMHDiwYf/GjRtj/PjxUVZWFvvuu2+MHj06qqur8zgxAACFrOCCNyLiYx/7WKxevbrh8cwzzzTsu+qqq+KRRx6J+++/P+bMmROrVq2KUaNG5XFaAAAKWdt8D7A1bdu2jR49emyxvaamJqZPnx733ntvnHHGGRERUVlZGYceemjMmzcvTjzxxD09KgAABa4gr/AuWbIkysvLo3///nHBBRfEihUrIiJi4cKFsXnz5hgyZEjDsQMHDow+ffrE3Llz8zUuAAAFrOCu8A4ePDhmzJgRH/3oR2P16tVx3XXXxSmnnBKvvvpqVFVVRfv27aNLly6NntO9e/eoqqra5jnr6uqirq6u4efa2tqWGh8AgAJTcME7fPjwhv995JFHxuDBg+Oggw6K++67Lzp27Nisc06dOjWuu+663TUiAACtSEHe0vBhXbp0iY985COxdOnS6NGjR2zatCnWrVvX6Jjq6uqt3vP7gYkTJ0ZNTU3DY+XKlS08NQAAhaLgg3f9+vWxbNmy6NmzZxx77LHRrl27mDVrVsP+xYsXx4oVK6KiomKb5yguLo6SkpJGDwAA9g4Fd0vDV77ylRgxYkQcdNBBsWrVqpg8eXK0adMmPvvZz0ZpaWlceumlMWHChOjWrVuUlJTEFVdcERUVFT6hAQCArSq44P373/8en/3sZ2Pt2rWx//77x8knnxzz5s2L/fffPyIibr311igqKorRo0dHXV1dDBs2LG6//fY8Tw0AQKEquOCdOXPmdvd36NAhpk2bFtOmTdtDEwEA0JoV/D28AACwKwQvAABJE7wAACRN8AIAkDTBCwBA0gQvAABJE7wAACRN8AIAkDTBCwBA0gQvAABJE7wAACRN8AIAkDTBCwBA0gQvAABJE7wAACRN8AIAkDTBCwBA0gQvAABJE7wAACRN8AIAkDTBCwBA0gQvAABJE7wAACRN8AIAkDTBCwBA0gQvAABJE7wAACRN8AIAkDTBCwBA0gQvAABJE7wAACRN8AIAkDTBCwBA0gQvAABJE7wAACRN8AIAkDTBCwBA0gQvAABJE7wAACRN8AIAkDTBCwBA0gQvAABJE7wAACRN8AIAkDTBCwBA0gQvAABJE7wAACRN8AIAkDTBCwBA0gQvAABJE7wAACRN8AIAkDTBCwBA0gQvAABJE7wAACRN8AIAkDTBCwBA0gQvAABJE7wAACRN8AIAkDTBCwBA0gQvAABJE7wAACRN8AIAkDTBCwBA0gQvAABJE7wAACRN8AIAkDTBCwBA0gQvAABJE7wAACRN8AIAkDTBCwBA0gQvAABJK+jgvemmmyKXy8WVV17ZsG3jxo0xfvz4KCsri3333TdGjx4d1dXV+RsSAICCVrDBu2DBgrjzzjvjyCOPbLT9qquuikceeSTuv//+mDNnTqxatSpGjRqVpykBACh0BRm869evjwsuuCB+8pOfRNeuXRu219TUxPTp0+P73/9+nHHGGXHsscdGZWVlPPfcczFv3rw8TgwAQKEqyOAdP358fOpTn4ohQ4Y02r5w4cLYvHlzo+0DBw6MPn36xNy5c7d5vrq6uqitrW30AABg79A23wP8q5kzZ8aLL74YCxYs2GJfVVVVtG/fPrp06dJoe/fu3aOqqmqb55w6dWpcd911u3tUAABagYK6wrty5cr48pe/HD/72c+iQ4cOu+28EydOjJqamobHypUrd9u5AQAobAUVvAsXLow1a9bEoEGDom3bttG2bduYM2dO3HbbbdG2bdvo3r17bNq0KdatW9foedXV1dGjR49tnre4uDhKSkoaPQAA2DsU1C0NZ555ZrzyyiuNto0bNy4GDhwYV199dfTu3TvatWsXs2bNitGjR0dExOLFi2PFihVRUVGRj5EBAChwBRW8nTt3jsMPP7zRtk6dOkVZWVnD9ksvvTQmTJgQ3bp1i5KSkrjiiiuioqIiTjzxxHyMDABAgSuo4N0Zt956axQVFcXo0aOjrq4uhg0bFrfffnu+xwIAoEAVfPDOnj270c8dOnSIadOmxbRp0/IzEAAArUpBvWkNAAB2N8ELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAElrdvC+8sorcffdd0dtbW3DtnfffTe++MUvxoEHHhgDBgyIO+64Y7cMCQAAzdXs4L3xxhtj0qRJ0blz54Zt3/jGN+LOO++Mf/zjH7Fy5coYP358PP7447tlUAAAaI5mB+/8+fPj9NNPj1wuFxER7733XlRWVsYJJ5wQa9asieXLl8f+++8fP/zhD3fbsAAA0FTNDt433ngjevfu3fDzggULora2Ni677LLo0KFDlJeXx9lnnx0vv/xyk8774x//OI488sgoKSmJkpKSqKioiN///vcN+zdu3Bjjx4+PsrKy2HfffWP06NFRXV3d3D8GAACJa3bwtm3bNurq6hp+nj17duRyuTj99NMbtpWVlcWbb77ZpPP26tUrbrrppli4cGG88MILccYZZ8TZZ58df/7znyMi4qqrropHHnkk7r///pgzZ06sWrUqRo0a1dw/BgAAiWvb3Cf27ds3nnrqqYaf77///ujXr18cdNBBDdtef/31KCsra9J5R4wY0ejnKVOmxI9//OOYN29e9OrVK6ZPnx733ntvnHHGGRERUVlZGYceemjMmzcvTjzxxOb+cQAASFSzr/BeeOGF8fLLL8fgwYPj1FNPjZdffjk+97nPNTrmT3/6UxxyyCHNHu7999+PmTNnxoYNG6KioiIWLlwYmzdvjiFDhjQcM3DgwOjTp0/MnTt3m+epq6uL2traRg8AAPYOzQ7eyy+/PM4777x44YUX4plnnonhw4fHN77xjYb9f/7zn+Pll19uuBLbFK+88krsu+++UVxcHJdddln8+te/jsMOOyyqqqqiffv20aVLl0bHd+/ePaqqqrZ5vqlTp0ZpaWnD48P3HgMAkLZm39JQXFwcv/jFL6K2tjZyuVyjjyeL+GeEvvTSS9G3b98mn/ujH/1oLFq0KGpqauKXv/xljB07NubMmdPcUWPixIkxYcKEhp9ra2tFLwDAXqLZwfv0009H3759o0+fPlvdv99++8W7774bL7/8cpx66qlNOnf79u1jwIABERFx7LHHxoIFC+KHP/xhnH/++bFp06ZYt25do6u81dXV0aNHj22er7i4OIqLi5s0AwAAaWj2LQ2nn356zJgxY7vH3HPPPY0+taG56uvro66uLo499tho165dzJo1q2Hf4sWLY8WKFVFRUbHLrwMAQHqafYU3y7IdHlNfX9/wxRQ7a+LEiTF8+PDo06dP/OMf/4h77703Zs+eHY899liUlpbGpZdeGhMmTIhu3bpFSUlJXHHFFVFRUeETGgAA2KpmB+/OWLJkSZSWljbpOWvWrImLLrooVq9eHaWlpXHkkUfGY489Fp/85CcjIuLWW2+NoqKiGD16dNTV1cWwYcPi9ttvb4nxAQBIQJOC95JLLmn084MPPhivvfbaFse9//77sXLlynj66adj+PDhTRpo+vTp293foUOHmDZtWkybNq1J5wUAYO/UpOD98D27uVwuFi1aFIsWLdrqsblcLo4//vi49dZbd2U+AADYJU0K3uXLl0fEP+/f7d+/f1x55ZXx5S9/eYvj2rRpE127do1OnTrtnikBAKCZmhS8H/7a4MrKyjjmmGMabQMAgELT7DetjR07dnfOAQAALWKXP6Vh/vz5sWDBgli3bl28//77W+zP5XIxadKkXX0ZAABolmYH71tvvRXnnHNOPPvss9v9TF7BCwBAPjU7eCdMmBDPPPNMnHbaaTF27Njo1atXtG3boh/rCwAATdbsQv3Nb34TJ5xwQsyaNavJ36YGAAB7SlFzn/juu+/GqaeeKnYBAChozQ7eo48+eqvfsgYAAIWk2cE7efLkePjhh2PevHm7cx4AANitmn0Pb1VVVXzqU5+KT3ziE3HBBRfEoEGDoqSkZKvHXnTRRc0eEAAAdkUu295nim1HUVFR5HK5Rh9J9q/382ZZFrlcbqufz5tPtbW1UVpaGjU1NduMdNjbPDAm/Y8PHH3fDfkeAYCdtDt7rdlXeCsrK3fphQEAYE/w1cIAACSt2W9aAwCA1qDZV3hXrFix08f26dOnuS8DAAC7pNnB27dv35360olcLhfvvfdec18GAAB2SbOD96KLLtpq8NbU1MTLL78cy5cvj0984hPRt2/fXZkPAAB2SbODd8aMGdvcl2VZ3HLLLXHzzTfH9OnTm/sSAACwy1rkTWu5XC6+8pWvxMc+9rH46le/2hIvAQAAO6VFP6XhuOOOiyeffLIlXwIAALarRYN32bJl3rAGAEBeNfse3m2pr6+P119/PWbMmBEPPfRQnHnmmbv7JQAAYKc1O3iLioq2+7FkWZZF165d45ZbbmnuSwAAwC5rdvCeeuqpWw3eoqKi6Nq1axx//PExbty4OOCAA3ZpQAAA2BXNDt7Zs2fvxjEAAKBltOib1gAAIN92y5vWnn322Vi0aFHU1tZGSUlJHH300XHSSSftjlMDAMAu2aXgfe6552LcuHGxdOnSiPjnG9U+uK/3kEMOicrKyqioqNj1KQEAoJmaHbx//vOfY+jQofHOO+/EJz/5yTj99NOjZ8+eUVVVFU899VT84Q9/iGHDhsW8efPisMMO250zAwDATmt28F5//fWxadOm+N3vfhdnnXVWo31XX311PProozFy5Mi4/vrrY+bMmbs8KAAANEez37Q2e/bsOPfcc7eI3Q+cddZZce6558ZTTz3V7OEAAGBXNTt4a2pqol+/fts9pl+/flFTU9PclwAAgF3W7OAtLy+PefPmbfeY559/PsrLy5v7EgAAsMuaHbwjR46M2bNnx6RJk2Ljxo2N9m3cuDEmT54cTz31VJx99tm7PCQAADRXLsuyrDlPXLt2bQwePDiWL18eZWVlccIJJ0T37t2juro6FixYEG+88Ub0798/5s+fH926ddvdc++S2traKC0tjZqamigpKcn3OFAQHhgzKd8jtLjR992Q7xEA2Em7s9ea/SkNZWVlMW/evPja174WM2fOjN/97ncN+zp06BDjxo2L73znOwUXuwAA7F126Ysn9ttvv7j77rvjzjvvjL/85S8N37Q2cODAaNeu3e6aEQAAmq3JwTtlypTYsGFDXHfddQ1R265duzjiiCMajtm0aVN885vfjM6dO8fXv/713TctAAA0UZPetPbEE0/ENddcE2VlZdu9gtu+ffsoKyuLb37zmz6HFwCAvGpS8N5zzz3RtWvXuPzyy3d47Pjx46Nbt25RWVnZ7OEAAGBXNSl4n3vuuRgyZEgUFxfv8Nji4uIYMmRIPPvss80eDgAAdlWTgnfVqlXRv3//nT6+X79+sXr16iYPBQAAu0uTgreoqCg2b96808dv3rw5ioqa/d0WAACwy5pUo+Xl5fHqq6/u9PGvvvpqHHjggU0eCgAAdpcmBe8pp5wSTz75ZLz22ms7PPa1116LJ598Mk499dTmzgYAALusScE7fvz42Lx5c5x77rnx5ptvbvO4tWvXxnnnnRfvvfdefPGLX9zlIQEAoLma9MUTgwYNiiuvvDJ+8IMfxGGHHRaXXXZZnH766dGrV6+IiHj99ddj1qxZcdddd8Ubb7wREyZMiEGDBrXI4AAAsDOa/E1rt9xyS3To0CG++93vxpQpU2LKlCmN9mdZFm3atImJEyfGjTfeuNsGBQCA5mhy8OZyufj2t78dl156aVRWVsZzzz0XVVVVERHRo0ePOOmkk+Liiy+Ogw8+eLcPCwAATdXk4P3AwQcf7AouAAAFz4fkAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQNMELAEDSBC8AAEkTvAAAJE3wAgCQtLb5HgAA2Ds8MGZSvkdoUaPvuyHfI7ANrvACAJA0wQsAQNIELwAASSu44J06dWocf/zx0blz5zjggAPinHPOicWLFzc6ZuPGjTF+/PgoKyuLfffdN0aPHh3V1dV5mhgAgEJWcME7Z86cGD9+fMybNy8ef/zx2Lx5cwwdOjQ2bNjQcMxVV10VjzzySNx///0xZ86cWLVqVYwaNSqPUwMAUKgK7lMaHn300UY/z5gxIw444IBYuHBhnHrqqVFTUxPTp0+Pe++9N84444yIiKisrIxDDz005s2bFyeeeGI+xgYAoEAV3BXef1VTUxMREd26dYuIiIULF8bmzZtjyJAhDccMHDgw+vTpE3Pnzt3qOerq6qK2trbRAwCAvUNBB299fX1ceeWVcdJJJ8Xhhx8eERFVVVXRvn376NKlS6Nju3fvHlVVVVs9z9SpU6O0tLTh0bt375YeHQCAAlHQwTt+/Ph49dVXY+bMmbt0nokTJ0ZNTU3DY+XKlbtpQgAACl3B3cP7gcsvvzx+85vfxNNPPx29evVq2N6jR4/YtGlTrFu3rtFV3urq6ujRo8dWz1VcXBzFxcUtPTIAAAWo4K7wZlkWl19+efz617+OJ598Mvr169do/7HHHhvt2rWLWbNmNWxbvHhxrFixIioqKvb0uAAAFLiCu8I7fvz4uPfee+Ohhx6Kzp07N9yXW1paGh07dozS0tK49NJLY8KECdGtW7coKSmJK664IioqKnxCAwAAWyi44P3xj38cERGnnXZao+2VlZVx8cUXR0TErbfeGkVFRTF69Oioq6uLYcOGxe23376HJwUAoDUouODNsmyHx3To0CGmTZsW06ZN2wMTAQDQmhXcPbwAALA7CV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICktc33AADsHg+MmZTvEVrU6PtuyPcIsF2p/xuMaL3/Dl3hBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASFrBBe/TTz8dI0aMiPLy8sjlcvHggw822p9lWVxzzTXRs2fP6NixYwwZMiSWLFmSn2EBACh4BRe8GzZsiKOOOiqmTZu21f0333xz3HbbbXHHHXfE888/H506dYphw4bFxo0b9/CkAAC0Bm3zPcC/Gj58eAwfPnyr+7Isix/84AfxrW99K84+++yIiLjnnnuie/fu8eCDD8ZnPvOZPTkqAACtQMFd4d2e5cuXR1VVVQwZMqRhW2lpaQwePDjmzp27zefV1dVFbW1towcAAHuHVhW8VVVVERHRvXv3Rtu7d+/esG9rpk6dGqWlpQ2P3r17t+icAAAUjlYVvM01ceLEqKmpaXisXLky3yMBALCHtKrg7dGjR0REVFdXN9peXV3dsG9riouLo6SkpNEDAIC9Q6sK3n79+kWPHj1i1qxZDdtqa2vj+eefj4qKijxOBgBAoSq4T2lYv359LF26tOHn5cuXx6JFi6Jbt27Rp0+fuPLKK+PGG2+MQw45JPr16xeTJk2K8vLyOOecc/I3NAAABavggveFF16I008/veHnCRMmRETE2LFjY8aMGfG1r30tNmzYEF/4whdi3bp1cfLJJ8ejjz4aHTp0yNfIAAAUsIIL3tNOOy2yLNvm/lwuF9dff31cf/31e3AqAABaq1Z1Dy8AADSV4AUAIGmCFwCApAleAACSJngBAEia4AUAIGmCFwCApAleAACSJngBAEia4AUAIGmCFwCApAleAACSJngBAEia4AUAIGmCFwCApAleAACSJngBAEia4AUAIGmCFwCApAleAACSJngBAEia4AUAIGmCFwCApAleAACSJngBAEia4AUAIGmCFwCApAleAACSJngBAEia4AUAIGmCFwCApAleAACSJngBAEia4AUAIGmCFwCApAleAACSJngBAEia4AUAIGmCFwCApAleAACSJngBAEia4AUAIGmCFwCApAleAACSJngBAEia4AUAIGmCFwCApAleAACSJngBAEia4AUAIGmCFwCApAleAACS1jbfA+wtHhgzKd8jtKjR992Q7xEAALbKFV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJLWaoN32rRp0bdv3+jQoUMMHjw45s+fn++RAAAoQK0yeH/xi1/EhAkTYvLkyfHiiy/GUUcdFcOGDYs1a9bkezQAAApMqwze73//+/Ef//EfMW7cuDjssMPijjvuiH322SfuvvvufI8GAECBaZvvAZpq06ZNsXDhwpg4cWLDtqKiohgyZEjMnTt3q8+pq6uLurq6hp9ramoiIqK2trZlh/2QdzbX7figVmxPriUtI/Xf0Yj0f09T/ztM/e9vb5D67+jeYE/+O/zgtbIs2+VztbrgffPNN+P999+P7t27N9revXv3+Mtf/rLV50ydOjWuu+66Lbb37t27RWbcK5V+N98TwI75PW3d/P1B/uXh3+HatWujtLR0l87R6oK3OSZOnBgTJkxo+Lm+vj7eeuutKCsri1wul8fJWkZtbW307t07Vq5cGSUlJfkeZ69h3fPDuueHdc8P654f1j0/ampqok+fPtGtW7ddPlerC9799tsv2rRpE9XV1Y22V1dXR48ePbb6nOLi4iguLm60rUuXLi01YsEoKSnxDzMPrHt+WPf8sO75Yd3zw7rnR1HRrr/lrNW9aa19+/Zx7LHHxqxZsxq21dfXx6xZs6KioiKPkwEAUIha3RXeiIgJEybE2LFj47jjjosTTjghfvCDH8SGDRti3Lhx+R4NAIAC0yqD9/zzz4833ngjrrnmmqiqqoqjjz46Hn300S3eyLa3Ki4ujsmTJ29xGwcty7rnh3XPD+ueH9Y9P6x7fuzOdc9lu+OzHgAAoEC1unt4AQCgKQQvAABJE7wAACRN8AIAkDTB24pde+21kcvlGj0GDhwYERGvvfbaFvs+eNx///15nrz12t6aR0RUVVXFhRdeGD169IhOnTrFoEGD4oEHHsjjxGnY0bovW7YsPv3pT8f+++8fJSUlMWbMmC2+nIbmef311+Pzn/98lJWVRceOHeOII46IF154oWF/lmVxzTXXRM+ePaNjx44xZMiQWLJkSR4nTsOO1v1Xv/pVDB06tOEbQxctWpS/YROyvXXfvHlzXH311XHEEUdEp06dory8PC666KJYtWpVnqdu/Xb0+37ttdfGwIEDo1OnTtG1a9cYMmRIPP/88016DcHbyn3sYx+L1atXNzyeeeaZiIjo3bt3o+2rV6+O6667Lvbdd98YPnx4nqdu3ba15hERF110USxevDgefvjheOWVV2LUqFExZsyYeOmll/I4cRq2te4bNmyIoUOHRi6XiyeffDKeffbZ2LRpU4wYMSLq6+vzPHXr9vbbb8dJJ50U7dq1i9///vfxP//zP3HLLbdE165dG465+eab47bbbos77rgjnn/++ejUqVMMGzYsNm7cmMfJW7edWfcNGzbEySefHN/5znfyOGladrTu77zzTrz44osxadKkePHFF+NXv/pVLF68OEaOHJnnyVu3nfl9/8hHPhI/+tGP4pVXXolnnnkm+vbtG0OHDo033nhj518oo9WaPHlydtRRR+308UcffXR2ySWXtNxAe4EdrXmnTp2ye+65p9G2bt26ZT/5yU9aeLK0bW/dH3vssayoqCirqalp2LZu3bosl8tljz/++B6aME1XX311dvLJJ29zf319fdajR4/su9/9bsO2devWZcXFxdnPf/7zPTFikna07h+2fPnyLCKyl156qWWH2gs0Zd0/MH/+/Cwisr/97W8tNFX6mrPuNTU1WURkTzzxxE4/xxXeVm7JkiVRXl4e/fv3jwsuuCBWrFix1eMWLlwYixYtiksvvXQPT5ie7a35xz/+8fjFL34Rb731VtTX18fMmTNj48aNcdppp+Vv4ERsa93r6uoil8s1+mDyDh06RFFRUaOr7zTdww8/HMcdd1ycd955ccABB8QxxxwTP/nJTxr2L1++PKqqqmLIkCEN20pLS2Pw4MExd+7cfIychB2tOy2jOeteU1MTuVwuunTpsmeGTFBT133Tpk1x1113RWlpaRx11FE7/0JNLXEKx+9+97vsvvvuy15++eXs0UcfzSoqKrI+ffpktbW1Wxz7xS9+MTv00EPzMGVadrTmb7/9djZ06NAsIrK2bdtmJSUl2WOPPZbnqVu/7a37mjVrspKSkuzLX/5ytmHDhmz9+vXZ5ZdfnkVE9oUvfCHfo7dqxcXFWXFxcTZx4sTsxRdfzO68886sQ4cO2YwZM7Isy7Jnn302i4hs1apVjZ533nnnZWPGjMnHyEnY0bp/mCu8u09T1j3Lsuzdd9/NBg0alH3uc5/bw5OmZWfX/ZFHHsk6deqU5XK5rLy8PJs/f36TXkfwJuTtt9/OSkpKsv/6r/9qtP2dd97JSktLs+9973t5mixd/7rml19+eXbCCSdkTzzxRLZo0aLs2muvzUpLS7M//elPeZ40Lf+67o899ljWv3//LJfLZW3atMk+//nPZ4MGDcouu+yyPE/aurVr1y6rqKhotO2KK67ITjzxxCzLBG9L2dG6f5jg3X2asu6bNm3KRowYkR1zzDGNbqei6XZ23devX58tWbIkmzt3bnbJJZdkffv2zaqrq3f6ddzSkJAuXbrERz7ykVi6dGmj7b/85S/jnXfeiYsuuihPk6Xrw2u+bNmy+NGPfhR33313nHnmmXHUUUfF5MmT47jjjotp06ble9Sk/Ovv+tChQ2PZsmWxZs2aePPNN+OnP/1pvP7669G/f/88T9q69ezZMw477LBG2w499NCG20l69OgREbHFJ2JUV1c37KPpdrTutIydXffNmzfHmDFj4m9/+1s8/vjjUVJSsifHTM7OrnunTp1iwIABceKJJ8b06dOjbdu2MX369J1+HcGbkPXr18eyZcuiZ8+ejbZPnz49Ro4cGfvvv3+eJkvXh9f8nXfeiYiIoqLG/6zatGnj0wJ2s239ru+3337RpUuXePLJJ2PNmjXePb2LTjrppFi8eHGjbX/961/joIMOioiIfv36RY8ePWLWrFkN+2tra+P555+PioqKPTprSna07rSMnVn3D2J3yZIl8cQTT0RZWdmeHjM5zf19r6+vj7q6up1/od1yPZq8+H//7/9ls2fPzpYvX549++yz2ZAhQ7L99tsvW7NmTcMxS5YsyXK5XPb73/8+j5OmY3trvmnTpmzAgAHZKaeckj3//PPZ0qVLs+9973tZLpfLfvvb3+Z79FZtR7/rd999dzZ37txs6dKl2U9/+tOsW7du2YQJE/I8des3f/78rG3bttmUKVOyJUuWZD/72c+yffbZJ/vv//7vhmNuuummrEuXLtlDDz2U/elPf8rOPvvsrF+/ftm7776bx8lbt51Z97Vr12YvvfRS9tvf/jaLiGzmzJnZSy+9lK1evTqPk7duO1r3TZs2ZSNHjsx69eqVLVq0KFu9enXDo66uLs/Tt147Wvf169dnEydOzObOnZu99tpr2QsvvJCNGzcuKy4uzl599dWdfh3B24qdf/75Wc+ePbP27dtnBx54YHb++ednS5cubXTMxIkTs969e2fvv/9+nqZMy47W/K9//Ws2atSo7IADDsj22Wef7Mgjj9ziY8pouh2t+9VXX5117949a9euXXbIIYdkt9xyS1ZfX5/HidPxyCOPZIcffnhWXFycDRw4MLvrrrsa7a+vr88mTZqUde/ePSsuLs7OPPPMbPHixXmaNh07WvfKysosIrZ4TJ48OT8DJ2J76/7B/dJbezz11FP5GzoB21v3d999N/v0pz+dlZeXZ+3bt8969uyZjRw5sslvWstlWZbt/PVgAABoXdzDCwBA0gQvAABJE7wAACRN8AIAkDTBCwBA0gQvAABJE7wAACRN8ALQyIwZMyKXy8WMGTPyPQrAbiF4AVrIa6+9FrlcrtFjn332ifLy8jjzzDPjmmuuiWXLluVltlwuF6eddlpeXhtgT2ub7wEAUnfwwQfH5z//+YiIqKurizVr1sT8+fPjhhtuiG9/+9vxta99LaZMmRK5XC7PkwKkSfACtLABAwbEtddeu8X2Z555Ji688MKYOnVqtGnTJm644YY9PxzAXsAtDQB5cvLJJ8ejjz4axcXFcfPNN8fKlSsb7X/ooYfizDPPjK5du0aHDh3i8MMPj+9973vx/vvvNzruw/fcPvTQQ3HCCSfEPvvsE/vvv39ccsklUV1d3XDs7NmzG64kz5kzp9HtFlu7Z/cPf/hDfPzjH4999tknysrKYuzYsbF27drdvxgALUjwAuTRRz/60RgzZkxs2rQpHnzwwYbtEydOjHPOOScWL14co0aNii996UvRsWPH+OpXvxqf+cxntnquBx54IM4777wYMGBAXHnllXHEEUdEZWVlnHzyyfH2229HRETfvn1j8uTJERFx0EEHxeTJkxseRx99dKPzPfzwwzFixIgoLy+PL33pS3HwwQfHPffcE2effXaLrAVAi8kAaBHLly/PIiIbNmzYdo+bPn16FhHZhRdemGVZlv3hD39oeN769esbjquvr88uu+yyLCKyX/7ylw3bKysrs4jIIiJ79NFHG53761//ehYR2eWXX95oe0Rkn/jEJ7Y6zwfna9u2bfbMM880bH/vvfey0047LYuIbO7cuTu1BgCFwBVegDwrLy+PiIg333wzIiJ+9KMfRUTEXXfdFZ06dWo4LpfLxU033RS5XC5+/vOfb3GeIUOGxLBhwxpt++Y3vxldunSJe+65J+rr65s01+c+97k46aSTGn5u06ZNjB07NiIiFixY0KRzAeSTN60BFJh58+ZFp06d4u67797q/o4dO8Zf/vKXLbafcsopW2zbd9994+ijj47Zs2fH//3f/8WAAQN2eo5jjz12i229evWKiIh169bt9HkA8k3wAuTZqlWrIiJi//33j4iIt956K95777247rrrtvmcDRs2bLGte/fuWz32g+01NTVNmqukpGSLbW3b/vP/Nv71jXMAhUzwAuTZ7NmzIyLi+OOPj4h/hmYul2u4xWFnffjTGLa2vbS0tPlDArRi7uEFyKO//vWvcd9990VxcXF8+tOfjoiIwYMHx9q1a2PJkiVNOtcf//jHLbatX78+Fi1aFCUlJdG/f/+G7UVFRa7SAnsNwQuQJ88++2wMGzYs6urq4utf/3oceOCBERHxn//5nxERcckll2z1M2+rqqrif//3f7fY/sQTT8Rjjz3WaNuUKVNi3bp1cdFFF0VR0f//n/xu3brF3//+9935xwEoWG5pAGhhS5cubfimtU2bNjV8tfArr7wSbdq0iW9961sNn40bEXHWWWfFpEmT4oYbbogBAwbEWWedFQcddFCsXbs2li5dGn/84x/jxhtvjEMPPbTR6/zbv/1bjBgxIs4999zo27dvzJs3L5566qk4+OCD4/rrr2907BlnnBH33XdfnHPOOXHMMcdEmzZtYuTIkXHkkUe2+HoA7GmCF6CFLVu2rOENaB07dowuXbrEwIEDY9KkSTF27Ng4+OCDt3jO9ddfH6eeemrcdtttMWvWrFi3bl2UlZVFv3794tprr40LLrhgi+eMHj06/v3f/z2mTJkSDz74YOyzzz5x8cUXx9SpU6Nr166Njv3hD38YERFPPvlkPPLII1FfXx+9evUSvECSclmWZfkeAoDmmzFjRowbNy4qKyvj4osvzvc4AAXHPbwAACRN8AIAkDTBCwBA0tzDCwBA0lzhBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaYIXAICkCV4AAJImeAEASJrgBQAgaf8fofmzmRGifv8AAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -125,9 +124,63 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This distribution is quite wide, signaling the difficulty the SWAP mapper is having in computing the best mapping.\n", + "This wide distribution demonstrates how difficult it is for the SWAP mapper to compute the best mapping. To gain some insight, let's look at both the circuit being executed as well as the qubits that were chosen on the hardware." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ghz.draw('mpl', idle_wires=False, style=\"iqp\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from qiskit.visualization import plot_circuit_layout\n", "\n", - "It's also important to point out here that the `SabreSwap` algorithm is different from the larger `SabreLayout` method in the previous stage. By default, `SabreLayout` runs both layout and routing, and returns the transformed circuit. This is done for a few particular technical reasons specified in the pass's [API reference page](../api/qiskit/qiskit.transpiler.passes.SabreLayout). " + "# Plot the hardware graph and indicate which hardware qubits were chosen to run the circuit\n", + "transpiled_circ = pass_manager.run(ghz)\n", + "plot_circuit_layout(transpiled_circ, backend)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "As you can see, this circuit has to execute a two-qubit gate between qubits 0 and 14, which are very far apart on the connectivity graph. Running this circuit thus requires inserting SWAP gates to execute all of the two-qubit gates using the `SabreSwap` pass.\n", + "\n", + "Note also that the `SabreSwap` algorithm is different from the larger `SabreLayout` method in the previous stage. By default, `SabreLayout` runs both layout and routing, and returns the transformed circuit. This is done for a few particular technical reasons specified in the pass's [API reference page](../api/qiskit/qiskit.transpiler.passes.SabreLayout). " ] }, { @@ -391,7 +444,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.11.1" }, "title": "Transpiler stages", "widgets": {