Quantum algorithm for linear systems of equations

Short description: Quantum linear algebra algorithm offering exponential speedup under certain conditions

The quantum algorithm for linear systems of equations, also called HHL algorithm, designed by Aram Harrow, Avinatan Hassidim, and Seth Lloyd, is a quantum algorithm published in 2008 for solving linear systems. The algorithm estimates the result of a scalar measurement on the solution vector to a given linear system of equations.[1]

The algorithm is one of the main fundamental algorithms expected to provide a speedup over their classical counterparts, along with Shor's factoring algorithm, Grover's search algorithm, and the quantum fourier transform. Provided the linear system is sparse and has a low condition number κ, and that the user is interested in the result of a scalar measurement on the solution vector, instead of the values of the solution vector itself, then the algorithm has a runtime of O(log⁡(N)κ2), where N is the number of variables in the linear system. This offers an exponential speedup over the fastest classical algorithm, which runs in O(Nκ) (or O(Nκ) for positive semidefinite matrices).

An implementation of the quantum algorithm for linear systems of equations was first demonstrated in 2013 by Cai et al., Barz et al. and Pan et al. in parallel. The demonstrations consisted of simple linear equations on specially designed quantum devices.[2][3][4] The first demonstration of a general-purpose version of the algorithm appeared in 2018 in the work of Zhao et al.[5]

Due to the prevalence of linear systems in virtually all areas of science and engineering, the quantum algorithm for linear systems of equations has the potential for widespread applicability.[6]

## Contents

* 1 Procedure
* 2 Explanation of the algorithm
* 2.1 Initialization
* 2.2 Hamiltonian simulation
* 2.3 Uinvert subroutine
* 2.4 Main loop
* 2.5 Scalar measurement
* 3 Run time analysis
* 3.1 Classical efficiency
* 3.2 Quantum efficiency
* 3.3 Optimality
* 4 Error analysis
* 5 Experimental realization
* 5.1 Cai et al.
* 5.2 Barz et al.
* 5.3 Pan et al.
* 5.4 Wen et al.
* 6 Applications
* 6.1 Electromagnetic scattering
* 6.2 Linear differential equation solving
* 6.3 Finite element method
* 6.4 Least-squares fitting
* 6.5 Machine learning and big data analysis
* 7 Critique
* 8 See also
* 9 References

## Procedure

The problem the quantum algorithm for linear systems of equations solves is: given a N×N Hermitian matrix A and a unit vector b->, find the solution vector x-> satisfying Ax->=b->. The algorithm assumes that the user is not interested in the values of x-> itself, but rather the result of applying some operator M onto x, ⟨x|M|x⟩.

First, the algorithm represents the vector b-> as a quantum state of the form:

|b⟩=∑i=1Nbi|i⟩.

Next, Hamiltonian simulation techniques are used to apply the unitary operator eiAt to |b⟩ for a superposition of different times t. The ability to decompose |b⟩ into the eigenbasis of A and to find the corresponding eigenvalues λj is facilitated by the use of quantum phase estimation.

The state of the system after this decomposition is approximately:

∑j=1Nβj|uj⟩|λj⟩,

where uj is the eigenvector basis of A, and |b⟩=∑j=1Nβj|uj⟩.

We would then like to perform the linear map taking |λj⟩ to Cλj−1|λj⟩, where C is a normalizing constant. The linear mapping operation is not unitary and thus will require a number of repetitions as it has some probability of failing. After it succeeds, we uncomputed the |λj⟩ register and are left with a state proportional to:

∑i=1Nβiλj−1|uj⟩=A−1|b⟩=|x⟩,

where |x⟩ is a quantum-mechanical representation of the desired solution vector x. To read out all components of x would require the procedure be repeated at least N times. However, it is often the case that one is not interested in x itself, but rather some expectation value of a linear operator M acting on x. By mapping M to a quantum-mechanical operator and performing the quantum measurement corresponding to M, we obtain an estimate of the expectation value ⟨x|M|x⟩. This allows for a wide variety of features of the vector x to be extracted including normalization, weights in different parts of the state space, and moments without actually computing all the values of the solution vector x.

## Explanation of the algorithm

### Initialization

Firstly, the algorithm requires that the matrix A be Hermitian so that it can be converted into a unitary operator. In the case where A is not Hermitian, define

