Updated README plots.

README.md

@@ -6,6 +6,8 @@
 
 *Additionally, find ways to center figures, replace these figures with updated ones in better formatting, and possibly get things to play nice with dark mode, etc.* -->
 
+<!-- Brackets still not extending for bmatrix, etc. -->
+
 ## Introduction
 
 [Quantum signal processing](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.118.010501) (QSP) is a flexible quantum algorithm subsuming Hamiltonian simulation, quantum linear systems solvers, amplitude amplification, and many other common quantum algorithms. Moreover, for each of these applications, QSP often exhibits state-of-the-art space and time complexity, with comparatively simple analysis. QSP and its related algorithms, e.g., [Quantum singular value transformation](https://arxiv.org/abs/1806.01838) (QSVT), using basic alternating circuit ansätze originally inspired by composite pulse techniques in NMR, permit one to *transform the spectrum of linear operators by near arbitrary polynomial functions*, with the aforementioned good numerical properties and simple analytic treatment.
@@ -62,20 +64,24 @@ The guiding principle to take away from the discussion above is the following: t
 
 ## A few quick-and-dirty examples
 
-This package includes various tools for plotting aspects of the computed QSP unitaries, many of which can be run from the command line. As an example, in the chart below the blue line shows the target ideal polynomial QSP *response function* approximating a scaled version of $1/a$ over a sub-interval of $[-1,1]$. The red line shows the real part of an actual response function (the matrix element $P_x(a)$) achieved by a QSP circuit with computed phases, while the green line shows the imaginary part of the QSP response, with `n = 20` (the length of the QSP phase list less one).
+This package includes various tools for plotting aspects of the computed QSP unitaries, many of which can be run from the command line. As an example, in the chart below the dashed line shows the target ideal polynomial QSP *response function* approximating a scaled version of $1/a$ over a sub-interval of $[-1,1]$. The dark line shows the real part of an actual response function, i.e., the matrix element $P_x(a)$, achieved by a QSP circuit with computed phases, while the blue line shows the imaginary part of the QSP response, with `n = 20` (the length of the QSP phase list less one).
 
-![QSP response function for the inverse function 1/a](https://github.com/ichuang/pyqsp/blob/master/docs/IMAGE-sample-qsp-response-for-one-over-x-kappa3.png?raw=true)
+![QSP response function for the inverse function 1/a](https://github.com/ichuang/pyqsp/blob/master/docs/ex_inversion.png)
 
-This was generated by running `pyqsp --plot invert`, which also spits out the the following verbose text:
+This was generated by running `pyqsp --plot --tolerance=0.01 --seqargs 3 invert`, which also spits out the the following verbose text:
 
 ```
-    b=20, j0=10
-    [PolyOneOverX] minimum [-2.90002589] is at [-0.25174082]: normalizing
-    Laurent P poly 0.0002108924030879319 * w ^ (-21) + -0.0006894043260278334 * w ^ (-19) + 0.001994436843136674 * w ^ (-17) + -0.005148265426149545 * w ^ (-15) + 0.011941126989562179 * w ^ (-13) + -0.02504164571900347 * w ^ (-11) + 0.04774921151669176 * w ^ (-9) + -0.08322978307559126 * w ^ (-7) + 0.1333200017468883 * w ^ (-5) + -0.1973241700493915 * w ^ (-3) + 0.2714342596621151 * w ^ (-1) + 0.2714342596621151 * w ^ (1) + -0.1973241700493915 * w ^ (3) + 0.1333200017468883 * w ^ (5) + -0.08322978307559126 * w ^ (7) + 0.04774921151669176 * w ^ (9) + -0.02504164571900347 * w ^ (11) + 0.011941126989562179 * w ^ (13) + -0.005148265426149545 * w ^ (15) + 0.001994436843136674 * w ^ (17) + -0.0006894043260278334 * w ^ (19) + 0.0002108924030879319 * w ^ (21)
-    Laurent Q poly -2.784691352688532e-05 * w ^ (-21) + -3.467046922689296e-06 * w ^ (-19) + -0.00023447352272530086 * w ^ (-17) + 0.00018731079814912242 * w ^ (-15) + -0.0007159634932856078 * w ^ (-13) + 0.0032821300323626736 * w ^ (-11) + -0.001907488898700853 * w ^ (-9) + 0.012591630667616198 * w ^ (-7) + -0.02371053103573988 * w ^ (-5) + -0.016629567619072996 * w ^ (-3) + -0.18519029619384528 * w ^ (-1) + -0.20476480667058175 * w ^ (1) + -0.5374170003848409 * w ^ (3) + -0.2638332742746844 * w ^ (5) + 0.21212227077358078 * w ^ (7) + 0.27748656462486654 * w ^ (9) + -0.34978762979573563 * w ^ (11) + 0.17888109364117422 * w ^ (13) + -0.07649917245226195 * w ^ (15) + 0.03551004671728361 * w ^ (17) + -0.011926352140796492 * w ^ (19) + 0.001997855069006951 * w ^ (21)
-    Laurent Pprime poly 0.00018304548956104657 * w ^ (-21) + -0.0006928713729505227 * w ^ (-19) + 0.001759963320411373 * w ^ (-17) + -0.0049609546280004226 * w ^ (-15) + 0.01122516349627657 * w ^ (-13) + -0.021759515686640796 * w ^ (-11) + 0.0458417226179909 * w ^ (-9) + -0.07063815240797505 * w ^ (-7) + 0.10960947071114842 * w ^ (-5) + -0.2139537376684645 * w ^ (-3) + 0.08624396346826982 * w ^ (-1) + 0.06666945299153335 * w ^ (1) + -0.7347411704342324 * w ^ (3) + -0.1305132725277961 * w ^ (5) + 0.12889248769798953 * w ^ (7) + 0.3252357761415583 * w ^ (9) + -0.3748292755147391 * w ^ (11) + 0.1908222206307364 * w ^ (13) + -0.0816474378784115 * w ^ (15) + 0.037504483560420285 * w ^ (17) + -0.012615756466824325 * w ^ (19) + 0.0022087474720948828 * w ^ (21)
-    [QuantumSignalProcessingWxPhases] Error in reconstruction from QSP angles = 0.4862234440482484
-    QSP angles = [0.11177647198529908, 0.321286291382733, -2.449109005349844, 0.5475854935639934, -0.23068701778999645, 1.852723853663707, -0.1638598380129409, -0.031620025684050396, -0.3018780297835489, -1.8740083256355018, 0.6314873861312269, -0.036881744534211114, 1.300525766122238, 0.3073180685644643, -0.23974313142278042, 0.09536754986888613, -1.188342341212731, -0.6092537117168764, 0.4850840958947118, 0.8800119831449805, 0.4163653216360098, 2.480415494993986]
+    b=30, j0=14
+    [PolyOneOverX] minimum [-3.5325637] is at [-0.20530335]: normalizing
+    [PolyOneOverX] bounding to 0.5
+    [pyqsp.PolyOneOverX] pcoefs=[ 0.00000000e+00  4.24568213e+00  0.00000000e+00 -6.14813187e+01
+      0.00000000e+00  5.70160728e+02  0.00000000e+00 -3.77110116e+03
+      0.00000000e+00  1.86774294e+04  0.00000000e+00 -7.07245446e+04
+      0.00000000e+00  2.06037512e+05  0.00000000e+00 -4.61025085e+05
+      0.00000000e+00  7.86778785e+05  0.00000000e+00 -1.01130011e+06
+      0.00000000e+00  9.59305607e+05  0.00000000e+00 -6.49556764e+05
+      0.00000000e+00  2.96436030e+05  0.00000000e+00 -8.15921088e+04
+      0.00000000e+00  1.02215704e+04]
 ```
 
 The sign function is also often useful to implement, e.g. for oblivious amplitude amplification. Running instead
@@ -84,15 +90,15 @@ pyqsp --plot-positive-only --plot --polyargs=19,10 --plot-real-only --polyname p
 ```
 yields QSP phases for a degree `19` polynomial approximation, using the error function applied to `kappa * a`, where `kappa` is `10`. This also gives a plotted response function:
 
-![Example QSP response function approximating the sign function](https://github.com/ichuang/pyqsp/blob/master/docs/IMAGE-sample-qsp-response-for-sign-kappa-10-degree-19.png?raw=true)
+![Example QSP response function approximating the sign function](https://github.com/ichuang/pyqsp/blob/master/docs/ex_amplitude_amplification.png)
 
 A threshold function further generalizes on the sign function, e.g., as used in distinguishing eigenvalues or singular values through windowing. Running
 ```
 pyqsp --plot-real-only --plot --polyargs=20,20 --polyname poly_thresh poly
 ```
 yields QSP phases for a degree `20` polynomial approximation, using two error functions applied to `kappa * 20`, with a plotted response function:
 
-![Example QSP response function approximating a threshold function](https://github.com/ichuang/pyqsp/blob/master/docs/IMAGE-sample-qsp-response-for-threshold-polynomial-degree-20-kappa-20.png?raw=true)
+![Example QSP response function approximating a threshold function](https://github.com/ichuang/pyqsp/blob/master/docs/ex_bandpass_response.png)
 
 In addition to approximations to piecewise continuous functions, the smooth trigonometric functions sine and cosine functions also often appear, e.g., in Hamiltonian simulation. Running:
 ```
@@ -108,8 +114,6 @@ This last example also shows how an arbitrary function can be specified (using a
 
 ## An overview of codebase structure
 
-
-
 - `angle_sequence.py` is the main module of the algorithm.
 - `LPoly.py` defines two classes `LPoly` and `LAlg`, representing Laurent polynomials and Low algebra elements respectively.
 - `completion.py` describes the completion algorithm: Given a Laurent polynomial element $F(\tilde{w})$, find its counterpart $G(\tilde{w})$ such that $F(\tilde{w})+G(\tilde{w})*iX$ is a unitary element.

pyqsp/response.py

@@ -188,7 +188,8 @@ def PlotQSPResponse(
     if plot_tight_y:
         plt.ylim([-0.1, 1.1 * ymax])
     else:
-        plt.ylim([-1.5 * ymax, 1.5 * ymax])
+        # plt.ylim([-1.5 * ymax, 1.5 * ymax])
+        plt.ylim([-1.25, 1.25])
 
     # Remove unecessary axes.
     ax = plt.gca()