Vector fixed-lag algorithm for decoding input symbols

[0002] This application is a continuation-in-part of 09/183,474 filed Oct. 30, 1998 of U.S. Pat. No. 6,226,613, issued May 1, 2001, entitled Fixed-Lag Decoding of Input Symbols to Input/Output Hidden Markov Models.

[0003] The present invention relates generally to a method and apparatus for decoding received symbols. More particularly, the present invention discloses a vector fix-lag algorithm for determining the probabilities of transmitted symbols given received symbols.

[0004] Forward-backward algorithms (FBAs) are often used in a variety of applications such as speech recognition, handwriting verification such as signature verification, error correction code decoding, etc., to calculate probabilities. As the name suggests, FBAs are a combination of forward algorithms and backward algorithms using vector-matrix products. Equipment that performs the algorithms requires large amounts of memory for storing all the matrices and intermediate matrix products needed to support the algorithms.

[0005] FBAs can be used to calculate the probabilities associated with the functions of Hidden Markov Models (HMMs) in voice recognition to recognize discrete and continuous speech. When a HMM is applied to describe a communication channel, products of sequences of probability density matrices are used to estimate the a posteriori probabilities of transmitted symbols given the received symbols. In other words, mathematical models are used to estimate the probabilities of the transmitted symbol knowing the received symbol.

[0006] Conventional FBA techniques require that a sequence of matrices multiplied by a first vector in a recursive manner in a forward part of the algorithm be stored in memory. The decoding process can start only after a long sequence of symbols has been received. This is unacceptable in many applications (a telephone application, for example) that impose strict constraints on the message delivery delay. Thus, new technology is needed to improve the vector-matrix product calculation that enables a decoder to estimate the product, and thus estimate the input symbols, without waiting for the whole symbol sequence to be received. This technology enables a designer to trade the product estimation accuracy for smaller delays in information delivery.

[0007] The invention provides a method and apparatus that performs a fixed-lag computation process.

[0008] The present invention discloses an apparatus and method of decoding information received over a noisy communications channel to determine the intended transmitted information. The present invention improves upon the traditional forward-backward algorithm with a vector fixed-lag algorithm. The algorithm is implemented by multiplying an initial state vector with a matrix containing information about the communications channel. The product is then recursively multiplied by the matrix τ times, using the new product with each recursive multiplication. The new product forward information is stored in storage elements. The final product is multiplied with a final state column vector yielding a probability of a possible input. The estimated input is the input having the largest probability. The invention may be applied to a maximum a posteriori estimation of input symbols in systems modeled by an input-output HMM such as symbols transmitted over noisy channels, to handwriting and speech recognition and other probabilistic systems.

[0009] The vector fixed-lag process of the invention replaces the conventional forward-backward algorithm. This eliminates the need of saving long sequences of the forward vectors. Accordingly, memory requirements and decoding delay are reduced when using the fixed-lag process to decode information transmitted over a communication channel.

[0010] The present invention discloses a fixed-lag method for determining the probability of a transmitted symbol at a time t, transmitted along a communications channel with bursts of errors, given a received symbol. The method comprises obtaining initial state information vector about the channel and obtaining channel information matrices describing the probabilities that the transmitted symbol would be transmitted along a communications channel with and without error. The method further comprises generating intermediate probabilities, each intermediate probability being the product of the initial state information vector at a time previous to time t, and a channel information matrix, storing the intermediate probabilities in storage elements, and multiplying a last intermediate probability with a final state vector to yield the probability of the transmitted symbol.

[0011] The invention will be described with reference to the accompanying Figures in which like elements are referenced with like numerals and in which:

[0012] FIG. 1 illustrates information processing according to the invention over a wireless communication channel;

[0013] FIG. 2 illustrates a decoder used to decode symbols transmitted according to FIG. 1;

[0014] FIG. 3 illustrates a decoder in another aspect;

[0015] FIG. 4 illustrates matrix storage according to the invention;

[0016] FIG. 5 illustrates matrix storage according to the invention in another aspect;

[0017] FIG. 6 illustrates a fixed-lag decoding apparatus for three memory elements according to the invention;

[0018] FIG. 7 illustrates a fixed-lag decoding apparatus according to another embodiment of the invention in which matrix inversion is used;

[0019] FIG. 8 illustrates a flowchart according to the invention;

[0020] FIG. 9 illustrates a decoder in accordance with another embodiment of the present invention;

[0021] FIG. 10 illustrates an encoder in which the present invention may be used; and

[0022] FIG. 11 illustrates a table of data exemplifying the embodiments of FIGS. 9 and 10.

[0023] The invention provides a method and apparatus to generate estimates for processing data symbols using algorithms and sequences of matrices. The purpose of the algorithms is to determine the intended transmitted or input symbol from the received symbol, which has been corrupted with noise. In general, the matrices reflect the relationship between a system state variables, input sequences and output sequences. For example, the matrices may describe a HMM of a communication system representing the following probabilities: Pr(X_t,Y_t,S_t|S_t−1). In other words, the matrices describe the transition from state S_t−1(i.e., state S at a prior time of t−1) to the next state S_t(i.e., state S at a later time t) and generate the next input symbol X_tand the next output symbol Y_t.