𝐂=[0AA†0].

As C is Hermitian, the algorithm can now be used to solve Cy=[b0]. to obtain y=[0x].

Secondly, The algorithm requires an efficient procedure to prepare |b⟩, the quantum representation of b. It is assumed that there exists some linear operator B that can take some arbitrary quantum state |initial⟩ to |b⟩ efficiently or that this algorithm is a subroutine in a larger algorithm and is given |b⟩ as input. Any error in the preparation of state |b⟩ is ignored.

Finally, the algorithm assumes that the state |ψ0⟩ can be prepared efficiently. Where

|ψ0⟩:=2/T∑τ=0T−1sin⁡π(τ+12T)|τ⟩

for some large T. The coefficients of |ψ0⟩ are chosen to minimize a certain quadratic loss function which induces error in the Uinvert subroutine described below.

### Hamiltonian simulation

Hamiltonian simulation is used to transform the Hermitian matrix A into a unitary operator, which can then be applied at will. This is possible if A is s-sparse and efficiently row computable, meaning it has at most s nonzero entries per row and given a row index these entries can be computed in time O(s). Under these assumptions, quantum Hamiltonian simulation allows eiAt to be simulated in time O(log⁡(N)s2t).

###  Uinvert subroutine

The key subroutine to the algorithm, denoted Uinvert, is defined as follows and incorporates a phase estimation subroutine:

1\. Prepare |ψ0⟩C on register C

2\. Apply the conditional Hamiltonian evolution (sum)

3\. Apply the Fourier transform to the register C. Denote the resulting basis states with |k⟩ for k = 0, ..., T − 1\. Define λk:=2πk/t0.

4\. Adjoin a three-dimensional register S in the state

|h(λk)⟩S:=1−f(λk)2−g(λk)2|nothing⟩S+f(λk)|well⟩S+g(λk)|ill⟩S,

5\. Reverse steps 1–3, uncomputing any garbage produced along the way.

The phase estimation procedure in steps 1-3 allows for the estimation of eigenvalues of A up to error ϵ.

The ancilla register in step 4 is necessary to construct a final state with inverted eigenvalues corresponding to the diagonalized inverse of A. In this register, the functions f, g, are called filter functions. The states 'nothing', 'well' and 'ill' are used to instruct the loop body on how to proceed; 'nothing' indicates that the desired matrix inversion has not yet taken place, 'well' indicates that the inversion has taken place and the loop should halt, and 'ill' indicates that part of |b⟩ is in the ill-conditioned subspace of A and the algorithm will not be able to produce the desired inversion. Producing a state proportional to the inverse of A requires 'well' to be measured, after which the overall state of the system collapses to the desired state by the extended Born rule.

### Main loop

The body of the algorithm follows the amplitude amplification procedure: starting with UinvertB|initial⟩, the following operation is repeatedly applied:

UinvertBRinitB†Uinvert†Rsucc,

where

Rsucc=I−2|well⟩⟨well|

and

Rinit=I−2|initial⟩⟨initial|.

After each repetition, S is measured and will produce a value of 'nothing', 'well', or 'ill' as described above. This loop is repeated until |well⟩ is measured, which occurs with a probability p. Rather than repeating 1p times to minimize error, amplitude amplification is used to achieve the same error resilience using only O(1p) repetitions.

### Scalar measurement

After successfully measuring 'well' on S the system will be in a state proportional to:

∑i=1Nβiλj−1|uj⟩=A−1|b⟩=|x⟩.

Finally, we perform the quantum-mechanical operator corresponding to M and obtain an estimate of the value of ⟨x|M|x⟩.

## Run time analysis

### Classical efficiency

The best classical algorithm which produces the actual solution vector x-> is Gaussian elimination, which runs in O(N3) time.

If A is s-sparse and positive semi-definite, then the Conjugate Gradient method can be used to find the solution vector x->, which can be found in O(Nsκ) time by minimizing the quadratic function |Ax->−b->|2.

When only a summary statistic of the solution vector x-> is needed, as is the case for the quantum algorithm for linear systems of equations, a classical computer can find an estimate of x->†Mx-> in O(Nκ).

### Quantum efficiency

