International audience

Krylov methods rely on iterated matrix-vector products $A^k u_j$ for an $n\times n$ matrix $A$ and vectors $u_1,\ldots,u_m$. The space spanned by all iterates $A^k u_j$ admits a particular basis -- the \emph{maximal Krylov basis} -- which consists of iterates of the first vector $u_1, Au_1, A^2u_1,\ldots$, until reaching linear dependency, then iterating similarly the subsequent vectors until a basis is obtained. Finding minimal polynomials and Frobenius normal forms is closely related to computing maximal Krylov bases. The fastest way to produce these bases was, until this paper, Keller-Gehrig's 1985 algorithm whose complexity bound $O(n^\omega \log(n))$ comes from repeated squarings of $A$ and logarithmically many Gaussian eliminations. Here $\omega>2$ is a feasible exponent for matrix multiplication over the base field. We present an algorithm computing the maximal Krylov basis in $O(n^\omega\log\log(n))$ field operations when $m \in O(n)$, and even $O(n^\omega)$ as soon as $m\in O(n/\log(n)^c)$ for some fixed real $c>0$. As a consequence, we show that the Frobenius normal form together with a transformation matrix can be computed deterministically in $O(n^\omega (\log\log(n))^2)$, and therefore matrix exponentiation~$A^k$ can be performed in the latter complexity if $\log(k) \in O(n^{\omega-1-\varepsilon})$ for some fixed $\varepsilon>0$. A key idea for these improvements is to rely on fast algorithms for $m\times m$ polynomial matrices of average degree $n/m$, involving high-order lifting and minimal kernel bases.

A new Las Vegas algorithm is presented for the composition of two polynomials modulo a third one, over an arbitrary field. When the degrees of these polynomials are bounded by n , the algorithm uses O ( n 1.43 ) field operations, breaking through the 3/2 barrier in the exponent for the first time. The previous fastest algebraic algorithms, due to Brent and Kung in 1978, require O ( n 1.63 ) field operations in general, and n 3/2+ o (1) field operations in the special case of power series over a field of large enough characteristic. If cubic-time matrix multiplication is used, the new algorithm runs in n 5/3+ o (1) operations, while previous ones run in O ( n 2 ) operations. Our approach relies on the computation of a matrix of algebraic relations that is typically of small size. Randomization is used to reduce arbitrary input to this favorable situation.

Quasiseparable matrices are a class of rank-structured matrices widely used in numerical linear algebra and of growing interest in computer algebra, with applications in e.g. the linearization of polynomial matrices. Various representation formats exist for these matrices that have rarely been compared.

A new algorithm is presented for computing the largest degree invariant factor of the Sylvester matrix (with respect either to x or y) associated to two polynomials a and b in which have no non-trivial common divisors. The algorithm is randomized of the Monte Carlo type and requires (delog q)1 + o(1) bit operations, where d and e respectively bound the input degrees in x and in y. It follows that the same complexity estimate is valid for computing: a generator of the elimination ideal (or ), as long as the polynomial system a = b = 0 has not roots at infinity; the resultant of a and b when they are sufficiently generic, especially so that the Sylvester matrix has a unique non-trivial invariant factor. Our approach is to use the reduction of the problem to a problem of minimal polynomial in the quotient algebra . By proposing a new method based on structured polynomial matrix division for computing with the elements in the quotient, we manage to improve the best known complexity bounds.

New algorithms are presented for computing annihilating polynomials of Toeplitz, Hankel, and more generally Toeplitz+Hankel-like matrices over a field. Our approach follows works on Coppersmith's block Wiedemann method with structured projections, which have been recently successfully applied for computing the bivariate resultant. A first baby steps/giant steps approach --directly derived using known techniques on structured matrices-- gives a randomized Monte Carlo algorithm for the minimal polynomial of an (n x n) Toeplitz or Hankel-like matrix of displacement rank α using(Õnw-c(w) Õ c(w)) arithmetic operations, where (w) is the exponent of matrix multiplication and (c(2.373) = 0.523) for the best known value of (w). For generic Toeplitz+Hankel-like matrices a second algorithm computes the characteristic polynomial; in particular, when the displacement rank is considered constant, its cost is (Õn2-1/w). Previous algorithms required (O(n2) operations while the exponents presented here are respectively less than 1.86 and 1.58 with the best known estimate for (w).