[0024] The communication system modeled above could be a wireless radio system, fiber optical system, wired system, or other suitable system. Many other systems can be analyzed using state matrix information. For instance, bioelectrical signals such as electrocardiograms, seismic measurements, handwriting recognition devices, speech recognition devices, control systems and others can be modeled as machines or processes whose next state depends upon the current state, plus input information or symbols. All these systems can be described in terms of communications systems. For example, in speech recognition, the output sequence is what is heard, while the input sequence is the intended meaning. In handwriting recognition, the output is the sequence of scanned handwritten symbols, while the input is the intended sequence of letters that a decoder must recognize. Therefore, in the sequel we will use the communication system terminology, but the results have a broader application.

[0025] For the applications noted above or for other suitable applications, the following general structure may be used to calculate the matrix product to determine the probability of the intended input. $\begin{array}{cc}{p}_t={\alpha }_0\prod _{i=1}^{t-1}{M}_i{W}_t\prod _{i=t+1}^T{M}_i{\beta }_T={\alpha }_{t-1}{W}_t{\beta }_t& \left(1\right)\end{array}$

[0026] where α₀is a row vector representing an initial condition, β_Tis a column vector representing a terminal condition, and M_iand W_iare square matrices. For different applications, matrices M_ican have different meanings.

[0027] Although not exemplified here, the matrices M_iand W_icould be of a dimension other than square as long as the dimensions of the row and column vector correspond appropriately to permit for proper matrix multiplication.

[0028] The evaluation of the parameter p_taccording to Equation (1) above is conventionally done by the forward-backward algorithm (FBA). The FBA requires that the decoding unit must receive all symbols in an input sequence, compute and store the forward vectors $\begin{array}{cc}{\alpha }_t={\alpha }_0\prod _{i=1}^t{M}_i\mathrm{for}\mathrm{all}t=1,2,\dots ,T& \left(2\right)\end{array}$

[0029] then compute the backward vectors $\begin{array}{cc}{\beta }_t=\prod _{i=t+1}^T{M}_i{\beta }_T& \left(3\right)\end{array}$

[0030] and compute p_t=α_t−1W_tβ_tfor all t=T−1,T−2, . . . , 1. T represents some total time period which is usually equal to the number of observed output symbols.

[0031] This calculation places large demands on memory and processing resources. The present invention avoids the necessity of storing the complete symbol sequence and reduces processing time compared to conventional technology. The invention does so in part by observing that a sufficient estimate of p_tmay be made, if the application exhibits a fading or finite memory so that some tail portion of the product ${\beta }_t=\prod _{i=t+1}^T{M}_i{\beta }_T$

[0032] shown in Equation 1 may be ignored with little penalty in accuracy.

[0033] FIG. 1 shows an exemplary communications system 10 as a typical application of the estimate process according to the invention. In FIG. 1, an information source 100 outputs information signals to an encoder/transmitter 110, such as a base station in a wireless cellular communications system. Encoder/transmitter 110 transmits an encoded signal from antenna 120 over a communication channel 130, which may, for instance, be the radio frequency channels according to Personal Communications Service (PCS) or other forms of communication channels. The transmitted symbols 140 are received at a receiving unit 150, which may be a mobile cellular telephone, over an antenna 180. The receiving unit 150 receives the transmitted symbols 140 and processes them in a decoder 160 to provide decoded output symbols to an input/output unit 170. The input/output unit 170 may, for instance, output voice sounds in a cellular telephone.

[0034] Real communication channels are characterized by the bursty nature of errors that can be modeled quite accurately by HMMs as known in the art. Therefore, communications system 10 may be modeled by an HMM, and the transmitted symbols 140 may be decoded by known methods such as maximum a posteriori (MAP) symbol estimation as briefly discussed herein.

[0035] In many applications, it is necessary to find a symbol X_tmaximum a posteriori estimate by maximizing its a posteriori probability density function (APPDF) as follows: $\begin{array}{cc}p\left(X_t|Y_1^T\right)=\frac{p\left(X_t,Y_1^T\right)}{p\left(Y_1^T\right)}.& \left(a\right)\end{array}$

[0036] Since the received sequence Y₁^Tis fixed, it is sufficient to maximize the unnormalized APPDF p(X_t,Y₁^T) as follows: $\begin{array}{cc}{\hat{X}}_t=\underset{X_t}{\arg \max }p\left(X_t,Y_1^T\right)=\underset{X_t}{\arg \max }p\left(X_t|Y_1^T\right)\mathrm{where}& \left(b\right)\\ p\left(X_t,Y_1^T\right)=\pi \prod _{i=1}^{t-1}P\left(Y_i\right)P\left(X_t,Y_t\right)\prod _{i=t+1}^{T}P\left(Y_1\right)1.& \left(c\right)\end{array}$