The runtime of the quantum algorithm for solving systems of linear equations originally proposed by Harrow et al. was shown to be O(κ2log⁡N/ε), where ε>0 is the error parameter and κ is the condition number of A. This was subsequently improved to O(κlog3κlog⁡N/ε3) by Andris Ambainis[7] and a quantum algorithm with runtime polynomial in log⁡(1/ε) was developed by Childs et al.[8] Since the HHL algorithm maintains its logarithmic scaling in N only for sparse or low rank matrices, Wossnig et al.[9] extended the HHL algorithm based on a quantum singular value estimation technique and provided a linear system algorithm for dense matrices which runs in O(Nlog⁡Nκ2) time compared to the O(Nlog⁡Nκ2) of the standard HHL algorithm.

### Optimality

An important factor in the performance of the matrix inversion algorithm is the condition number κ, which represents the ratio of A's largest and smallest eigenvalues. As the condition number increases, the ease with which the solution vector can be found using gradient descent methods such as the conjugate gradient method decreases, as A becomes closer to a matrix which cannot be inverted and the solution vector becomes less stable. This algorithm assumes that all singular values of the matrix A lie between 1κ and 1, in which case the claimed run-time proportional to κ2 will be achieved. Therefore, the speedup over classical algorithms is increased further when κ is a poly(log⁡(N)).[1]

If the run-time of the algorithm were made poly-logarithmic in κ then problems solvable on n qubits could be solved in poly(n) time, causing the complexity class BQP to be equal to PSPACE.[1]

## Error analysis

Performing the Hamiltonian simulation, which is the dominant source of error, is done by simulating eiAt. Assuming that A is s-sparse, this can be done with an error bounded by a constant ε, which will translate to the additive error achieved in the output state |x⟩.

The phase estimation step errs by O(1t0) in estimating λ, which translates into a relative error of O(1λt0) in λ−1. If λ≥1/κ, taking t0=O(κε) induces a final error of ε. This requires that the overall run-time efficiency be increased proportional to O(1ε) to minimize error.

## Experimental realization

While there does not yet exist a quantum computer that can truly offer a speedup over a classical computer, implementation of a "proof of concept" remains an important milestone in the development of a new quantum algorithm. Demonstrating the quantum algorithm for linear systems of equations remained a challenge for years after its proposal until 2013 when it was demonstrated by Cai et al., Barz et al. and Pan et al. in parallel.

### Cai et al.

Published in Physical Review Letters 110, 230501 (2013), Cai et al. reported an experimental demonstration of the simplest meaningful instance of this algorithm, that is, solving 2×2 linear equations for various input vectors. The quantum circuit is optimized and compiled into a linear optical network with four photonic quantum bits (qubits) and four controlled logic gates, which is used to coherently implement every subroutine for this algorithm. For various input vectors, the quantum computer gives solutions for the linear equations with reasonably high precision, ranging from fidelities of 0.825 to 0.993.[10]

### Barz et al.

On February 5, 2013, Stefanie Barz and co-workers demonstrated the quantum algorithm for linear systems of equations on a photonic quantum computing architecture. This implementation used two consecutive entangling gates on the same pair of polarization-encoded qubits. Two separately controlled NOT gates were realized where the successful operation of the first was heralded by a measurement of two ancillary photons. Barz et al. found that the fidelity in the obtained output state ranged from 64.7% to 98.1% due to the influence of higher-order emissions from spontaneous parametric down-conversion.[3]

### Pan et al.

On February 8, 2013, Pan et al. reported a proof-of-concept experimental demonstration of the quantum algorithm using a 4-qubit nuclear magnetic resonance quantum information processor. The implementation was tested using simple linear systems of only 2 variables. Across three experiments they obtain the solution vector with over 96% fidelity.[4]

### Wen et al.

Another experimental demonstration using NMR for solving an 8*8 system was reported by Wen et al.[11] in 2018 using the algorithm developed by Subaşı et al.[12]

## Applications

Quantum computers are devices that harness quantum mechanics to perform computations in ways that classical computers cannot. For certain problems, quantum algorithms supply exponential speedups over their classical counterparts, the most famous example being Shor's factoring algorithm. Few such exponential speedups are known, and those that are (such as the use of quantum computers to simulate other quantum systems) have so far found limited use outside the domain of quantum mechanics. This algorithm provides an exponentially faster method of estimating features of the solution of a set of linear equations, which is a problem ubiquitous in science and engineering, both on its own and as a subroutine in more complex problems.