As a typical application, the Lenstra-Lenstra-Lovász lattice basis reduction algorithm (LLL) is used to compute a reduced basis of the orthogonal lattice for a given integer matrix, via reducing a special kind of lattice bases. With such bases in input, we propose a new technique for bounding from above the number of iterations required by the LLL algorithm. The main technical ingredient is a variant of the classical LLL potential, which could prove useful to understand the behavior of LLL for other families of input bases.

An algorithm is presented for computing the resultant of two generic bivariate polynomials over a field K. For such p and q K[x,y] both of degree d in x and n in y , the algorithm computes the resultant with respect to y using (n2 - 1/ømega d) 1+o(1) arithmetic operations in K, where two n x n matrices are multiplied using O(nømega) operations. Previous algorithms required time (n2 d) 1+o(1). The resultant is the determinant of the Sylvester matrix S(x) of p and q , which is an n x n Toeplitz-like polynomial matrix of degree~ d . We use a blocking technique and exploit the structure of S(x) for reducing the determinant computation to the computation of a matrix fraction description R(x)Q(x)-1 of an m x m submatrix of the inverse S(x)-1, where młl n. We rely on fast algorithms for handling dense polynomial matrices: the fraction description is obtained from an x -adic expansion via matrix fraction reconstruction, and the resultant as the determinant of the denominator matrix. We also describe some extensions of the approach to the computation of generic Gröbner bases and of characteristic polynomials of generic structured matrices and in univariate quotient algebras.