[0037] This equation can be evaluated by the forward-backward algorithm.

[0038] Forward part: Compute and save

[0039] α(Y₁⁰)=π, α(Y₁^t)=α(Y₁^t−1)P(Y_t), t=1,2 . . . , T−1.  (d)

[0040] Backward part: For t=T, T−1, . . . , 2 compute

[0041] p(X_t,Y₁^T)=α(Y₁^t−1)P(X_t,Y_t)β(Y_t+1^T), where  (e)

[0042] β(Y_T+1^T)=1, β(Y_t^T)=P(Y_t)β(Y_t+1^T).  (f)

[0043] If we need to calculate only one or two of the products in Equation (c), we can apply a forward algorithm, but if we need to calculate p(X_t,Y₁^T) for many values of t, we use the forward-backward algorithm.

[0044] Since all products of probabilities tend to zero, to increase the calculation accuracy and avoid underflow, it is necessary to scale the equations if T is not small. The scaled vectors are denoted as follows:

[0045] {overscore (α)}(Y₁^t)=c_tα(Y₁^t).  (g)

[0046] After the variable substitution Equation (d) takes the form

[0047] {overscore (α)}(Y₁^t+1)=λ_t+1{overscore (α)}(Y₁^t)P(Y_t),  (h)

[0048] where λ_t+1=c_t+1/c_t.

[0049] Let d_tbe the scaling factor for β(Y_t^T):

[0050] {overscore (β)}(Y_t^T)=d_tβ(Y_t^T).  (i)

[0051] If we use {overscore (α)}(Y₁^t−1) instead of α(Y₁^t−1) and {overscore (β)}(Y_t+1^T) instead of β(Y_t+1^T) in Equation (e), we obtain:

[0052] {overscore (p)}(X_t,Y₁^T)=p(X_tY₁^T)μ_twhere μ_t=c₁c₂. . . c_t−1d_t+1. . . d_T. If the scaling factors do not depend on X_t, then μ_tdoes not depend on X_t, and the solution of Equation (b) does not change if we replace P(X_t,Y₁^T) with {overscore (p)}(X_t,Y₁^T).

[0053] In principle, c_iand d_ican be any numbers. However, it is convenient to choose

[0054] c_t=1/α(Y₁^t)1.  (j)

[0055] so that the normalized vector {overscore (α)}(Y₁^T)1=1

[0056] The normalized vectors can be obtained recursively using Equation (d) and normalizing the result after each recursive step:

[0057] {circumflex over (α)}(Y₁^t+1)={overscore (α)}(Y₁^t)P(Y_t), {overscore (α)}(Y₁^t+1)=λ_t+1{circumflex over (α)}(Y₁^t+1)  (k)

[0058] where

[0059] λ_t+1=1/{circumflex over (α)}(Y₁^t+1)1=c_t+1/c_t.

[0060] The normalization factors c_tcan be recovered from the normalization factors λ_tof the scaled forward algorithm (k): $c_t=\prod _{i=1}^t{\lambda }_i.$

[0061] We can select the normalizing factors for β(Y_t^T) similarly. However, if we use $d_t=\prod _{i=1}^T{\lambda }_i$

[0062] we will have c_td_t=1/p(Y₁^T), ∀t and we can write the APPDF as

[0063] p(X_t|Y₁^T)={overscore (α)}(Y₁^t−1)P(X_t,Y_t){overscore (β)}(Y_t+1^T)/λ_t.

[0064] If T is large and the maximum density functions do not have special structures simplifying their multiplication, the forward-backward algorithm uses a lot of computer resources. Therefore, it is beneficial to find approximate algorithms that have a satisfactory accuracy.

[0065] One of the approaches is based on the fact that many processes have a “fading” memory: the process samples dependency is a decreasing function of the sample time separation. In this case

[0066] p(X_tY₁^t)≈p(X_tY₁^t+T)

[0067] and we can use the fixed-lag algorithm.

[0068] With reference back to the modeling, a FBA process may be applied that evaluates a probability at time t, P(X_t|Y₁^T), for the transmitted symbol X_tand for the actually received symbols Y₁^T=Y₁,Y₂, . . . Y_T. P(X_t|Y_t^T) is proportional to

[0069] P(X_t,Y₁^T)=α_t−1P(X_t,Y_t)β_t

[0070] where α₀is the row vector of the Markov state initial probabilities, α_t, and β_tare computed according to Equations (2) and (3) in which M_i=P(Y_i) representing the matrix probabilities of receiving symbols Y_i. However, channel distortions affecting the transmitted information symbols 140 only persist for a finite period of time, for instance as a result of multipath fading. Thus, it is only necessary to look forward by a fixed period of time or time lag τ through the received sequence to decode the transmitted symbols.

[0071] If the memory in the communication channel is of length τ, then probability P(X_t|Y₁^T) at time t of a transmitted symbol X_t, given the received sequence may be estimated by the expression: $\begin{array}{cc}{p}_t\approx {\alpha }_0\prod _{i=1}^{t-1}{M}_i{W}_t\prod _{i=t+1}^{t+\tau }{M}_i{\beta }_{\infty }=a_{t-1}{W}_t{\beta }_{t,\tau }& \left(3.1\right)\end{array}$

[0072] where W_t=P(X_t,Y_t) is the matrix probability of transmitting X_tand receiving Y_t. When compared with the conventional FBA, at a given time t, only the terms extending from 1 to t+τ rare computed instead of 1 to T, where T is the total time period of the complete received symbols. Thus, the terms extending from t+τ to T are eliminated when computing the estimate. The invention presents the algorithm for computing vectors $\begin{array}{cc}{\beta }_{t,\tau }=\prod _{i=t+1}^{t+\tau }{M}_i{\beta }_{\infty }=M_{t+1}^{t+\tau }{\beta }_{\infty }& \left(4\right)\end{array}$

[0073] recursively, thus saving both the memory space and processing time required to support computation of p_t.

[0074] The invention makes use of the fact that the matrices $M_{t+1}^{t+\tau }=\prod _{i=t+1}^{t+\tau }{M}_i$

[0075] can be computed recursively by the following equation

[0076] M_t+k+1^t+τ+1=M_t+k+1^t+τM_t+τ+1, k=1,2, . . . , τ  (5)

[0077] and then compute β_t+1=M_t+2^t+τ+1β_∞. The vector β_∞=1 in most applications. With β_∞equal to a unity column vector, the mathematical computation is the summing of elements (by rows) in the matrix M_t+2^t+τ+1being multiplied by the unity vector.

[0078] FIG. 2 shows a flow diagram of a general process for generating the estimate p_t. In this figure, letter “R” on signal lines indicates that the corresponding matrix multiplies the matrix on the other line from the right. It is important to show, because matrix products are not commutative. As illustrated in FIG. 2, M_t+τ+1is input on signal line 202, and then multiplied by a series of matrices: M_t+τ stored in storage element 204, M_t+τ+1stored in storage element 206, . . . , M_t+1stored in storage element 208, and M_tstored in storage element 210. α_t−1stored in storage element 226 is then right-multiplied by multiplier 210 and the result is output over signal line 236 to update α_t−1to α_t. α_tis output over signal line 240 for right multiplication by W_tby multiplier 214. The result of the multiplier 214 is output over signal line 242 to multiplier 216 as a forward portion of the estimate p_t. The storage elements 204, 206, . . . , 208, and 210 serve to delay the matrices M_t→M_t+τ to synchronize the generation of the forward pattern with the generation of a backward portion as described below. The partial matrix product M_t+1^t+τ stored in the storage element 235 is then right multiplied by the vector β_∞stored in the storage element 228 and the result is multiplied from the left by the forward portion obtained on line 242 thus producing the desired estimate p_t. The partial matrix products stored in the storage elements 230, 232, . . . , 235 may be generated in a progressive manner according to equation (5) by storing a sequence of τ−1 matrix products where each member of the sequence is generated by matrix multiplying a prior member of the sequence by M_t+τ+1from the right and storing the result in a storage element of the next sequence member.

[0079] As shown in FIG. 2, storage elements 230, 232, . . . , 234 and 235 store the sequence of matrix products. When M_t+τ+1is generated, 1) the content of the storage element 235 is matrix multiplied with β_∞ by multiplier 225 to generate the next backward portion, 2) the storage element 235 is then used to store the result of the matrix product between the content of the storage element 234 and M_t+τ+1generated by multiplier 224, 3) the storage element 234 is then used to store the matrix product between the content of the next storage element earlier in the sequence and M_t+τ+1generated by the multiplier 222 and so on. After the content of the storage element 232 is used to generate the matrix products for the following storage element in the sequence, it is used to store the output of multiplier 221. Finally, the storage element 230 stores the product M_t+τM_t+τ+1. Thus, the storage elements 230, 232, 234 and 235 stores τ−1 sequence of matrix products for generating the backward portion of the p_t. The backward portion is multiplied by multiplier 216 with the forward portion to generate p_tas the probability at time t.

[0080] In the alternative implementation of the algorithm, we assume that it is possible to calculate the inverse matrices M_t⁻¹. In this case, the partial matrix products can be evaluated according to the following equation

[0081] M_t+2^t+τ+1=M_t+1⁻¹M_t+1^t+τM_t+τ+1  (6)

[0082] Therefore, the whole sequence of storage elements and multipliers 230 through 235 in FIG. 2 may be replaced with a single storage device, two multipliers and the matrix inversion unit. The latter may be replaced with storage units if the inverse matrices are pre-computed and saved. This embodiment is described below more particularly with respect to FIG. 7.

[0083] The generation of p_taccording to FIG. 2 can be implemented by an exemplary fixed-lag apparatus 250 shown in FIG. 3. The fixed-lag apparatus may include a controller 252, a memory 254, a matrix multiplier 256, a matrix inverter 258 and an input/output device 260. The above components are coupled together via signal bus 262.

[0084] While the fixed-lag apparatus 250 is shown with a common bus architecture, other structures are well known to one of ordinary skill in the art. In addition, the functions performed by each of the devices could be performed by a general purpose computer, digital signal processors, application specific integrated circuits, DGA's, DLA, etc. which are well known in the art.

[0085] When generating p_t, the controller 252 reads values of the matrices M_iout of memory 254 for multiplication by matrix multiplier 256 or inversion by matrix inverter 258. The individual matrices M_t−M_t+τ are stored in memory 254, which may be electronic random access memory or other forms of electronic or other storage appreciated by persons skilled in the art. Memory 254 likewise contains the matrix products of storage elements 234-235 which are M_t+τ−1M_t+τ, M_t+τ−1M_t+τ−2M_t+τ−3, . . . , M_t+1M_t+2. . . M_t+τ.

[0086] At each time t, the controller 252 generates the matrix M_t+τ+1. This matrix may be generated based on the HMM of the underlying process and received sequence of symbols for the period T (e.g., received encoded data over a communication channel,or a handwriting analysis process). Once generated, M_t+τ+1is stored in the memory 254 and used for the fixed-lag operation as described below.

[0087] The controller 252 directs matrix multiplier 256 to generate α_tby multiplying α_t−1stored in storage element 226 by M_t, further directing the matrix multiplier 256 to multiply α_t, by W_tto generate the forward portion. The controller 252 generates the backward portion by directing the matrix multiplier 256 to multiply β_∞ stored in the storage element 228 with M_t+1^t+τ stored in storage element 235. The controller 252 then generates p_τ by directing the matrix multiplier 256 to multiply the forward portion with the backward portion and outputs p_tto further downstream processes.

[0088] After generating the backward portion, the controller 252 proceeds to generate each of the matrix products to be stored in the storage element 230, 232, 234 and 235 by directing the matrix multiplier 256 to multiply M_t+τ+1with the contents of each respective storage element and storing the result in the next following storage element in the sequence. In this way, all the contents of the storage elements 230, 232, 234 and 235 are prepared for the generation of p_t+1.

[0089] FIG. 4 shows a FIFO 270 as an exemplary device for the storage elements 204, 206, 208 and 210. The FIFO 270 has τ+1 locations 272, 274, 276 and 278 that correspond to the storage elements 204, 206, 208 and 210, respectively.

[0090] For each t, M_tis read from the FIFO 270 and a M_t+τ+1is generated and “pushed” into the FIFO 270. For example, at time t=1, the FIFO 270 contains M_t+τ in location 278, M_τ in location 274, M₂in location 276 and M₁in location 278. At t=2, the FIFO 270 contains M_2+τ in location 278, M_τ+1in location 274, M₃in location 276 and M₂in location 278. M₁is consumed by vector matrix multiplication with α₀to for α₁now stored in storage element 226.

[0091] FIG. 5 shows an exemplary memory management scheme of a memory space 280 for storage elements 230, 232, 234 and 235. A block of locations 284, 286, 288 and 290 in the memory 254 may be set aside corresponding to the storage elements 230, 232, 234 and 235. Thus, at t=1, location 284 contains M_τM_1+τ, location 286 contains M_τ−1M_τM_1+τ location 288 contains M₃M₄. . . M_1+τ, and location 290 contains M₂M₃. . . M_1+τ. The pointer 282 is pointing at location 290 in preparation for generating the backward portion of p₁. At t=2 the controller 252 reads the contents of the location pointed to by the pointer 282 and obtains M₂M₃. . . M_1+τ and sends this matrix product to the matrix multiplier 256 to generate the first backward portion M₂^1+τβ_∞. Then the controller 252 directs the matrix multiplier 256 to multiply M_1+τ with M_2+τ and stores the product in the location pointed to by the pointer 256 which is location 290 thus overwriting M₂M₃. . . M_1+τ. The controller 252 then updates the pointer 256 to point to location 288 by decrementing the pointer 256 by M, for example, where M is the number of elements in each of the matrix product. In this regard, each of the locations 284, 286, 288 and 290 actually is a block of memory space sufficient to store one of the matrix products.

[0092] Then, the controller 252 directs the matrix multiplier 256 to matrix multiply the contents of each of the remaining locations 284, 286 and 288 with M_2+τ. At this point, the memory space 280 is ready for the next cycle to generate the backward portion for p_t+1.

[0093] After τ−2 cycles, the pointer 282 would be pointing to location 284. During the τ−1 cycle the pointer 256 would be incremented by τ−2 to again point to location 290 which essentially permits the memory space 280 to be a circular buffer of τ−1 locations 284, 286, 288 and 290.