### Electromagnetic scattering

Clader et al. provided a preconditioned version of the linear systems algorithm that provided two advances. First, they demonstrated how a preconditioner could be included within the quantum algorithm. This expands the class of problems that can achieve the promised exponential speedup, since the scaling of HHL and the best classical algorithms are both polynomial in the condition number. The second advance was the demonstration of how to use HHL to solve for the radar cross-section of a complex shape. This was one of the first end to end examples of how to use HHL to solve a concrete problem exponentially faster than the best known classical algorithm.[13]

### Linear differential equation solving

Dominic Berry proposed a new algorithm for solving linear time dependent differential equations as an extension of the quantum algorithm for solving linear systems of equations. Berry provides an efficient algorithm for solving the full-time evolution under sparse linear differential equations on a quantum computer.[14]

### Finite element method

The Finite Element Method uses large systems of linear equations to find approximate solutions to various physical and mathematical models. Montanaro and Pallister demonstrate that the HHL algorithm, when applied to certain FEM problems, can achieve a polynomial quantum speedup. They suggest that an exponential speedup is not possible in problems with fixed dimensions, and for which the solution meets certain smoothness conditions.

Quantum speedups for the finite element method are higher for problems which include solutions with higher-order derivatives and large spatial dimensions. For example, problems in many-body dynamics require the solution of equations containing derivatives on orders scaling with the number of bodies, and some problems in computational finance, such as Black-Scholes models, require large spatial dimensions.[15]

### Least-squares fitting

Wiebe et al. provide a new quantum algorithm to determine the quality of a least-squares fit in which a continuous function is used to approximate a set of discrete points by extending the quantum algorithm for linear systems of equations. As the number of discrete points increases, the time required to produce a least-squares fit using even a quantum computer running a quantum state tomography algorithm becomes very large. Wiebe et al. find that in many cases, their algorithm can efficiently find a concise approximation of the data points, eliminating the need for the higher-complexity tomography algorithm.[16]

### Machine learning and big data analysis

Main article: Quantum machine learning

Machine learning is the study of systems that can identify trends in data. Tasks in machine learning frequently involve manipulating and classifying a large volume of data in high-dimensional vector spaces. The runtime of classical machine learning algorithms is limited by a polynomial dependence on both the volume of data and the dimensions of the space. Quantum computers are capable of manipulating high-dimensional vectors using tensor product spaces and are thus the perfect platform for machine learning algorithms.[17]

The quantum algorithm for linear systems of equations has been applied to a support vector machine, which is an optimized linear or non-linear binary classifier. A support vector machine can be used for supervised machine learning, in which training set of already classified data is available, or unsupervised machine learning, in which all data given to the system is unclassified. Rebentrost et al. show that a quantum support vector machine can be used for big data classification and achieve an exponential speedup over classical computers.[18]

In June 2018, Zhao et al. developed an algorithm for performing Bayesian training of deep neural networks in quantum computers with an exponential speedup over classical training due to the use of the quantum algorithm for linear systems of equations,[5] providing also the first general-purpose implementation of the algorithm to be run in cloud-based quantum computers.[19]

## Critique

Recognizing the importance of the HHL algorithm in the field of quantum machine learning, Scott Aaronson[20] analyzes the caveats and factors that could limit the actual quantum advantage of the algorithm.

1. the solution vector, |b⟩, has to be efficiently prepared in the quantum state. If the vector is not close to uniform, the state preparation is likely to be costly, and if it takes O(nc) steps the exponential advantage of HHL would vanish.
2. the QPE phases calls for the generation of the unitary eiAt, and its controlled application. The efficiency of this step depends on the A matrix being sparse and 'well conditioned' (low κ). Otherwise, the application of eiAt would grow as O(nc) and once again, the algorithm's quantum advantage would vanish.
3. lastly, the vector, |x⟩, is not readily accessible. The HHL algorithm enables learning a 'summary' of the vector, namely the result of measuring the expectation of an operator ⟨x|M|x⟩. If actual values of x→ are needed, then HHL would need to be repeated O(n) times, killing the exponential speed-up.

## See also

* Differentiable programming

## References