We present an interactive probabilistic proof protocol that certifies in (log N)O(1) arithmetic and Boolean operations for the verifier the determinant, for example, of an N x N matrix over a field whose entries a(i,j) are given by a single (log NO(1)-depth arithmetic circuit, which contains (log NO(1) field constants and which is polynomial time uniform, for example, which has size (log NO(1). The prover can produce the interactive certificate within a (log NO(1) factor of the cost of computing the determinant. Our protocol is a version of the proofs for muggles protocol by Goldwasser, Kalai and Rothblum [STOC 2008, J. ACM 2015]. An application is the following: suppose in a system of k homogeneous polynomials of total degree ≤ d in the k variables y1,...,yk the coefficient of the term y1e1 ... ykek in the i-th polynomial is the (hypergeometric) value ((i+e1 + ... + ek)!)/((i!)(e1!)...(ek!)), where e! is the factorial of e. Then we have a probabilistic protocol that certifies (projective) solvability or inconsistency of such a system in (k log(d))O(1) bit complexity for the verifier, that is, in polynomial time in the number of variables k and the logarithm of the total degree, log(d).

Computational problem certificates are additional data structures for each output, which can be used by a---possibly randomized---verification algorithm that proves the correctness of each output. In this paper, we give an algorithm that computes a certificate for the minimal polynomial of sparse or structured matrices over an abstract field, of sufficiently large cardinality, whose Monte Carlo verification complexity requires a single matrix-vector multiplication and a linear number of extra field operations. We also propose a novel preconditioner that ensures irreducibility of the characteristic polynomial of the generically preconditioned matrix. This preconditioner takes linear time to be applied and uses only two random entries. We then combine these two techniques to give algorithms that compute certificates for the determinant, and thus for the characteristic polynomial, whose Monte Carlo verification complexity is therefore also linear.

We compute minimal bases of solutions for a general interpolation problem, which encompasses Hermite-Pade approximation and constrained multivariate interpolation, and has applications in coding theory and security. This problem asks to find univariate polynomial relations between m vectors of size σ; these relations should have small degree with respect to an input degree shift. For an arbitrary shift, we propose an algorithm for the computation of an interpolation basis in shifted Popov normal form with a cost of O~(mω-1 σ) field operations, where ω is the exponent of matrix multiplication and the notation O~(·) indicates that logarithmic terms are omitted.

The interpolation step in the Guruswami-Sudan algorithm is a bivariate interpolation problem with multiplicities commonly solved in the literature using either structured linear algebra or basis reduction of polynomial lattices. This problem has been extended to three or more variables; for this generalization, all fast algorithms proposed so far rely on the lattice approach. In this paper, we reduce this multivariate interpolation problem to a problem of simultaneous polynomial approximations, which we solve using fast structured linear algebra. This improves the best known complexity bounds for the interpolation step of the list-decoding of Reed-Solomon codes, Parvaresh-Vardy codes, and folded Reed-Solomon codes. In particular, for Reed-Solomon list-decoding with re-encoding, our approach has complexity O~(ℓω-1m2(n - k)), where ℓ, m, n, and k are the list size, the multiplicity, the number of sample points, and the dimension of the code, and ω is the exponent of linear algebra; this accelerates the previously fastest known algorithm by a factor of ℓ/m.

Let B be a basis of a Euclidean lattice, and B an approximation thereof. We give a sufficient condition on the closeness between B and B so that an LLL-reducing transformation U for B remains valid for B. Further, we analyse an efficient reduction algorithm when B is itself a small deformation of an LLL-reduced basis. Applications include speeding-up reduction by keeping only the most significant bits of B, reducing a basis that is only approximately known, and efficiently batching LLL reductions for closely related inputs.

The HJLS and PSLQ algorithms are the de facto standards for discovering non-trivial integer relations between a given tuple of real numbers. In this work, we provide a new interpretation of these algorithms, in a more general and powerful algebraic setup: we view them as special cases of algorithms that compute the intersection between a lattice and a vector subspace. Further, we extract from them the first algorithm for manipulating finitely generated additive subgroups of a euclidean space, including projections of lattices and finite sums of lattices. We adapt the analyses of HJLS and PSLQ to derive correctness and convergence guarantees.

A general goal concerning fundamental linear algebra problems is to reduce the complexity estimates to essentially the same as that of multiplying two matrices (plus possibly a cost related to the input and output sizes). Among the bottlenecks one usually finds the questions of designing a recursive approach and mastering the sizes of the intermediately computed data.

Abstract. We devise an algorithm, e L 1, with the following specifications: It takes as input an arbitrary basis B = (bi)i ∈ Z d×d of a Euclidean lattice L; It computes a basis of L which is reduced for a mild modification of the Lenstra-Lenstra-Lovász reduction; It terminates in time O(d 5+ε β + d ω+1+ε β 1+ε) where β = log max ‖bi ‖ (for any ε> 0 and ω is a valid exponent for matrix multiplication). This is the first LLL-reducing algorithm with a time complexity that is quasi-linear in β and polynomial in d. The backbone structure of e L 1 is able to mimic the Knuth-Schönhage fast gcd algorithm thanks to a combination of cutting-edge ingredients. First the bit-size of our lattice bases can be decreased via truncations whose validity are backed by recent numerical stability results on the QR matrix factorization. Also we establish a new framework for analyzing unimodular transformation matrices which reduce shifts of reduced bases, this includes bit-size control and new perturbation tools. We illustrate the power of this framework by generating a family of reduction algorithms. 1

This paper deals with the design and implementation of low latency software for binary floating-point division with correct rounding to nearest. The approach we present here targets a VLIW integer processor of the ST200 family, and is based on fast and accurate programs for evaluating some particular bivariate polynomials. We start by giving approximation and evaluation error conditions that are sufficient to ensure correct rounding. Then we describe the heuristics used to generate such evaluation programs, as well as those used to automatically validate their accuracy. Finally, we propose, for the binary32 format, a complete C implementation of the resulting division algorithm. With the ST200 compiler and compared to previous implementations, the speed-up observed with our approach is by a factor of almost 1.8.

We describe a new LLL-type algorithm, H-LLL, that relies on Householder transformations to approximate the underlying Gram-Schmidt orthogonalizations. The latter computations are performed with floating-point arithmetic. We prove that a precision essentially equal to the dimension suffices to ensure that the output basis is reduced. H-LLL resembles the L2 algorithm of Nguyen and Stehlé that relies on a floating-point Cholesky algorithm. However, replacing Cholesky's algorithm by Householder's is not benign, as their numerical behaviors differ significantly. Broadly speaking, our correctness proof is more involved, whereas our complexity analysis is more direct. Thanks to the new orthogonalization strategy, H-LLL is the first LLL-type algorithm that admits a natural vectorial description, which leads to a complexity upper bound that is proportional to the progress performed on the basis (for fixed dimensions).

Efficient block projections of non-singular matrices have recently been used by the authors in [10] to obtain an efficient algorithm to find rational solutions for sparse systems of linear equations. In particular a bound ofO~(n2.5) machine operations is presented for this computation assuming that the input matrix can be multiplied by a vector with constant-sized entries using O~(n) machine operations. Somewhat more general bounds for black-box matrix computations are also derived. Unfortunately, the correctness of this algorithm depends on the existence of efficient block projections of non-singular matrices, and this was only conjectured.

Given a lattice basis of n vectors in Zn, we propose an algorithm using 12n3+O(n2) floating point operations for checking whether the basis is LLL-reduced. If the basis is reduced then the algorithm will hopefully answer "yes". If the basis is not reduced, or if the precision used is not sufficient with respect to n, and to the numerical properties of the basis, the algorithm will answer "failed". Hence a positive answer is a rigorous certificate. For implementing the certificate itself, we propose a oating point algorithm for computing (certified) error bounds for the R factor of the QR factorization. This algorithm takes into account all possible approximation and rounding errors. The certificate may be implemented using matrix library routines only. We report experiments that show that for a reduced basis of adequate dimension and quality the certificate succeeds, and establish the effectiveness of the certificate. This effectiveness is applied for certifying the output of fastest existing floating point heuristics of LLL reduction, without slowing down the whole process.

We describe some major recent progress in exact and symbolic linear algebra. These advances concern the improvement of complexity estimates for fundamental problems such as linear system solution, determinant, inversion and computation of canonical forms. The matrices are over a finite field, the integers, or univariate polynomials. We show how selected techniques are key ingredients for the new solutions: randomization and algebraic conditioning, lifting, subspace approach, divide-double and conquer, minimum matrix polynomial, matrix approximants. These algorithmic progress allow the design of new generation high performance libraries such as LinBox, and open various research directions.

We propose a new algorithm to find a rational solution to a sparse system of linear equations over the integers. This algorithm is based on a p-adic lifting technique combined with the use of block matrices with structured blocks. It achieves a sub-cubic complexity in terms of machine operations subject to a conjecture on the effectiveness of certain sparse projections. A LinBox-based implementation of this algorithm is demonstrated, and emphasizes the practical benefits of this new method over the previous state of the art.

We reduce the problem of computing the rank and a null-space basis of a univariate polynomial matrix to polynomial matrix multiplication. For an input n x n matrix of degree, d over a field K we give a rank and nullspace algorithm using about the same number of operations as for multiplying two matrices of dimension, n and degree, d. If the latter multiplication is done in MM(n,d)= O~(nωd operations, with ω the exponent of matrix multiplication over K, then the algorithm uses O~MM(n,d) operations in, K. For m x n matrices of rank r and degree d, the cost expression is O(nmr ω-2d). The soft-O notation O~ indicates some missing logarithmic factors. The method is randomized with Las Vegas certification. We achieve our results in part through a combination of matrix Hensel high-order lifting and matrix minimal fraction reconstruction, and through the computation of minimal or small degree vectors in the nullspace seen as a K[x]-module.

We investigate the problem of memory reuse in order to reduce the memory needed to store an array variable. We develop techniques that can lead to smaller memory requirements in the synthesis of dedicated processors or to more effective use by compiled code of software-controlled scratchpad memory. Memory reuse is well-understood for allocating registers to hold scalar variables. Its extension to arrays has been studied recently for multimedia applications, for loop parallelization, and for circuit synthesis from recurrence equations. In all such studies, the introduction of modulo operations to an otherwise affine mapping (of loop or array indices to memory locations) achieves the desired reuse. We develop here a new mathematical framework, based on critical lattices, that subsumes the previous approaches and provides new insight. We first consider the set of indices that conflict, those that cannot be mapped to the same memory cell. Next, we construct the set of differences of conflicting indices. We establish a correspondence between a valid modular mapping and a strictly-admissible integer lattice-one having no nonzero element in common with the set of conflicting index differences. The memory required by an optimal modular mapping is equal to the determinant of the corresponding lattice. The memory reuse problem is thus reduced to the (still interesting and nontrivial) problem of finding a strictly admissible integer lattice-of least determinant. We then propose and analyze several practical strategies for finding strictly admissible integer lattices, either optimal or optimal up to a multiplicative factor, and, hence, memory-saving modular mappings. We explain and analyze previous approaches in terms of our new framework.

We investigate the problem of memory reuse, for reducing the necessary memory size, in the context of compilation of dedicated processors. Memory reuse is a well-known concept when allocating registers (i.e., scalar variables). Its (recent) extension to arrays was studied mainly by Lefebvre and Feautrier (for loop parallelization) and by Quillere and Rajopadhye (for circuit synthesis based on recurrence equations). Both consider affine mappings of indices to data, with modulo expressions in the first and (mainly) projections in the second. We develop a mathematical framework based on (integral) critical lattices that subsumes all previous approaches and gives new insights into the problem. Our technique consists first in building an abstract representation of conflicting indices (equivalent in a multi-dimensional space to the interference graph for register allocation), then in defining an integral lattice, admissible for the set of differences of conflicting indices, used to build a valid modular allocation. We also show the link with critical lattices, successive minima, and basis reduction, and we analyze various strategies for lattice-based memory allocation.

We study the link between the complexity of polynomial matrix multiplication and the complexity of solving other basic linear algebra problems on polynomial matrices. By polynomial matrices we mean ntimes n matrices in K[x] of degree bounded by d, with K a commutative field. Under the straight-line program model we show that multiplication is reducible to the problem of computing the coefficient of degree d of the determinant. Conversely, we propose algorithms for minimal approximant computation and column reduction that are based on polynomial matrix multiplication; for the determinant, the straight-line program we give also relies on matrix product over K[x] and provides an alternative to the determinant algorithm of [16, 17]. We further show that all these problems can be solved in particular in O (ω) operations in K. Here the "soft O" notation O indicates some missing log (nd) factors and ω is the exponent of matrix multiplication over K.

A probabilistic algorithm is presented to find the determinant of a nonsingular, integer matrix. For a matrix A/spl isin/Z/sup n/spl times/n/ the algorithm requires O(n/sup 3.5/(log n)/sup 4.5/) bit operations (assuming for now that entries in A have constant size) using standard matrix and integer arithmetic. Using asymptotically fast matrix arithmetic, a variant is described which requires O(n/sup 2+/spl theta//2//spl middot/log/sup 2/nloglogn) bit operations, where n/spl times/n matrices can be multiplied with O(n/sup /spl theta//) operations. The determinant is found by computing the Smith form of the integer matrix an extremely useful canonical form in itself. Our algorithm is probabilistic of the Monte Carlo type. That is, it assumes a source of random bits and on any invocation of the algorithm there is a small probability of error.

We present a new algorithm to compute the Integer Smith normal form of large sparse matrices. We reduce the computation of the Smith form to independent, and therefore parallel, computations modulo powers of word-size primes. Consequently, the algorithm does not suffer from coefficient growth. We have implemented several variants of this algorithm (Elimination and/or Black-Box techniques) since practical performance depends strongly on the memory available. Our method has proven useful in algebraic topology for the computation of the homology of some large simplicial complexes.

In t,his paper we st,ucly the problen ~ of transforrniug, via in-vertible colu1tln opcrat.ious ~ it matrix polyioruial into a varicty Of.shiftcd forms. Esarnplcs of forms c:overed in out frmwa-ork include a colunm rctluccd form: il triangular fornlz R I%!rInite IlOrInd fOrll1 or it Popov IlorIllal fOrIll alollg wit,11 their shifted courltcrpart,s. I3y obt.aiuiug tlcgrvc bounds for uuiniodiilar niiill,iplicrs of shifted Popor fornis we are able t,o c11lbct1 tlic probleni of conqmtiug il normal forni into 0Iic of deterniiJIing a sliift.ctl forni Of R InininIal pOl~IlOIIliill hiISiS fur all XWXiiltWl IIliLtris polyioruial. Shifted niiuind polynomial lXPX?S cm be conlpu1.d via sigma bases [2! 31 iIlld ill POpOv forui Vii1 Mahler s~sbenls [il. Tl ic 1. d t,t, cr Iut:t.lIotl gives a fractiorl-frw algorithm for computing niatris riormal forms. Key words: Popov Form. Herr&c N~~r~n~d Fornl 1

We analyse the probability of success of the block algorithm proposed by Coppersmith for solving large sparse systems Aw = O of linear equations over a field K. Itis based on a modification of a scheme proposed by Wiedemann.An open question was to prove that the block algorithm may produce a solution for small finite fields e.g. for K =GF(2).Our investigations allow us to answer this question nearly completely.We prove that the input parameters of the algorithm may be tuned such that, for any input system, a solution is computed with high probability for any field.Conversely, for particular input systems, we show that the conditions on the input parameters may be relaxed to ensure the success.We also improve the previous probability measurements in the case of large cardkmlity fields. 'The whole proofs has been sent to the referees.They may be found in [30]

For a polynomial matrix P(z) of degree d in M~,~(K[z]) where K is a commutative field, a reduction to the Hermite normal form can be computed in O (ndM(n) + M(nd)) arithmetic operations if M(n) is the time required to multiply two n x n matrices over K. Further, a reduction can be computed using O(log~+' (ml)) pamlel arithmetic steps and O(L(nd)) processors if the same processor bound holds with time O (logX (rid)) for determining the lexicographically first maximal linearly independent subset of the set of the columns of an nd x nd matrix over K.These results are obtamed by applying in the matrix case, the techniques used in the scalar case of the gcd of polynomials.

We study linear Differential Algebraic Equations, DAE, with time varying coefficients. Such equations B(t)&(t) = A(t)z(t) + f(t) are intensively studied from a numerical point of view. Canonical forms have been proposed to find conditions under which the equation admits a solution, to find the set of consistent initial conditions and to determine conditions under which there is a unique solution. However, since the situation where the system admits infinitely many solutions for one initial value is not really tractable in a numerician framework, few algorithms may be found in this latter case. Among them, we find the method of P. Kunkel and V. Mehrmann who propose a new set of local characterizing quantities for the treatment of the system. This leads to a generalization of the global index. Nevertheless, these latter characterizing quantities impose too restrictive conditions on the input equations. We propose new definitions for them that lead to a new algorithm which puts the initial system into a reduced form without doing any assumption on it. This allows us to propose a new generalization of the global index and a definition for the singularities of the initial system. The questions of existence and uniqueness of solutions are solved in all interval which does not contain singularity. Finally, since from a practical point of view the general case of analytic functions is difficult to handle, we focus on the polynomial case. We propose an effective algorithm that has been implemented and report some experiments.

We establish that the Smith normal form of a polynomial matrix in F[x]n×n, where F is an arbitrary commutative field, can be computed in NCF.

We describe a new algorithm for the computation of the Smith normal form of polynomial matrices.This algorithm computes the normal form and pre-and post-multipliers in deterministic polynomial time.Noticing that the computation reduces to a linear algebra problem over the field of the coefficients, we obtain a good worst-case complexity bound,,

Nous 6tudions ici la paral161isation de l'algorithme .L3 pour la r6duction des bases de u.%eaux.Sous le mod~le des architectures parallbles ~m6moires distributes, l'algorithme pro-pos6 permet d'utiliser efficacement 0(n2) processeurs, oti n est la dimension de la base con-sid&6e.Cet algorithm, implant6 sur une machine massivernent parall~le, donne lieu i de nombreuses experimentations.Les premibres, reportdes ici, font d'une part apparaitre de bons rr%ultats quant aux acc~kations obtenues en pratique pour des grands nombre de processeurs.Elles permettent d'autre part de com-p16ter Ies connaissances exp&imentales sur la complexit~s6quentielle de L3 .

Article Free Access Share on PAC: first experiments on a 128 transputers méganode Authors: Françoise Roch-Siebert Equipe Calcul Parallèle et Calcul Formel, LMC - CNRS 46, av. Félix Viallet, F-38031 Grenoble Cédex Equipe Calcul Parallèle et Calcul Formel, LMC - CNRS 46, av. Félix Viallet, F-38031 Grenoble CédexView Profile , Gilles Villard Equipe Calcul Parallèle et Calcul Formel, LMC - CNRS 46, av. Félix Viallet, F-38031 Grenoble Cédex Equipe Calcul Parallèle et Calcul Formel, LMC - CNRS 46, av. Félix Viallet, F-38031 Grenoble CédexView Profile Authors Info & Claims ISSAC '91: Proceedings of the 1991 international symposium on Symbolic and algebraic computationJune 1991 Pages 343–351https://doi.org/10.1145/120694.120748Published:01 June 1991Publication History 1citation184DownloadsMetricsTotal Citations1Total Downloads184Last 12 Months1Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF