g 0dZddlZddlmZmZddlmZddlZddlZ ddl m Z ddl m Z ddlmZddlmZmZdd lmZdd lmZdd lmZd d lmZmZd dlmZd dlm Z ej!j"d7dddZ#ej!j" d8dZ$ej!j" d9ddddd ddZ%ej!j" d:dddZ&ej!j"d7dddZ'dZ(dZ)dZ*dZ+ej!j"ej,j" d;dddZ-ej!j"d Z.d!Z/dd*ee4d+e5d'ee2fd,Z6 d?d.ee4d/e5d0e2d+e5d'e2f d1Z7Gd2d3Z8dz%plot_state_hinton..v5AAAaCFF122J$$S))AAAcdg|],}t|dd-Srr r#s r'r(z%plot_state_hinton..w5>>>1Q!!#&&>>>r*grayequalboxwhiteblack?) facecolor edgecolorfontsizeZr8rotationz Re[$\rho$]z Im[$\rho$])) matplotlibrr num_qubitsrmathceillog2npabsdatamaxrealimagsubplots get_figurerangeshapepatch set_facecolor set_aspectxaxisset_major_locator NullLocatoryaxis ndenumeratesqrt Rectangle add_patch set_xticksarange set_yticksset_xlimset_ylimset_yticklabelsset_xticklabels set_title tight_layoutsuptitlersavefig)statetitlerax_realax_imagrpltrho max_weightdatarealdataimagfigax1ax2 column_names row_nameslylxxywplot_xplot_ycolorsizerectr&s @r'plot_state_hintonrz'sp)(((((   C .C { !LMMMdi "&*:*:*>*>*@*@ A ABBBJwsx  Hwsx  H 7,,q!W,==Zc33  '$$&&CC$$&&CAAAA5C==AAAL>>>>af >>>tttDI ^FB 2 ''' w&&& ##COO$5$5666 ##COO$5$566611 IFQAQ FF 1uuGG'E726!99z122D==vq(#,*AB !D MM$     sRYr]]*+++ sRYr]]*+++ aW aW I333 L2CCC mb 111 2 ''' w&&& ##COO$5$5666 ##COO$5$566611 IFQAQ FF 1uuGG'E726!99z122D==vq(#,*AB !D MM$     sRYr]]*+++ sRYr]]*+++ aW aW I333 L2CCC mb 111 ) UR (((7?"3''' {{8$$$r* cartesianc.ddlm}|d}|||}|dkr|d|d|d} } }|tj| ztj| z|d<|tj| ztj| z|d<|tj| z|d<|||| |:|j} | |d|dt| | SdS) a,Plot the Bloch sphere. Plot a Bloch sphere with the specified coordinates, that can be given in both cartesian and spherical systems. Args: bloch (list[double]): array of three elements where [, , ] (Cartesian) or [, , ] (spherical in radians) is inclination angle from +z direction is azimuth from +x direction title (str): a string that represents the plot title ax (matplotlib.axes.Axes): An Axes to use for rendering the bloch sphere figsize (tuple): Figure size in inches. Has no effect is passing ``ax``. coord_type (str): a string that specifies coordinate type for bloch (Cartesian or spherical), default is Cartesian font_size (float): Font size. Returns: :class:`matplotlib:matplotlib.figure.Figure` : A matplotlib figure instance if ``ax = None``. Raises: MissingOptionalLibraryError: Requires matplotlib. Examples: .. plot:: :alt: Output from the previous code. :include-source: from qiskit.visualization import plot_bloch_vector plot_bloch_vector([0,1,0], title="New Bloch Sphere") .. plot:: :alt: Output from the previous code. :include-source: import numpy as np from qiskit.visualization import plot_bloch_vector # You can use spherical coordinates instead of cartesian. plot_bloch_vector([1, np.pi/2, np.pi/3], coord_type='spherical') r)BlochN)rr)axes font_size sphericalrr)rc) blochr}rBsincos add_vectorsrenderrkset_size_inchesr) rrcaxr coord_typerr}Brthetaphirks r'plot_bloch_vectorrsb 2+++A[  a%(E!H#5rve}}$rvc{{2arve}}$rvc{{2arve}}$aMM%HH5H ze GAJ 333"3''' 4r*F) reverse_bitsrrtitle_font_size title_padcjddlm}|rt|dddnt|} t| } | |\} } | | z} n|d| z \} } ||nd} ||n| }|| | f}t | D]T}|r| dz |z n|}|d| |dzd }t| |d t|z||| U| ||d |d z zt|||S| |S)aW Plot a Bloch sphere for each qubit. Each component :math:`(x,y,z)` of the Bloch sphere labeled as 'qubit i' represents the expected value of the corresponding Pauli operator acting only on that qubit, that is, the expected value of :math:`I_{N-1} \otimes\dotsb\otimes I_{i+1}\otimes P_i \otimes I_{i-1}\otimes\dotsb\otimes I_0`, where :math:`N` is the number of qubits, :math:`P\in \{X,Y,Z\}` and :math:`I` is the identity operator. Args: state (Statevector or DensityMatrix or ndarray): an N-qubit quantum state. title (str): a string that represents the plot title figsize (tuple): size of each individual Bloch sphere figure, in inches. reverse_bits (bool): If True, plots qubits following Qiskit's convention [Default:False]. font_size (float): Font size for the Bloch ball figures. title_font_size (float): Font size for the title. title_pad (float): Padding for the title (suptitle `y` position is `y=1+title_pad/100`). Returns: :class:`matplotlib:matplotlib.figure.Figure` : A matplotlib figure instance. Raises: MissingOptionalLibraryError: Requires matplotlib. VisualizationError: if input is not a valid N-qubit state. Examples: .. plot:: :alt: Output from the previous code. :include-source: from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector from qiskit.visualization import plot_bloch_multivector qc = QuantumCircuit(2) qc.h(0) qc.x(1) state = Statevector(qc) plot_bloch_multivector(state) .. plot:: :alt: Output from the previous code. :include-source: from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector from qiskit.visualization import plot_bloch_multivector qc = QuantumCircuit(2) qc.h(0) qc.x(1) # You can reverse the order of the qubits. from qiskit.quantum_info import DensityMatrix qc = QuantumCircuit(2) qc.h([0, 1]) qc.t(1) qc.s(0) qc.cx(0,1) matrix = DensityMatrix(qc) plot_bloch_multivector(matrix, title='My Bloch Spheres', reverse_bits=True) rrNr-rr<r3d projectionzqubit )rrr?d)r8rs) r=r_bloch_multivector_datalen figaspectfigurerJ add_subplotrstrr`rra)rbrcrrrrrrrf bloch_datar&widthheightdefault_title_font_sizerkr%posrs r'plot_bloch_multivectorrs^)(((((1=`&&ttt,,BYZ_B`B` j//C v   a#g.. v+4+@iib)8)DooJaO **eV_* - -C 3ZZ  )0cAgkkq __QQUt_ < < qM8c#hh.2wR[     LLC)c/4ILJJJs### {{8$$$r*c h5ddlm}ddlm} ddlm} t |} | j55tdtj | j } tj | j } 5fdtd5zD}5fdtd5zD}| jdd\}}tjd|d }tjd|d }tj|d z|d z\}}|}|}tj||z}d tj|z}|}| }| }|d \}}nFt+|dkrt-d |ddn|d}|d dn|d }|R|P|d}| |d}|d dd dd}|d dddd}n3||}|}|}n|}d}|}|tj|}tj|}|\} }!t;| dz |!}"t=d|"z}#ddtj|"zz }$|||df|||dffD]G\}%}&}'}(|% tj|&})tj|&}*tA|'tBr*|'"dr|#|'}'|&dk}+tj$|+rtK||+||+||+||+||+|&|+|'},|%&||+||+||+||+||+|&|+|d}-|-'|,|*dcxkr|)krnnd|gd|g}/}.tQtS|.|.dddztj*|/ddgdzg}0| |0d dd }1|1+d!|%,|1|&dk}2tj$|2rtK||2||2||2||2||2|&|2|'},|%&||2||2||2||2||2|&|2|d"}3|3'|,|%-|(d#|#$|%.tjd |d zd |%/tjd |d zd |)|*kr-|%j01|*t7|d%z|nN|*dkr-|%j01|*t7|d%z|n|%j01d&'|%2|%j34||#d(d)d*+|%j54||#d,d-d.+|%j67D]P}4|4j89|#|4j8:d-|4j8;d/Q|%<d0|$1|%=d|%>dI|?||#d2z$|@d3ddd dd4||t|||S|B|S)5a Plot the cityscape of quantum state. Plot two 3d bar graphs (two dimensional) of the real and imaginary part of the density matrix rho. Args: state (Statevector or DensityMatrix or ndarray): an N-qubit quantum state. title (str): a string that represents the plot title figsize (tuple): Figure size in inches. color (list): A list of len=2 giving colors for real and imaginary components of matrix elements. alpha (float): Transparency value for bars ax_real (matplotlib.axes.Axes): An optional Axes object to be used for the visualization output. If none is specified a new matplotlib Figure will be created and used. If this is specified without an ax_imag only the real component plot will be generated. Additionally, if specified there will be no returned Figure since it is redundant. ax_imag (matplotlib.axes.Axes): An optional Axes object to be used for the visualization output. If none is specified a new matplotlib Figure will be created and used. If this is specified without an ax_real only the imaginary component plot will be generated. Additionally, if specified there will be no returned Figure since it is redundant. Returns: :class:`matplotlib:matplotlib.figure.Figure` : The matplotlib.Figure of the visualization if the ``ax_real`` and ``ax_imag`` kwargs are not set Raises: MissingOptionalLibraryError: Requires matplotlib. ValueError: When 'color' is not a list of len=2. VisualizationError: if input is not a valid N-qubit state. Examples: .. plot:: :alt: Output from the previous code. :include-source: # You can choose different colors for the real and imaginary parts of the density matrix. from qiskit import QuantumCircuit from qiskit.quantum_info import DensityMatrix from qiskit.visualization import plot_state_city qc = QuantumCircuit(2) qc.h(0) qc.cx(0, 1) state = DensityMatrix(qc) plot_state_city(state, color=['midnightblue', 'crimson'], title="New State City") .. plot:: :alt: Output from the previous code. :include-source: # You can make the bars more transparent to better see the ones that are behind # if they overlap. import numpy as np from qiskit.quantum_info import Statevector from qiskit.visualization import plot_state_city from qiskit import QuantumCircuit qc = QuantumCircuit(2) qc.h(0) qc.cx(0, 1) qc = QuantumCircuit(2) qc.h([0, 1]) qc.cz(0,1) qc.ry(np.pi/3, 0) qc.rx(np.pi/5, 1) state = Statevector(qc) plot_state_city(state, alpha=0.6) rNr)Poly3DCollectionrcdg|],}t|dd-Srr r#s r'r(z#plot_state_city..r)r*rcdg|],}t|dd-Srr r#s r'r(z#plot_state_city..r,r*rg?r3)#648fffrz 'color' must be a list of len=2.r)r<rrt)rr4rF)rcomputed_zorderg@ Real Imaginary#g?)alphazorderr-k)rr4 linewidths?g?u Amplitude (ρ)r7g& .>T)auto-righttop)r8r;havag6leftcenterbottom)rrr)aspectzoomg?g?)rrrrhspacewspace)Cmatplotlib.colorscolorsr=rmpl_toolkits.mplot3d.art3drr r>rrBrFrDrGrJrKrXmeshgridflattenzeros ones_likecopyr ValueErrorrrrIr_rEget_size_inchesminintrT isinstancer startswith to_rgba_arrayanygenerate_facecolorsbar3drMlistziprepeat set_zorderadd_collection3dr^rWrYr~ set_zlim3dget_autoscalez_onrOset_ticklabelsrRzaxisget_major_tickslabel1 set_fontsizeset_horizontalalignmentset_verticalalignmentset_box_aspect set_xmargin set_ymarginr`subplots_adjustrra)6rbrcrrwrrdrermcolorsrfrrgrirjrnrorprqxposyposzposdxdydzrdzi real_color imag_colorrkrlrmmax_dzrmax_dzi fig_width fig_height max_plot_size max_font_sizemax_zoomrdzcolzlabelmax_dzmin_dzdznfc negative_barsxlimylimvertsplanedzp positive_barstickr&s6 @r'plot_state_cityrmsx('''''((((((;;;;;;   C .C { !LMMMwsx  Hwsx  HBAAA5C==AAAL>>>>af >>>I ^BQB FB 9QA  D 9QA  DTD[$+66JD$ <<>>D <<>>D 8BG  D r|D!! !B B     C     C }!5 JJ u::???@@ @"'("2YYa "'("2YYa 7? ?GjjCj88ooaA$oNNooaA$oNN    ""  ""fSkkGfSkkG //11Iz D(*55MM)**MR"'-0001H c:v& c:{+ RRBV :  c3   -CNN3$7$7 -'',,C1f 6#;; ,$S 49d3iC"S'2c7CBHHS S S 333%  M  ' ' + + + A         R1b'$D#dT$$B$Z/41C1CaS1WMMNNOE$$U$#RSTTTE   T " " "    & & &Ag 6#;; ,$S 49d3iC"S'2c7CBHHS S S 333%  M  ' ' + + + ///- HHH biR#Xq11222 biR#Xq11222 V   G  vs7T>7'C'C D D D D{{""63w~w+G+GHHHH"""---    w5      =5VPX    H,,.. 8 8D K $ $] 3 3 3 K / / 7 7 7 K - -h 7 7 7 7 ::: q qLL!5L666C1QOOO7?"3''' {{8$$$r*cddlm}t|\}}t|} |d}|d}t j| } d} |d} ||\} }nd } |} |dd d | | || |d | d d| dd| | | gd||dd|dd|dd g|d|j|jzD]}|jd||d| rt1| || S| |S)ak Plot the Pauli-vector representation of a quantum state as bar graph. The Pauli-vector of a density matrix :math:`\rho` is defined by the expectation of each possible tensor product of single-qubit Pauli operators (including the identity), that is .. math :: \rho = \frac{1}{2^n} \sum_{\sigma \in \{I, X, Y, Z\}^{\otimes n}} \mathrm{Tr}(\sigma \rho) \sigma. This function plots the coefficients :math:`\mathrm{Tr}(\sigma\rho)` as bar graph. Args: state (Statevector or DensityMatrix or ndarray): an N-qubit quantum state. title (str): a string that represents the plot title figsize (tuple): Figure size in inches. color (list or str): Color of the coefficient value bars. ax (matplotlib.axes.Axes): An optional Axes object to be used for the visualization output. If none is specified a new matplotlib Figure will be created and used. Additionally, if specified there will be no returned Figure since it is redundant. Returns: :class:`matplotlib:matplotlib.figure.Figure` : The matplotlib.Figure of the visualization if the ``ax`` kwarg is not set Raises: MissingOptionalLibraryError: Requires matplotlib. VisualizationError: if input is not a valid N-qubit state. Examples: .. plot:: :alt: Output from the previous code. :include-source: # You can set a color for all the bars. from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector from qiskit.visualization import plot_state_paulivec qc = QuantumCircuit(2) qc.h(0) qc.cx(0, 1) state = Statevector(qc) plot_state_paulivec(state, color='midnightblue', title="New PauliVec plot") .. plot:: :alt: Output from the previous code. :include-source: # If you introduce a list with less colors than bars, the color of the bars will # alternate following the sequence from the list. import numpy as np from qiskit.quantum_info import DensityMatrix from qiskit import QuantumCircuit from qiskit.visualization import plot_state_paulivec qc = QuantumCircuit(2) qc.h(0) qc.cx(0, 1) qc = QuantumCircuit(2) qc.h([0, 1]) qc.cz(0, 1) qc.ry(np.pi/3, 0) qc.rx(np.pi/5, 1) matrix = DensityMatrix(qc) plot_state_paulivec(matrix, color=['crimson', 'midnightblue', 'seagreen']) rrN)rrr3TrFrz--)r linewidth linestylerrwrr)rrw Coefficientsr6r7)r-grr3rFr:Paulir-z#eeeeeer<)r=r_paulivec_datarrBrXrHrIgridbaraxhline set_ylabelrWrYr] set_xlabelr[rMrOrrRrrr^rra)rbrcrrwrrrflabelsvaluesnumelemindr return_figrkrs r'plot_state_paulivecrjsX)(((((#E**NFF&kkG } )G  C E z ,,w,//RR mmooGG1TG222FF3U1F555JJ#J&&&MM.2M...MM#MM'''(((vR888MM'BM'''KKQY((**RX-E-E-G-GG%%   $$$$LLL$$$("3''' {{8$$$r*c |dkrdStdtt||z dz|dztd|dzdS)zReturn the number of combinations for n choose k. Args: n (int): the total number of options . k (int): The number of elements. Returns: int: returns the binomial coefficient rc*||dz|dz S)Nrr)rrrss r'zn_choose_k..sq1Q4x!A$r*r)rrrJ)nrs r' n_choose_krsY Avvq ..E!a%!)QU4K4KUSTVWZ[V[__0]0]_` a aar*ct|krtdfd|DtfdtD}t |S)a1Return the lex index of a combination.. Args: n (int): the total number of options . k (int): The number of elements. lst (list): list Returns: int: returns int index for lex order Raises: VisualizationError: if length of list is not equal to k zlist should have length kc g|] }dz |z  S)rr)r$rrrs r'r(zlex_index..s! # # #!AEAI # # #r*c3VK|]#}tdz |z |dzV$dS)rN)r)r$r%combrs r' zlex_index..s=EEq 4A ?AE22EEEEEEr*)rrsumrJr)rrlstdualmr#s`` @r' lex_indexr(su 3xx1}} !<=== # # # #s # # #D EEEEEE!HHEEE E EE u::r*ct|}|d}|d||z krtddt|D}t |||S)z*Return the index of a string of 0s and 1s.10zs must be a string of 0 and 1c$g|] \}}|dk |S)r*r)r$rchars r'r(z$bit_string_index..s! = = =ICCr*)rcountr enumerater()srroness r'bit_string_indexr2so AA  Awws||q1u !@AAA = =1 = = =D Q4  r*ctj|tjdzdz ztjdzz}tj|tjdzz dd}|S)zMap a phase of a complexnumber to a color in (r,g,b). complex_number is phase is first mapped to angle in the range [0, 2pi] and then to the HSL color wheel rrrr3)rBanglepicolorsys hls_to_rgb)complex_numberanglesrgbs r' phase_to_rgbr; sQ h~&&"%!)a-8RUQY GF  f 2C = =C Jr*Tc vddlm}ddlm}ddlm} ddl} ddlm} ddlm } t|} | j }|td | | j\}}|d }|d }|| }nd }|}|dd}||ddddfd}|jdd|jdd|jdd|jd |ddt3|jdr|jdt7jddt6jzd}t7jdt6jd}t7jt7j|t7j |}t7jt7j |t7j |}t7jt7j!t7j"|t7j|}|#|||dd|j$ddd|j%&d|j'&d|j(&d|j%j)*d|j'j)*d|j(j)*d|+g|,g|-gt]|j/ddz ddD]}||d kr|dd|f}t7j0|1}t7j2||dt6jzzdt6jzz}t7j3d!|z}||z}|}t]d|zD]{}ti|dd5|}|6d"} d#| z|z dz}!to|| }"tq|}#ts| |z t6jdzz|#dzt6j|"z zz}$| |dz ks| |dz kr+|#|"dz kr"t6j|$z dt6jz|"z z }$t7j:d|!dzz t7j|$z}%t7j:d|!dzz t7j |$z}&t7j;t7j<||||=}'t}|'d}'t||}(d})|&d$krd|&z })t7j@|'dsL|rId%}*t7jAt7j:d|!dzz |!}+|*t7j |+zt7j|$z},|*t7j |+zt7j |$z}-|*t7j|+z}.d&|zd'z}/|rt7j2||t6jd(zzt6jdzz}0|r|/d)|0d*zt6jz d+d,z }/n.t|0d-Cd.d/}0|/d)|0d0z }/|D|,|-|.|/d1d1d23|E|%g|&g|!g|(|(d4t7j:|'d5z|)6| d|%gd|&gd|!gd7|'d8|(d9}1|F|1}t]|dzD]} t7jd#t6jzdt6jzd:}2d#| z|z dz}t7j:d|dzz }3|3t7j|2z}|3t7j |2z}|E|||d;dd|Edgdgdgd;d;d4dd6d?}4t7j!|4}2| G|4}5||ddddf}6|6H|2|5d|4zd@zd|5dd|4zd@zzdAB|6F| dCd=dDdEdF}7|rgdG}8ngdH}8|6Ddd|8dd1d1dIJ|6D|7d|8dd1d1dIJ|6Dd|7|8dd1d1dIJ|6D|7 d|8dd1d1dIJ|6Dd|7 |8d(d1d1dIJ|rt|||S|J|S)Ka Plot the qsphere representation of a quantum state. Here, the size of the points is proportional to the probability of the corresponding term in the state and the color represents the phase. Args: state (Statevector or DensityMatrix or ndarray): an N-qubit quantum state. figsize (tuple): Figure size in inches. ax (matplotlib.axes.Axes): An optional Axes object to be used for the visualization output. If none is specified a new matplotlib Figure will be created and used. Additionally, if specified there will be no returned Figure since it is redundant. show_state_labels (bool): An optional boolean indicating whether to show labels for each basis state. show_state_phases (bool): An optional boolean indicating whether to show the phase for each basis state. use_degrees (bool): An optional boolean indicating whether to use radians or degrees for the phase values in the plot. Returns: :class:`matplotlib:matplotlib.figure.Figure` : A matplotlib figure instance if the ``ax`` kwarg is not set Raises: MissingOptionalLibraryError: Requires matplotlib. VisualizationError: Input is not a valid N-qubit state. QiskitError: Input statevector does not have valid dimensions. Examples: .. plot:: :alt: Output from the previous code. :include-source: from qiskit import QuantumCircuit from qiskit.quantum_info import Statevector from qiskit.visualization import plot_state_qsphere qc = QuantumCircuit(2) qc.h(0) qc.cx(0, 1) state = Statevector(qc) plot_state_qsphere(state) .. plot:: :alt: Output from the previous code. :include-source: # You can show the phase of each state and use # degrees instead of radians from qiskit.quantum_info import DensityMatrix import numpy as np from qiskit import QuantumCircuit from qiskit.visualization import plot_state_qsphere qc = QuantumCircuit(2) qc.h([0, 1]) qc.cz(0,1) qc.ry(np.pi/3, 0) qc.rx(np.pi/5, 1) qc.z(1) matrix = DensityMatrix(qc) plot_state_qsphere(matrix, show_state_phases = True, use_degrees = True) r)gridspecr)CircleN)linalgr)Arrow3Dr)rrTrFr)nrowsncolsrrgrri)elevazimrrrrrz grid.colorg?)rstridecstriderwrr)rrrgr-gMbP?yr*g?g?z$\vertz\rangle$rz $z.1fz^\circ$)ndigitsr5z\pi$r )rrrxo)markerfacecolormarkeredgecolormarker markersizer-)mutation_scaler arrowstylerwlwr)r3r3r3:r3)rwrXlsr@rr)rradius)rrr1r gffffff?)z Phase (Deg)r+90z180 270)Phasez$0$z$\pi/2$z$\pi$z$3\pi/2$r6)horizontalalignmentverticalalignmentr8)Kr=r=rmatplotlib.patchesr>seabornscipyr?rr@r r>reighrDrrIGridSpecrr~ set_xlim3d set_ylim3drr view_inithasattrrrBlinspacer5outerrrr1rx plot_surfacercParamsrOset_pane_colorrRrline set_colorrWrY set_zticksrJrKabsoluteargmaxr4expr!r"r.rr2floatrTrFdotconjrr;isclosearctan2r replacetextplot add_artist hls_palettepierra)9rbrrshow_state_labelsshow_state_phases use_degreesrr=rfr>snsr?r@rgr&eigvalseigvecsrrkgsuvrrrszidxlocr9anglesetdr%elementweightzvaluenumber_of_divisions weight_orderr4xvalueyvalueprob colorstatealfarprime angle_theta xvalue_text yvalue_text zvalue_text element_text element_anglearrrrrmoffsetrs9 r'plot_state_qspherers `$#####(((((())))))   C .C { !LMMM{{38,,GW z jjj)) mmoo   !  , ,B AaC1H$ 7 7BGtS!!!GtS!!!GtS!!!GLLLLacL"""rw())* y))) Aq25y"%%A Arub!!A BF1II&&A BF1II&&A $$bfQii00AOO 1aAS\,-Gs^_ H0111H0111H0111HM0111HM0111HM0111MM"MM"MM"W]1%)2r22kk 3<%  AAAsFOE+e$$++--ChuSz**QY61ru9EFvcFl++Hu$EA1c6]]I !I !a&&***3// s++fq1,&0F&;&;#/88 v*ruqy9 1$0C(CDQUNNq1u__<;NQR;R+R+REEMQY9L-LMEVQY//"&--?VQY//"&--?wrveAha @@AA4||)%(33 S==+>">"NK"(26++>+>">"NK"(26++>+>">K#,w#6#DL(C)+%(););ruqy)IbeVWi(X &C(,[-#2E2M,[,[,[,[[LL,4]A,N,N,N,V,VW[]c,d,dM(,B-,B,B,BBLGG###$##HHH$.$.!wt}}r1   GKKK#%"$    a     A,, Q Q BJBE 3??K!Oa'GA1H%%u %u %1a1CPPPP GG / /       A GAJJE __Q  F //"QRRV* % %CGGE&Q!. !a%1* 1EEdGSSSNN66&#WQ???@@@ FE===DDDHHQ6!9(hacHdddHH6!9(hac HH 66!9(hac HH F1I8xbd HH F7F1I8xbd ("3''' {{8$$$r*cddlm}tjgd}tj|j|jz} d||fd||fd||ffD]Y\} } } | dtjtjf} | dtjtjf} | | |d| fzz| d| f<Z| d| jddz} g} t|t|kr|D]}| |gdznWt| |} t| t|kr| dt|zz} t| }t| |S) aGenerates shaded facecolors for shaded bars. This is here to work around a Matplotlib bug where alpha does not work in Bar3D. Args: x (array_like): The x- coordinates of the anchor point of the bars. y (array_like): The y- coordinates of the anchor point of the bars. z (array_like): The z- coordinates of the anchor point of the bars. dx (array_like): Width of bars. dy (array_like): Depth of bars. dz (array_like): Height of bars. color (array_like): sequence of valid color specifications, optional Returns: list: Shaded colors for bars. Raises: MissingOptionalLibraryError: If matplotlib is not installed rN))rrrrrrrrrrrr)rrrrrrrErrr)rrrr)rrrEr)rrrr)rrrErrr.)r-)rrrBarrayemptyrKnewaxisreshaperextendrr_generate_normals _shade_colors)rrrsrrrrrwrcuboidpolysr%pdp facecolorscnormalss r'rr9s((''''' X+ + + --F` HQWv|+ , ,EBZ!QaBZ8001b c2:rz) * RZ+ ,BQ//c1f  MM%%+abb/1 2 2EJ 5zzSVV ' 'A   qcAg & & & & ''//6677 z??SVV # # !c!ff* $J&&G W - --r*cxt|tjrS|jd}d|dzd|zdz}}}|d|ddf|d|ddfz }|d|ddf|d|ddfz }ntjt |df}tjt |df}t |D]c\}}t |}d|dzd|zdz}}}||ddf||ddfz ||ddf<||ddf||ddfz ||ddf<dtj||S)a`Takes a list of polygons and return an array of their normals. Normals point towards the viewer for a face with its vertices in counterclockwise order, following the right hand rule. Uses three points equally spaced around the polygon. This normal of course might not make sense for polygons with more than three points not lying in a plane, but it's a plausible and fast approximation. Args: polygons (list): list of (M_i, 3) array_like, or (..., M, 3) array_like A sequence of polygons to compute normals for, which can have varying numbers of vertices. If the polygons all have the same number of vertices and array is passed, then the operation will be vectorized. Returns: normals: (..., 3) array_like A normal vector estimated for the polygon. rIrrr.N)rrBndarrayrKrrr/cross) polygonsri1i2i3v1v2poly_ipss r'rrsv((BJ''2 N2 QA B c2qqqj !HS"aaaZ$8 8 c2qqqj !HS"aaaZ$8 8Xs8}}a( ) ) Xs8}}a( ) )#H-- 2 2JFBBAAFAEQJBBr111uI2qqq5 1BvqqqyMr111uI2qqq5 1BvqqqyMM 8B  r*cf ddlm}m}ddlm} |ddd t j fd|D}t j|}|r|t||t||}t||||<| |}|ddd f} d ||ddtj fd zz|z} | | ddd f<n&t j | } | S) z Shade *color* using normal vectors given by *normals*. *color* can also be an array of the same length as *normals*. r) Normalize LightSourceNg -x3@)azdegaltdegcltj|ddz|ddzz|ddzzS)Nrrr)rBrT)rs r'modz_shade_colors..mods4wqtqy1Q419,qtqy8999r*cg|]?}|r&tj||z jn tj@Sr)rBrw directionnan)r$r lightsourcers r'r(z!_shade_colors..sHZZZQcc!ff HCCFF K1 2 2 2"&ZZZr*rr3)rrrrrBrisnanrrrErr asanyarrayr) rwrrrrrshademasknormrrrs ` @r'rrsm 98888888''''''!kG<<< ::: HZZZZZRYZZZ  E HUOO D xxzz -yU4[))3uT{+;+;<<5;''te %%e,,aaad U AAArzM2S88EAqqq!t u%%**,, Mr*ketrbdims conventionreturnc |+t|dhkrd}nd}d}d}|r!d}|j}d|d}|j}t |d ko%t|dhk}|d kr|rt |jfi|} nt|jfd di|} || z|zS) aSReturn a Latex representation of a state. Wrapper function for `qiskit.visualization.array_to_latex` for convention 'vector'. Adds dims if necessary. Intended for use within `state_drawer`. Args: state: State to be drawn dims (bool): Whether to display the state's `dims` convention (str): Either 'vector' or 'ket'. For 'ket' plot the state in the ket-notation. Otherwise plot as a vector **args: Arguments to be passed directly to `array_to_latex` for convention 'ket' Returns: Latex representation of the state NrFTrz\begin{align} z\\ \text{dims=z } \end{align}rrsource) setr _op_shapedims_lrdims_r_state_to_latex_ket_datar) rbrrargsprefixsuffixdims_stroperator_shapeis_qubit_statevector latex_strs r'state_to_latexrs $ | uzz||   # #DDD F F D#?))++CxCCC_N~4466771<d^EZEZE\E\A]A]bcadAdU3' <Convert a list of numbers to latex formatted terms The first non-zero term is treated differently. For this term a leading + is suppressed. Args: numbers: List of numbers to format decimals: Number of decimal places to round to (default: 10). Returns: List of formatted terms T)r first_term coefficientF)rappend)rrrtermsnumberterms r'_numbers_to_latex_termsrsRJ EVh:[_``` T Lr*rMrDmax_sizercN ttjt| fd}t j||}t j|dkd}t||krB|d|dzdgz|| dzdzdz}t|||}d||dz<nt|||}d}t|D]+\}} | |dz } ||} || } || d| d z },||zS) aConvert state vector to latex representation Args: data: State vector max_size: Maximum number of non-zero terms in the expression. If the number of non-zero terms is larger than the max_size, then the representation is truncated. prefix: Latex string to be prepended to the latex, intended for labels. decimals: Number of decimal places to round to (default: 10). Returns: String with LaTeX representation of the state vector cXt|ddS)Nrr )r%r&s r'ket_namez%_state_to_latex_ket..ket_name3s%1vvabbz$$$r*rNrrrz + \ldots z |z\rangle) rr?rArrBaroundwheretolistrr/) rDrrrrnonzero_indices latex_termsrrket_idxrrr&s @r'rr"sk diD "" # #C%%%%% 9T8 $ $Dhtqy))!,3355O ?h&& Oh!mO ,s 2_hYRS^VWEWEYEY5Z Z .d?.CXNN )-A &&-d?.CXNN I!/2222 W ?  &IIs#D(7##C D11C111 1II I r*c&eZdZdZddZdZdZdS) TextMatrixzeText representation of an array, with `__str__` method so it displays nicely in Jupyter notebooksrNrc||_||_|t|ttfr&t |dhkst|trt| t| krRt | t | cxkrdhkrnnd}nd}||_||_ ||_ t|tr ||_dSt|trt|dz|_dS|d|_dS)NrFTr)rbrrrr rrrr input_dims output_dimsrrrr)selfrbrrrrs r'__init__zTextMatrix.__init__PsT   <5; ">?? C DUDUZ[Y\D\D\5(++E]((**++s53D3D3F3F/G/GGG((**++s53D3D3F3F/G/GNNNNA3NNNNN   h $ $ ($DMMM } - - ( MMQ.DMMM$QKDMMMr*c|j}tj|jj|j|d}d}|jr|dz }|dt|jzz }t|jttfr%|d|jj z }n?|d|j dz }|d |jz }|j|z|z|jzS) N,)r threshold separatorrz,  zdims=z input_dims=z, z output_dims=)rrB array2stringrbrrrrrrr rrrrr)rrrDdimstrs r'__str__zTextMatrix.__str__hsM  J T[IQT    9 D EMD cC ,,, ,F$*{M&BCC DA$*"6"="="?"?AAAC (=(=(?(?CCCCC)?)?)A)ACCC{T!F*T[88r*c*|SN)r )rs r'__repr__zTextMatrix.__repr__ys||~~r*)rNrr)__name__ __module__ __qualname____doc__rr rrr*r'rrLsP,,((((0999"r*rc Ftj}d}||r|dd}|}|}tt t ttttd}|dkrCtj dddlm}|d}|d ||fi|d S|dkr|S ||}||fi|S#t"$r.}t%d |d t'|jd |d}~wwxYw) aReturns a visualization of the state. **repr**: ASCII TextMatrix of the state's ``_repr_``. **text**: ASCII TextMatrix that can be printed in the console. **latex**: An IPython Latex object for displaying in Jupyter Notebooks. **latex_source**: Raw, uncompiled ASCII source to generate array using LaTeX. **qsphere**: Matplotlib figure, rendering of statevector using `plot_state_qsphere()`. **hinton**: Matplotlib figure, rendering of statevector using `plot_state_hinton()`. **bloch**: Matplotlib figure, rendering of statevector using `plot_bloch_multivector()`. **city**: Matplotlib figure, rendering of statevector using `plot_state_city()`. **paulivec**: Matplotlib figure, rendering of statevector using `plot_state_paulivec()`. Args: output (str): Select the output method to use for drawing the circuit. Valid choices are ``text``, ``latex``, ``latex_source``, ``qsphere``, ``hinton``, ``bloch``, ``city`` or ``paulivec``. Default is `'text`'. drawer_args: Arguments to be passed to the relevant drawer. For 'latex' and 'latex_source' see ``array_to_latex`` Returns: :class:`matplotlib.figure` or :class:`str` or :class:`TextMatrix` or :class:`IPython.display.Latex`: Drawing of the state. Raises: MissingOptionalLibraryError: when `output` is `latex` and IPython is not installed. ValueError: when `output` is not a valid selection. reprN state_drawer)r| latex_sourceqspherehintonrcitypauliveclatexr)Latexrz$$'z$' is not a valid option for drawing z objects. Please choose from: 'text', 'latex', 'latex_source', 'qsphere', 'hinton', 'bloch', 'city' or 'paulivec'.)r get_configgetlowerrrrrzrrr _optionals HAS_IPYTHON require_nowIPython.displayrrKeyErrorrtyper) rboutput drawer_argsconfigdefault_outputdrawersr draw_funcerrs r'rr}s~L # % %FN ~  @#ZZ??N \\^^F&%#''G**>:::))))))N+ u=))E99[99===>>> ~~ FO y..+...  .& . .d5kk>R . . .    sC(( D 2)DD c t|j}|tdtgd}g}t |D]}|dkrhtjt jd|dz ftt jd|dz ft ||d}n|}fd | D}| ||S) aReturn list of Bloch vectors for each qubit Args: state (DensityMatrix or Statevector): an N-qubit state. Returns: list: list of Bloch vectors (x, y, z) for each qubit. Raises: VisualizationError: if input is not an N-qubit state. Nr)XYZrr)dtypeT)qubitc g|]@}tjtjtj|jASr)rBrFtracerwrD)r$matrgs r'r(z+_bloch_multivector_data..s;```CrwrxsCH(=(=>>??```r*) r r>rr rJfrom_symplecticrBrboolinsert matrix_iterr)rbr& pauli_singlesrr%paulis bloch_statergs @r'rrs   C .C { !LMMMooo..MJ 3ZZ'' 77.!cAgt444bhC!G~UY6Z6Z6ZfQ Tf22 F#F````6K]K]K_K_``` +&&&& r*ctjt|}|jt d|jtj|j d|jzzfS)zReturn paulivec data for plotting. Args: state (DensityMatrix or Statevector): an N-qubit state. Returns: tuple: (labels, values) for Pauli vector. Raises: VisualizationError: if input is not an N-qubit state. Nrr) r from_operatorr r>rr= to_labelsrBrFcoeffs)rbrgs r'rrsd  %mE&:&: ; ;C ~ !LMMM :   ! !273:3>8I+I#J#J JJr*)rNNN)rNNr{N)rN)rNNrNN)NNTFFr)Nr)r)rMrr)rSs  >>>>>>;;;;;;MMMMMMMMBBBBBB00000022222200000000------****** *Q%]aQ%Q%Q%Q%+*Q%h *NRAAA+*AH * h%  h%h%h%h%+*h%V *    y%y%y%y%y%+*y%x *p%X\p%p%p%p%+*p%f b b b*!!! * '   ]%]%]%]%]%('+*]%@  *[.[.+*[.|%%%P!!!!JTY'''' m+ ,''48''MP''''''''''TT']c4PS9*PR'' w-'#&'58'IL'''''T........bLLLL^<KKKKKr*