1. ↑ 1.0 1.1 1.2 Harrow, Aram W; Hassidim, Avinatan; Lloyd, Seth (2008). "Quantum algorithm for solving linear systems of equations". Physical Review Letters 103 (15): 150502. doi:10.1103/PhysRevLett.103.150502. PMID 19905613. Bibcode: 2009PhRvL.103o0502H.
2. ↑ Cai, X.-D; Weedbrook, C; Su, Z.-E; Chen, M.-C; Gu, Mile; Zhu, M.-J; Li, Li; Liu, Nai-Le et al. (2013). "Experimental Quantum Computing to Solve Systems of Linear Equations". Physical Review Letters 110 (23): 230501. doi:10.1103/PhysRevLett.110.230501. PMID 25167475. Bibcode: 2013PhRvL.110w0501C.
3. ↑ 3.0 3.1 Barz, Stefanie; Kassal, Ivan; Ringbauer, Martin; Lipp, Yannick Ole; Dakić, Borivoje; Aspuru-Guzik, Alán; Walther, Philip (2014). "A two-qubit photonic quantum processor and its application to solving systems of linear equations". Scientific Reports 4: 6115. doi:10.1038/srep06115. ISSN 2045-2322. PMID 25135432. Bibcode: 2014NatSR...4E6115B.
4. ↑ 4.0 4.1 Pan, Jian; Cao, Yudong; Yao, Xiwei; Li, Zhaokai; Ju, Chenyong; Peng, Xinhua; Kais, Sabre; Du, Jiangfeng et al. (2014). "Experimental realization of quantum algorithm for solving linear systems of equations". Physical Review A 89 (2): 022313. doi:10.1103/PhysRevA.89.022313. Bibcode: 2014PhRvA..89b2313P.
5. ↑ 5.0 5.1 Zhao, Zhikuan; Pozas-Kerstjens, Alejandro; Rebentrost, Patrick; Wittek, Peter (2019). "Bayesian Deep Learning on a Quantum Computer". Quantum Machine Intelligence 1 (1–2): 41–51. doi:10.1007/s42484-019-00004-7.
6. ↑ Quantum Computer Runs The Most Practically Useful Quantum Algorithm, by Lu and Pan.
7. ↑ Ambainis, Andris (2010). "Variable time amplitude amplification and a faster quantum algorithm for solving systems of linear equations". arXiv:1010.4458 [quant-ph].
8. ↑ Childs, Andrew M.; Kothari, Robin; Somma, Rolando D. (2017). "Quantum Algorithm for Systems of Linear Equations with Exponentially Improved Dependence on Precision". SIAM Journal on Computing 46 (6): 1920–1950. doi:10.1137/16m1087072. ISSN 0097-5397.
9. ↑ Wossnig, Leonard; Zhao, Zhikuan; Prakash, Anupam (2018). "A quantum linear system algorithm for dense matrices". Physical Review Letters 120 (5): 050502. doi:10.1103/PhysRevLett.120.050502. PMID 29481180. Bibcode: 2018PhRvL.120e0502W.
10. ↑ Cai, X. -D; Weedbrook, Christian; Su, Z. -E; Chen, M. -C; Gu, Mile; Zhu, M. -J; Li, L; Liu, N. -L et al. (2013). "Experimental Quantum Computing to Solve Systems of Linear Equations". Physical Review Letters 110 (23): 230501. doi:10.1103/PhysRevLett.110.230501. PMID 25167475. Bibcode: 2013PhRvL.110w0501C.
11. ↑ Jingwei Wen, Xiangyu Kong, Shijie Wei, Bixue Wang, Tao Xin, and Guilu Long (2019). "Experimental realization of quantum algorithms for a linear system inspired by adiabatic quantum computing". Phys. Rev. A 99, 012320.
12. ↑ Subaşı, Yiğit; Somma, Rolando D.; Orsucci, Davide (2019-02-14). "Quantum Algorithms for Systems of Linear Equations Inspired by Adiabatic Quantum Computing". Physical Review Letters 122 (6): 060504. doi:10.1103/physrevlett.122.060504. ISSN 0031-9007. PMID 30822089. Bibcode: 2019PhRvL.122f0504S.
13. ↑ Clader, B. D; Jacobs, B. C; Sprouse, C. R (2013). "Preconditioned Quantum Linear System Algorithm". Physical Review Letters 110 (25): 250504. doi:10.1103/PhysRevLett.110.250504. PMID 23829722. Bibcode: 2013PhRvL.110y0504C.
14. ↑ Berry, Dominic W (2010). "High-order quantum algorithm for solving linear differential equations". Journal of Physics A: Mathematical and Theoretical 47 (10): 105301. doi:10.1088/1751-8113/47/10/105301. Bibcode: 2014JPhA...47j5301B.
15. ↑ Montanaro, Ashley; Pallister, Sam (2016). "Quantum Algorithms and the Finite Element Method". Physical Review A 93 (3): 032324. doi:10.1103/PhysRevA.93.032324. Bibcode: 2016PhRvA..93c2324M.
16. ↑ Wiebe, Nathan; Braun, Daniel; Lloyd, Seth (2012). "Quantum Data Fitting". Physical Review Letters 109 (5): 050505. doi:10.1103/PhysRevLett.109.050505. PMID 23006156. Bibcode: 2012PhRvL.109e0505W.
17. ↑ Lloyd, Seth; Mohseni, Masoud; Rebentrost, Patrick (2013). "Quantum algorithms for supervised and unsupervised machine learning". arXiv:1307.0411 [quant-ph].
18. ↑ Rebentrost, Patrick; Mohseni, Masoud; Lloyd, Seth (2013). "Quantum support vector machine for big feature and big data classification". arXiv:1307.0471v2 [quant-ph].
19. ↑ "apozas/bayesian-dl-quantum" (in en). https://gitlab.com/apozas/bayesian-dl-quantum.
20. ↑ Aaronson, Scott (2015). "Read the fine print". Nature Physics 11 (4): 291-293. https://www.nature.com/articles/nphys3272. Retrieved 2023-05-09.