[0094] FIG. 6 shows a specific example of decoding according to the invention where τ is set equal to 3 and T=256. As illustrated in FIG. 6, the calculations are initialized using α_t− and M_t+1^t+3to generate p_t. Matrix M_t+4is then input over signal line 302 to a sequence of matrices M_t+3. M_t+2, M_t+1, and M_tstored in storage elements 304, 306, 308 and 310, respectively, right-multiply the M_tin storage element 302 by multiplier 312 with α_t−1(of storage element 326) thus generating α_t. The forward portion is generated by α_tis output over signal line 336 to store α_tinto storage element 326, thus updating α_t−1to α_t. Simultaneously, α_t−1is output over signal line 340 to right-multiplier 314 for right-multiplication by W_t, that product in turn being output to multiplier 316. Multiplier 320 receives M_t+1^t+3stored in storage 332 and right-multiplies it by β_∞ stored in storage 328 and then output to multiplier 316 which multiplies it from the left by the quantity α_t−1W_tand outputs over signal line 338 the desired result p_t=α_t−W_tM_t+1^t+3β_∞. In the mean time, the contents of the storage elements 330 and 332 are replaced by M_t+3^t+4=M_t+3M_t+4and M_t+2^t+4=M_t+2M_t+3M_t+4, respectively. The storage elements 304, 306, 308 and 310 also updated by shifting their contents thus preparing for the next cycle.

[0095] In decoder 160, the received value p_twhich is used to decode the current transmitted symbol. The following illustrates the calculation of several initial values of p_t.

[0096] p₁α₀W₁M₂M₃M₄β_∞, α₁=α₀M₁, M₄⁵=M₄M₅, M₃⁵=M₃M₄M₅

[0097] p₂=α₁W₂M₃⁵β_∞, α₂=α₁M₂, M₅⁶=M₅M₆, M₄⁶=M₄M₅M₆, and so on.

[0098] As can be seen from FIG. 2 and from $\begin{array}{cc}{p}_t\approx {\alpha }_0\prod _{i=1}^{t-l}{M}_i{W}_l\prod _{i=t+1}^{t+\tau }{M}_i{\beta }_{\infty }& \left(7\right)\end{array}$

[0099] in the invention, the conventional products of Markov matrices are truncated according to the persistence of memory in communications channel 130, reducing storage and computation significantly.

[0100] The effects of memory on communications channel 130 are accounted for by the product of matrices M_t−M_t+3. Therefore, decoder 160 as illustrated in FIG. 2 outputs to input/output unit 170 a probability value p_tthat a symbol X_twas transmitted at time t. In the illustrative embodiment, the encoder/transmitter 110 may be transmitting wireless voice or data signals over communications channel 130, and input/output unit 170 may output a voice output over receiving unit 150, such as a voice sound.

[0101] The general form of the equation for calculating the partial matrix products according to the invention is shown in Equation 7 above for arbitrary τ. As can be seen from that expression, in the invention it is only necessary to compute matrix products of matrices modeling the communication channel, whether wireless, radio frequency, optical or otherwise, over the period of time τ representing channel memory.

[0102] The transmitted information symbols 140 are illustrated in FIG. 1 as being cellular wireless voice or data symbols, however, it will be understood that the invention can be applied to any information signals that can be modeled by an HMM. Such information signals could also be, for instance, voice recognition information, handwriting information, bioelectrical signals such as electrocardiographs, seismic signals, and others. In a handwriting implementation, for instance, each letter would represent an information symbol which is modeled by an HMM, whose states are composed of preceding and succeeding letters and some hidden states representing a particular style of writing, for example, which would be reflected in matrices drawn to that model.

[0103] The system and method of the invention according to the foregoing description achieves information decoding in a streamlined manner. Using the invention, it is possible among other things to avoid having to store all forward (as well as backward) vectors in an HMM, and moreover to look forward through the chain by only a fixed lag, rather than through the entire sequence. This reflects the realization that time delays or fades which create a memory effect and distort a channel are of finite duration. Those distortions could only influence the present information signal as long as those time delays, fades or other distortions are still propagated. The invention capitalizes on these and other characteristics of non-Gaussian channels to achieve improved processing efficiency, while placing much reduced demands on processor bandwidth and storage capacity. Further efficiencies are gained when coefficients are recovered using an inverse matrix as described above.

[0104] An embodiment of the invention is illustrated in FIG. 7, in which advantage is taken of the property of matrix inversion to realize storage gains in the backward portion of the algorithm. Specifically, when dealing with products of matrices necessary to compute backward portion, it is possible to avoid the chain multiplication over the complete time period t to t+τ, when the intermediate matrix can be inverted. In this embodiment, the matrices for the forward portion of the algorithm are stored similarly to the apparatus of FIG. 2, with M_tbeing stored in storage element 708, M_t+1being stored in storage element 706, and so forth with the last M_t+τ being stored in storage element 700. M_tis multiplied by α_t−1stored in storage element 710 by multiplier 712 and the result is stored in storage element 710 thus generating the forward portion α_t. Simultaneously, α_t−1is sent over signal line 720 for multiplication by W_tand that result is then multiplied by multiplier 716 by the product of M_t+1^t+τ stored in storage element 726 and β_∞ stored in storage element 724 to crate p_t, generally as in the other described embodiment.

