[rebranding] Qiskit Aer is now Aer (#1954)

Co-authored-by: Jun Doi <[email protected]>

CONTRIBUTING.md

@@ -5,7 +5,7 @@ included in the Qiskit documentation:
 
 https://qiskit.org/documentation/contributing_to_qiskit.html
 
-## Contributing to Qiskit Aer
+## Contributing to Aer
 
 In addition to the general guidelines, there are specific details for
 contributing to Aer. These are documented below.
@@ -105,33 +105,33 @@ look something like::
 ```yaml
 features:
   - |
-    Introduced a new feature foo, that adds support for doing something to
-    ``QuantumCircuit`` objects. It can be used by using the foo function,
+    Introduced a new feature ``foo``, that adds support for doing something to
+    ``AerProvider`` objects. It can be used by using the ``foo`` function,
     for example::
 
-      from qiskit import foo
-      from qiskit import QuantumCircuit
-      foo(QuantumCircuit())
+      from qiskit_aer import foo
+      from qiskit_aer import AerProvider
+      foo(AerProvider())
 
   - |
-    The ``qiskit.QuantumCircuit`` module has a new method ``foo()``. This is
-    the equivalent of calling the ``qiskit.foo()`` to do something to your
-    QuantumCircuit. This is the equivalent of running ``qiskit.foo()`` on
-    your circuit, but provides the convenience of running it natively on
+    The ``qiskit_aer.AerProvider`` module has a new method ``foo()``. This is
+    the equivalent of calling the ``qiskit_aer.foo()`` to do something to your
+    ``AerProvider``. This is the equivalent of running ``qiskit_aer.foo()`` on
+    your provider, but it has the convenience of running it natively on
     an object. For example::
 
-      from qiskit import QuantumCircuit
+      from qiskit_aer import AerProvider
 
-      circ = QuantumCircuit()
-      circ.foo()
+      provider = AerProvider()
+      provider.foo()
 
 deprecations:
   - |
-    The ``qiskit.bar`` module has been deprecated and will be removed in a
+    The ``qiskit_aer.bar`` module has been deprecated and will be removed in a
     future release. Its sole function, ``foobar()`` has been superseded by the
-    ``qiskit.foo()`` function which provides similar functionality but with
+    ``qiskit_aer.foo()`` function which provides similar functionality but with
     more accurate results and better performance. You should update your calls
-    ``qiskit.bar.foobar()`` calls to ``qiskit.foo()``.
+    ``qiskit_aer.bar.foobar()`` calls to ``qiskit_aer.foo()``.
 ```
 
 You can also look at other release notes for other examples.
@@ -180,7 +180,7 @@ it has been tagged::
 At release time, ``reno report`` is used to generate the release notes for the
 release and the output will be submitted as a pull request to the documentation
 repository's [release notes file](
-https://github.com/Qiskit/qiskit/blob/master/docs/release_notes.rst)
+https://github.com/Qiskit/qiskit-aer/blob/master/docs/release_notes.rst)
 
 #### Building release notes locally
 
@@ -193,7 +193,7 @@ particular will be located at `docs/_build/html/release_notes.html`
 
 ## Style and lint
 
-Qiskit Aer uses 3 tools for verifying code formatting and lint checking. The
+Aer uses 3 tools for verifying code formatting and lint checking. The
 first tool is [black](https://github.com/psf/black) which is a Python code formatting
 tool that will automatically update the code formatting to a consistent style.
 The second tool is [pylint](https://www.pylint.org/) which is a code linter
@@ -211,7 +211,7 @@ any error you will have to fix these issues by manually updating your code.
 
 ### Development Cycle
 
-The development cycle for qiskit-aer is all handled in the open using
+The development cycle for Aer is all handled in the open using
 the project boards in GitHub for project management. We use milestones
 in GitHub to track work for specific releases. The features or other changes
 that we want to include in a release will be tagged and discussed in GitHub.
@@ -222,20 +222,20 @@ previous version in the release notes.
 
 * `main`:
 
-The main branch is used for development of the next version of qiskit-aer.
+The main branch is used for development of the next version of Aer.
 It will be updated frequently and should not be considered stable. The API
 can and will change on main as we introduce and refine new features.
 
 * `stable/*` branches:
-Branches under `stable/*` are used to maintain released versions of qiskit-aer.
+Branches under `stable/*` are used to maintain released versions of `qiskit-aer`.
 It contains the version of the code corresponding to the latest release for
 that minor version on pypi. For example, stable/0.4 contains the code for the
 0.4.0 release on pypi. The API on these branches are stable and the only changes
 merged to it are bugfixes.
 
 ### Release cycle
 
-When it is time to release a new minor version of qiskit-aer, we will:
+When it is time to release a new minor version of `qiskit-aer`, we will:
 
 1.  Create a new tag with the version number and push it to github
 2.  Change the `main` version to the next release version.
@@ -268,7 +268,7 @@ window
     $ conda activate QiskitDevEnv
 ```
 
-- Clone the `Qiskit Aer` repo via *git*.
+- Clone the `Aer` repo via *git*.
 ```
     $ git clone https://github.com/Qiskit/qiskit-aer
 ```
@@ -301,7 +301,7 @@ You're now ready to build from source! Follow the instructions for your platform
 
 ### Linux
 
-Qiskit is officially supported on Red Hat, CentOS, Fedora, and Ubuntu distributions, as long as you can install a GCC version that is C++14 compatible and a few dependencies we need.
+Aer is officially supported on Red Hat, CentOS, Fedora, and Ubuntu distributions, as long as you can install a GCC version that is C++14 compatible and a few dependencies we need.
 
 #### <a name="linux-dependencies"> Dependencies </a>
 
@@ -635,7 +635,7 @@ options we have on `Aer` to CMake, we use its native mechanism:
 
 ### Building with GPU support
 
-Qiskit Aer can exploit GPU's horsepower to accelerate some simulations, specially the larger ones.
+Aer can exploit GPU's horsepower to accelerate some simulations, specially the larger ones.
 GPU access is supported either via CUDA® (NVIDIA® chipset) or ROCm® (AMD® GPUs).
 
 #### Building with CUDA® support
@@ -672,12 +672,12 @@ Few notes on CUDA® GPU builds:
 3. We don't need NVIDIA® drivers for building, but we need them for running simulations
 4. Only Linux platforms are supported
 
-Qiskit Aer now supports cuQuantum optimized Quantum computing APIs from NVIDIA®.
+Aer now supports cuQuantum optimized Quantum computing APIs from NVIDIA®.
 cuStateVec APIs can be exploited to accelerate statevector, density_matrix and unitary methods.
 cuTensorNet APIs can be exploited to tensor_network merthod.
 This implementation requires CUDA® toolkit version 11.2 or higher and Volta or Ampare architecture GPUs.
 
-Before building Qiskit Aer with cuQuantum support, install required components via pip install as following.
+Before building Aer with cuQuantum support, install required components via pip install as following.
 
     qiskit-aer$ pip install nvidia-cuda-runtime-cu11 nvidia-cublas-cu11 nvidia-cusolver-cu11 nvidia-cusparse-cu11 cuquantum-cu11
 
@@ -710,15 +710,15 @@ results = execute(circuit,sim,cuStateVec_enable=True).result()
 ```
 #### Building with ROCm® support
 ROCm® support has been added matching the CUDA® implementation based
-on the `thrust` library. This enables Qiskit-Aer to run on AMD® GPUs,
+on the `thrust` library. This enables Aer to run on AMD® GPUs,
 including the AMD® Instinct GPU line based on the CDNA architecture. 
 ROCm® only support linux platforms.
 
 To build the standalone version, the following should be sufficient:
 
 ```
-cmake <Qiskit-Aer source folder> -G Ninja \
-   -DCMAKE_INSTALL_PREFIX=<Qiskit-Aer target instalation folder> \
+cmake <qiskit-aer source folder> -G Ninja \
+   -DCMAKE_INSTALL_PREFIX=<qiskit-aer target instalation folder> \
    -DSKBUILD=FALSE \
    -DAER_THRUST_BACKEND=ROCM \
    -DAER_MPI=<set to ON or OFF depending on whether to activate MPI support> \
@@ -730,7 +730,7 @@ ninja install
 Alternatively, and possibly preferred for most use cases, you can create a Python
 wheel file that you can install as part of your Python environemnt:
 ```
-cd <Qiskit-Aer source folder>
+cd <qiskit-aer source folder>
 
 QISKIT_AER_PACKAGE_NAME='qiskit-aer-gpu-rocm' \
    python3 setup.py bdist_wheel -- \
@@ -745,9 +745,9 @@ In both cases, the host system needs to have a functional ROCm® instalation and
 the environment variable `ROCM_PATH` set pointing to the ROCm® instalation folder if
 that is not the default `/opt/rocm`.
 Depending on how your Python environment is set, you might need to install
-Qiskit-Aer's required development modules:
+Aer's required development modules:
 ```
-cd <Qiskit-Aer source folder>
+cd <qiskit-aer source folder>
 pip install -r requirements-dev.txt
 ```
 
@@ -763,11 +763,11 @@ results = execute(circuit,sim,cuStateVec_enable=True).result()
 
 ### Building with MPI support
 
-Qiskit Aer can parallelize its simulation on the cluster systems by using MPI. 
+Aer can parallelize its simulation on the cluster systems by using MPI. 
 This can extend available memory space to simulate quantum circuits with larger number of qubits and also can accelerate the simulation by parallel computing. 
 To use MPI support, any MPI library (i.e. OpenMPI) should be installed and configured on the system.
 
-Qiskit Aer supports MPI both with and without GPU support. Currently following simulation methods are supported to be parallelized by MPI.
+Aer supports MPI both with and without GPU support. Currently following simulation methods are supported to be parallelized by MPI.
 
  - statevector
  - density_matrix
@@ -795,7 +795,7 @@ For example,
 
 ### Running with multiple-GPUs and/or multiple nodes
 
-Qiskit Aer parallelizes simulations by distributing quantum states into distributed memory space.
+Aer parallelizes simulations by distributing quantum states into distributed memory space.
 To decrease data transfer between spaces the distributed states are managed as chunks that is a sub-state for smaller qubits than the input circuits.
 
 For example, 
@@ -809,7 +809,7 @@ And the (noiseless) swap gates are inserted to exchange data.
 Please refer to this paper (https://arxiv.org/abs/2102.02957) for more detailed algorithm and implementation of parallel simulation.
 
 So to simulate by using multiple GPUs or multiple nodes on the cluster, following configurations should be set to backend options.
-(If there is not enough memory to simulate the input circuit, Qiskit Aer automatically set following options, but it is recommended to explicitly set them)
+(If there is not enough memory to simulate the input circuit, Aer automatically set following options, but it is recommended to explicitly set them)
 
  - blocking_enable
 
@@ -828,13 +828,13 @@ circ.measure_all()
 result = execute(circ, sim, shots=100, blocking_enable=True, blocking_qubits=23).result()
 ```
 
-To run Qiskit Aer with Python script with MPI parallelization, MPI executer such as mpirun should be used to submit a job on the cluster. Following example shows how to run Python script using 4 processes by using mpirun.
+To run Aer with Python script with MPI parallelization, MPI executer such as mpirun should be used to submit a job on the cluster. Following example shows how to run Python script using 4 processes by using mpirun.
 
 ```
 mpirun -np 4 python example.py
 ```
 
-MPI_Init function is called inside Qiskit Aer, so you do not have to manage MPI processes in Python script.
+MPI_Init function is called inside Aer, so you do not have to manage MPI processes in Python script.
 Following metadatas are useful to find on which process is this script running. 
 
  - num_mpi_processes : shows number of processes using for this simulation
@@ -855,9 +855,9 @@ myrank = meta['mpi_rank']
 Multiple shots are also distributed to multiple nodes when setting `device=GPU` and `batched_shots_gpu=True`. The results are distributed to each processes.
 
 
-Note : In the script, make sure that the same random seed should be used for all processes so that the consistent circuits and parameters are passed to Qiskit Aer. To do so add following option to the script.
+Note : In the script, make sure that the same random seed should be used for all processes so that the consistent circuits and parameters are passed to Aer. To do so add following option to the script.
 ```
-from qiskit.utils import algorithm_globals
+from qiskit_algorithms.utils import algorithm_globals
 algorithm_globals.random_seed = consistent_seed_to_all_processes
 ```
 
@@ -1049,10 +1049,10 @@ These are the flags:
 Code contributions are expected to include tests that provide coverage for the
 changes being made.
 
-We have two types of tests in the codebase: Qiskit Terra integration tests and
+We have two types of tests in the codebase: Qiskit integration tests and
 Standalone integration tests.
 
-For Qiskit Terra integration tests, you first need to build and install the Qiskit Python extension, and then run `unittest` Python framework.
+For Qiskit integration tests, you first need to build and install the Qiskit Python extension, and then run ``unittest`` Python framework.
 
 ```
 qiskit-aer$ pip install .
@@ -1167,7 +1167,7 @@ After this, you can step through the code and continue with your debug session a
 
 ## Dealing with the git blame ignore list
 
-In the qiskit-aer repository we maintain a list of commits for git blame to
+In the ``Qiskit/qiskit-aer`` repository we maintain a list of commits for git blame to
 ignore. This is mostly commits that are code style changes that don't change
 the functionality but just change the code formatting (for example, when we
 migrated to use black for code formatting). This file, `.git-blame-ignore-revs`

README.md

@@ -1,21 +1,19 @@
-# Qiskit Aer
+# Aer - high performance quantum circuit simulation for Qiskit
 
 [![License](https://img.shields.io/github/license/Qiskit/qiskit-aer.svg?style=popout-square)](https://opensource.org/licenses/Apache-2.0)
 [![Build](https://github.com/Qiskit/qiskit-aer/actions/workflows/build.yml/badge.svg?branch=main)](https://github.com/Qiskit/qiskit-aer/actions/workflows/build.yml)
 [![Tests](https://github.com/Qiskit/qiskit-aer/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/Qiskit/qiskit-aer/actions/workflows/tests.yml)
 [![](https://img.shields.io/github/release/Qiskit/qiskit-aer.svg?style=popout-square)](https://github.com/Qiskit/qiskit-aer/releases)
 [![](https://img.shields.io/pypi/dm/qiskit-aer.svg?style=popout-square)](https://pypi.org/project/qiskit-aer/)
 
-**Qiskit** is an open-source framework for working with noisy quantum computers at the level of pulses, circuits, and algorithms.
-
-Qiskit is made up of elements that work together to enable quantum computing. This element is **Aer**, which provides high-performance quantum computing simulators with realistic noise models.
+**Aer** is a high performance simulator for quantum circuits written in Qiskit, that includes realistic noise models.
 
 ## Installation
 
-We encourage installing Qiskit via the pip tool (a python package manager). The following command installs the core Qiskit components, including Aer.
+We encourage installing Aer via the pip tool (a python package manager):
 
 ```bash
-pip install qiskit qiskit-aer
+pip install qiskit-aer
 ```
 
 Pip will handle all dependencies automatically for us, and you will always install the latest (and well-tested) version.
@@ -47,8 +45,8 @@ that have CUDA support, you will have to build from source. You can refer to
 the [contributing guide](CONTRIBUTING.md#building-with-gpu-support)
 for instructions on doing this.
 
-## Simulating your first quantum program with Qiskit Aer
-Now that you have Qiskit Aer installed, you can start simulating quantum circuits with noise. Here is a basic example:
+## Simulating your first Qiskit circuit with Aer
+Now that you have Aer installed, you can start simulating quantum circuits with noise. Here is a basic example:
 
 ```
 $ python
@@ -91,20 +89,19 @@ print('Counts(noise):', counts_noise)
 
 ## Contribution Guidelines
 
-If you'd like to contribute to Qiskit, please take a look at our
+If you'd like to contribute to Aer, please take a look at our
 [contribution guidelines](CONTRIBUTING.md). This project adheres to Qiskit's [code of conduct](CODE_OF_CONDUCT.md). By participating, you are expected to uphold this code.
 
 We use [GitHub issues](https://github.com/Qiskit/qiskit-aer/issues) for tracking requests and bugs. Please use our [slack](https://qiskit.slack.com) for discussion and simple questions. To join our Slack community use the [link](https://qiskit.slack.com/join/shared_invite/zt-fybmq791-hYRopcSH6YetxycNPXgv~A#/). For questions that are more suited for a forum, we use the Qiskit tag in the [Stack Exchange](https://quantumcomputing.stackexchange.com/questions/tagged/qiskit).
 
 ## Next Steps
 
-Now you're set up and ready to check out some of the other examples from our
-[Qiskit IQX Tutorials](https://github.com/Qiskit/qiskit-tutorials/tree/master/tutorials/simulators) or [Qiskit Community Tutorials](https://github.com/Qiskit/qiskit-community-tutorials/tree/master/aer) repositories.
+Now you're set up and ready to check out some of the other examples from the [Aer documentation](https://qiskit.org/ecosystem/aer/).
 
 ## Authors and Citation
 
-Qiskit Aer is the work of [many people](https://github.com/Qiskit/qiskit-aer/graphs/contributors) who contribute
-to the project at different levels. If you use Qiskit, please cite as per the included [BibTeX file](https://github.com/Qiskit/qiskit-terra/blob/main/CITATION.bib).
+Aer is the work of [many people](https://github.com/Qiskit/qiskit-aer/graphs/contributors) who contribute to the project at different levels.
+If you use Qiskit, please cite as per the included [BibTeX file](https://github.com/Qiskit/qiskit/blob/main/CITATION.bib).
 
 ## License
 

qiskit_aer/__init__.py

@@ -78,8 +78,8 @@
 
 if sys.version_info < (3, 8):
     warnings.warn(
-        "Using Qiskit Aer with Python 3.7 is deprecated as of the 0.12.0 release. "
-        "Support for running Qiskit Aer with Python 3.7 will be removed in a future "
+        "Using Aer with Python 3.7 is deprecated as of the 0.12.0 release. "
+        "Support for running Aer with Python 3.7 will be removed in a future "
         "release",
         DeprecationWarning,
     )

qiskit_aer/aererror.py

@@ -11,7 +11,7 @@
 # that they have been altered from the originals.
 
 """
-Exception for errors raised by Qiskit Aer simulators backends.
+Exception for errors raised by Aer simulators backends.
 """
 
 from qiskit import QiskitError

qiskit_aer/aerprovider.py

@@ -11,7 +11,7 @@
 # that they have been altered from the originals.
 
 # pylint: disable=invalid-name
-"""Provider for Qiskit Aer backends."""
+"""Provider for Aer backends."""
 
 
 from qiskit.providers import ProviderV1 as Provider
@@ -24,7 +24,7 @@
 
 
 class AerProvider(Provider):
-    """Provider for Qiskit Aer backends."""
+    """Provider for Aer backends."""
 
     _BACKENDS = None
 

qiskit_aer/backends/aer_simulator.py

@@ -10,7 +10,7 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 """
-Qiskit Aer qasm simulator backend.
+Aer qasm simulator backend.
 """
 
 import copy

qiskit_aer/backends/aerbackend.py

@@ -10,7 +10,7 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 """
-Qiskit Aer qasm simulator backend.
+Aer qasm simulator backend.
 """
 
 import copy
@@ -45,7 +45,7 @@
 
 
 class AerBackend(Backend, ABC):
-    """Qiskit Aer Backend class."""
+    """Aer Backend class."""
 
     def __init__(
         self, configuration, properties=None, defaults=None, backend_options=None, provider=None