* v
* t
* e

Quantum information science

General|

* Quantum computing
* Qubit
* physical vs. logical
* DiVincenzo's criteria
* Quantum information
* Quantum programming
* Quantum processors
* Cloud-based quantum computing
* Timeline of quantum computing

Theorems|

* Bell's theorem
* Gleason's theorem
* Gottesman–Knill theorem
* Holevo's theorem
* Margolus–Levitin theorem
* No-broadcast theorem
* No-cloning theorem
* No-communication theorem
* No-deleting theorem
* No-hiding theorem
* No-teleportation theorem
* PBR theorem
* Quantum threshold theorem

Quantum
communication|

* Quantum capacity
* Classical capacity
* Entanglement-assisted classical capacity
* Quantum channel
* Quantum network
* Quantum cryptography
* Quantum key distribution
* BB84
* SARG04
* Three-stage quantum cryptography protocol
* Quantum teleportation
* Superdense coding
* LOCC
* Entanglement distillation

Quantum algorithms|

* Universal quantum simulator
* Deutsch–Jozsa algorithm
* Grover's algorithm
* Quantum Fourier transform
* Shor's algorithm
* Simon's problem
* Quantum phase estimation algorithm
* Quantum counting algorithm
* Quantum annealing
* Quantum algorithm for linear systems of equations
* Amplitude amplification

Quantum
complexity theory|

* Quantum Turing machine
* EQP
* BQP
* QMA
* PostBQP
* QIP

Quantum
computing models|

* Quantum circuit
* Quantum logic gate
* One-way quantum computer
* cluster state
* Adiabatic quantum computation
* Topological quantum computer

Quantum
error correction|

* Stabilizer codes
* Entanglement-Assisted Quantum Error Correction
* Shor code
* Steane code
* CSS code
* Quantum convolutional codes
* Toric code

Physical
implementations|

| Quantum optics|

* Cavity QED
* Circuit QED
* Linear optical quantum computing
* KLM protocol
* Boson sampling

|

Ultracold atoms|

* Trapped ion quantum computer
* Optical lattice

Spin-based|

* Nuclear magnetic resonance QC
* Kane QC
* Loss–DiVincenzo QC
* Nitrogen-vacancy center

Superconducting
quantum computing|

* Charge qubit
* Flux qubit
* Phase qubit
* Transmon

Software|

* libquantum
* OpenQASM
* Q#
* Qiskit
* IBM Q Experience

0.00

(0 votes)

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Quantum_algorithm_for_linear_systems_of_equations&oldid=191894"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template