[0105] However, according to equation (6), to update the value of β_tat time t+1, in the case of invertible matrices, storing the entire backward potion is not necessary. M_t+2^t+τ+1can be generated by inverting M_t+1in the matrix inverter 258, and multiplying M_t+2^t+τ+1or by that inverted matrix in multiplier 730 to generate M_t+2^t+τ and then multiplying M_t+2^t+τ by M_t+τ+1in multiplier 728 to generate M_t+2^t+τ+1. This has the effect of removing the earliest term from the matrix product, while adding the next multiplicative term at time t+τ+1. Because of all the new matrix products, except for the last term, are dropped and the new value replaces the old one in storage element 726, no more of the backward sequence need to be saved in order to update β_t.

[0106] The decoding operation is illustrated in another aspect in the flowchart of FIG. 8. It will be understood that the following processing steps are illustrated as executed by controller 252 in coordination with memory 254, matrix multiplier 256 and related elements. Processing begins in step 610, followed by initialization in step 615 of the matrices and parameters as described herein. In step 620, the current matrix is read from the FIFO, and in 625 that quantity is used to generate the current forward portion, α_t−1. In step 626 α_t−1W_tis generated. In step 630, α_tis stored in storage location 226. In step 635, β_tis generated. In step 640 p_trepresenting the a posteriori probability of the input symbol is generated by multiplying α_t−1W_tand β_t. In step 645, the controller 252 directs the generation of the next matrix model for the following time period. In step 650, the next matrix model is written into the FIFO. In step 655, the next matrix model is multiplied by the contents of each of the storage locations 230, 232, . . . , 234. In step 660, the results of those multiplications are stored in locations 232, . . . , 235. The next matrix model is then overwritten in storage location 204 in step 665, and in step 675 the matrix values for succeeding storage elements 206, 208, . . . , 210 are replaced with the matrix contents for the next time. In step 680, the processing tests whether time has reached the end of the time period T. If not, processing repeats for t+1, otherwise it ends in step 685.

[0107] In an alternate embodiment, the fixed-lag algorithm can be implemented in the vector form thus reducing the computation and storage requirements. Consider the following probability vectors: $\begin{array}{cc}s\left(X_t,Y_1^{t+\tau }\right)={\alpha }_0\prod _{i=1}^{t-l}{M}_i{W}_t\prod _{i=t+1}^{t+\tau }{M}_i={\alpha }_{t-1}{W}_t{M}_{t+1}^{t+\tau }& \left(I\right)\end{array}$

[0108] We can see that s(X_t,Y₁^t) can be computed recursively as

[0109] s(X_t,Y₁^t)=α_t−1W_t  (II.A)

[0110] s(X_t,Y₁^u)=s(X_t,Y₁^u−1)M_u, (u=t+1, . . . , T)  (II.B)

[0111] Using these vectors, we can rewrite Equation (1) as

[0112] p_t=s(X_t,Y₁^T)β_∞  (III)

[0113] A list structure can be used for evaluating the a posteriori probabilities in the following way. Suppose that, for all X_twhere t<u, α_u−1, s(X_t,Y₁^u−1) represents a list at the moment u. We may then replace α_u−1with α_uand s(X_t,Y₁^u−1) with s(X_t,Y_t^u) using Equation (II.B) and the equation

[0114] α_u=α_u−1M_u  (IV)

[0115] and add to the list s(X_u,Y₁^u). At the end, we obtain p_tfrom equation (III).

[0116] In contrast with the forward-backward algorithm, this algorithm does not have a backward portion. Thus, computing probabilities with this algorithm requires less memory than required by the forward-backward algorithm. In addition, a fixed-lag algorithm using vectors requires less storage and computation than the matrix fixed-lag algorithm presented above. In this case we do not need to keep in memory s(X_t,Y₁^t+τ) for u≦t. Therefore, the list of the forward-only algorithm increases only at the beginning while t<τ.

[0117] This vector fixed-lag algorithm is illustrated in FIG. 9. FIG. 9 shows a flow diagram of a process for generating the estimate p_tusing vectors in an alternate embodiment. Matrix M_t+1is input along signal line 902. α_tis initially stored in storage element 904. Recall that α_tis a row vector. In this embodiment, α_tis right-hand multiplied by M_t+1at multiplier 906 and right hand multiplied by matrix W_t+1at multiplier 910. The result of the first multiplication is then stored in storage element 904. For exemplary purposes, if a row vector and a square matrix are used, the multiplication yields a row vector being stored in storage element 904. The result of the second multiplication is stored in storage element 912 as shown by arrow 914.

[0118] The storage elements 912, 914, and 918 at time t contain the probability vectors s_t+1=s(X_t,Y₁^t), s_t+2=s(X_t−1,Y₁^t), . . . , s_t+τ+1=s (X_t−τ,Y₁^t), respectively. The content of storage element 912 and the content of storage element 914 are right-hand multiplied by matrix M_t+1at multipliers 916 and 920 and shifted to the next storage element as indicated by arrows. Additional storage elements may be added with the same multiplication pattern as indicated by the dashed lines 926. The product of the last multiplication is stored in storage element 918. This product is right hand multiplied with β_∞. As discussed above, if β_∞ is a unity column vector, the mathematical operation is summing the elements in the row vector s_t+τ+1. The product is the probability p_t+τ−1=p(X_t−τ−1,Y₁^t−1).

[0119] Given that row vector α_tis right-hand multiplied by matrix M_t+1yielding a row vector, at the beginning of the algorithm, the storage requirements of storage elements 904, 912, 914, 918 are less than the storage requirements of the storage elements shown in FIG. 2 (storing matrices). In addition, the total number of storage elements shown in FIG. 9 is less than the total number of the storage elements shown in FIG. 2. Thus, the algorithm shown in FIG. 9 has a faster computation time than the algorithm shown in FIG. 2 as well as a smaller memory requirement.

[0120] FIGS. 10 and 11 are used to exemplify the process described in FIG. 9. FIG. 10 illustrates a convolutional encoder 1000 having shift registers 1004 and 1006 and summers 1008 and 1010. Input symbols I_jare input into encoder 1000 along signal line 1002. As shown in FIG. 10,

[0121] x_j1=I_j+I_j−1I_j−2

[0122] as shown by signal line 1002, shift registers 1004 and 1006 and summer 1008, and

[0123] x_j2=I_j+I_j−2

[0124] as shown by signal line 1002, shift register 1006 and summer 1010. The state of encoder 1000 is shown by the contents of shift registers 1004 and 1006 and is represented by the following expression, S_j=[x_j−1, x_j−2]. Encoder 1000 output symbols X_j1and X_j2are mapped to a modulator, such as a quadrature phase shift keying (QPSK) modulator shown in FIG. 10. The encoder is a rate one-half encoder, outputting two bits for each input bit. The modulated symbols are transmitted over a communications channel with memory that is modeled by an HMM.

[0125] Assume that the communications channel has bursts of errors as presented in the following parameters: a₀=[0.91892 0.08108] $P\left(0\right)=\left[\begin{array}{cc}0.997& 0.00252\\ 0.034& 0.81144\end{array}\right]P\left(1\right)=\left[\begin{array}{cc}0.0& 0.00048\\ 0.0& 0.15456\end{array}\right]$

[0126] The α₀row vector represents the initial conditions of the communications channel. The P(0) square matrix and the P(1) square matrix are the matrix probabilities of correct reception and erroneous reception, respectively. Assume further that the following bit sequence is received:

[0127] Y₁^T=11 01 11 00 00 11 01 01 00 10 11 00, where T=12. (Given the rate one-half encoder, Y₁=11; Y₂=01, Y₃=11 . . . Y₁₂=00).

[0128] FIG. 11 illustrates the normalized a posteriori probabilities of the transmitted bits given the above received bits using the forward-backward algorithm (columns two and three); the vector fixed-lag algorithm with τ=1 (columns four and five); and the vector fixed-lag algorithm with τ=3 (columns six and seven). Column one represents time t and column eight represents the predicted input bit.

[0129] So, at time t=0, using the forward-backward algorithm, we can see that the probability that the input X₀was a 0 is 0.00000 and the probability that X₀is a 1 is 0.79311. Thus, it is more likely that the input bit X₀was a 1. Using the vector fixed-lag algorithm with the lag, or memory τ=1, we can see that the probability that the input X₀was a 0 is 0.00013 and the probability that X₀is a 1 is 0.24542. Thus, under this algorithm with τ=1, it is still more likely that the input bit X₀was a 1.

[0130] Finally, using the vector fixed-lag algorithm, with the lag, or memory τ=3, we can see that the probability that the input X₀was a 0 is 0.00003 and the probability that X₀is a 1 is 0.67481. Thus, under this algorithm with τ=3 it is also more likely that the input bit X₀was a 1. Column eight shows that the input X₀is 1. The remaining entries in the table show the probabilities of input symbols at times t=1−9.

[0131] As we can see, the lag τ=3 estimates (columns 6 and 7) are closer to the complete a posteriori probability (columns 2 and 3) than lag τ=1 estimates (columns 2 and 3), but in both cases the vector fixed-lag algorithm decodes the same input sequence, even for these small lags, as the complete forward-backward algorithm.

[0132] The foregoing description of the system and method for processing information according to the invention is illustrative, and variations in configuration and implementation will occur to person skilled in the art.