Asserted Claim of ’800
`Patent
`[1A] A method for data
`processing in a reconfigurable
`computing system, the
`reconfigurable computing
`system comprising at least one
`reconfigurable processor, the
`reconfigurable processor
`comprising a plurality of
`functional units, said method
`comprising:
`
`Exemplary Disclosure of RaPiD
`
`At least under Plaintiff’s apparent theories of infringement and interpretations of the claims in
`alleging that any of Defendant’s accused products satisfy this claim limitation, RaPiD alone or in
`combination with one or more references, discloses:
`
`RaPiD at Abstract: “The goal of the RaPiD (Reconfigurable Pipelined Datapath) architecture is to
`provide high performance configurable computing for a range of computationally-intensive
`applications that demand special-purpose hardware. This is accomplished by mapping the
`computation into a deep pipeline using it configurable array of coarse-grained computational units.”
`
`RaPiD at 106: “Unfortunately, the promise of configurable computing has yet to be realized in spite
`of some very successful examples [l, 9]. There are two main reasons for this.”
`
`RaPiD at 111: “Since a 2-D DCT performs two multiplies by the same weight matrix, W is loaded
`only once: one column per cell in both the first 8 cells and last 8 cells. The transpose in between
`matrix multiplies is performed with two local memories per cell: one to store products of the current
`sub-image and the other to store the products of the previous sub-image. During the computation of
`the current sub-image, the transpose of the previous sub-image computation is passed to the next 8
`cells. The datapath for one RaPiD cell of a 2-D DCT is shown in Figure 10.”
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 1
`
`

`

`
`
`
`
`RaPiD at 115: “References
`
`[1] J. M. Arnold et al. The Splash 2 processor and applications. In Proceedings IEEE International
`Conference on Computer Design: VLSI in Computers and Processors, pages 482-5. IEEE Comput.
`Soc. Press, 1993.”
`
`To the extent Plaintiff asserts this limitation is not expressly or inherently disclosed under Plaintiff’s
`apparent claim construction, or any other claim construction, the claimed subject matter would have
`been obvious to a person of ordinary skill in the art considering this reference in combination with
`the knowledge of one of ordinary skill in the art at the time of the alleged invention and/or the
`disclosures in one or more of the references identified in Section I.B.2 of the cover pleading.
`
`At least under Plaintiff’s apparent theories of infringement and interpretations of the claims in
`alleging that any of Defendant’s accused products satisfy this claim limitation, RaPiD alone or in
`combination with one or more references, discloses:
`
`RaPiD at Equations 5 and 6:
`
`
`[1B] transforming an algorithm
`into a data driven calculation
`that is implemented by said
`reconfigurable computing
`system at the at least one
`reconfigurable processor;
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 2
`
`

`

`
`
`
`
`
`RaPiD at 111: “As seen in Equation 5 and Equation 6, both zmj and yji are equivalent to N x N
`matrix multiplies. However, since the zmj values are produced in row-major order but required in
`column-major order, the results from the zmj DCT must be transposed prior to computing yji as
`illustrated in Figure 8. In addition, since both input streams are read in row-major order, it might be
`desirable to produce row-major output (potentially reducing memory stalls), requiring yet another
`transform (i.e. output yij instead of yji). The resulting computation is ((A x W)T x W)T.”
`
`To the extent Plaintiff asserts this limitation is not expressly or inherently disclosed under Plaintiff’s
`apparent claim construction, or any other claim construction, the claimed subject matter would have
`been obvious to a person of ordinary skill in the art considering this reference in combination with
`the knowledge of one of ordinary skill in the art at the time of the alleged invention and/or the
`disclosures in one or more of the references identified in Section I.B.2 of the cover pleading.
`
`
`
`
`
`
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 3
`
`

`

`[1C] forming at least two of
`said functional units at the at
`least one reconfigurable
`processor to perform said
`calculation
`
`At least under Plaintiff’s apparent theories of infringement and interpretations of the claims in
`alleging that any of Defendant’s accused products satisfy this claim limitation, RaPiD alone or in
`combination with one or more references, discloses:
`
`RaPiD at 110: “5.1 1-D DCT
`An N-point 1-D DCT partitions an input vector A into N-element sub-vectors, and for each resulting
`subvector Ah computes
`
`
`
`for 0 ≤ i ≤ N - 1, where ahn is the n-th element of sub-vector Ah (and the (hN + n)-th element of
`vector A).l The N2 cosine terms are constant over all subvectors and hence can be read once as
`precomputed weights W where wni = cos πi/2N(2n + 1). This reduces Equation 1 to
`
`
`
`for 0 ≤ i ≤ N – 1. By viewing input vector A and weights W as matrices A and W, Equation 2
`reduces to the matrix multiply Y = A x W. Thus, to compute a 1-D DCT, RaPiD performs a matrix
`multiply. To implement an 8 point 1-D DCT on an 8 x 8 input matrix A (i.e. a 64-element vector),
`the entire 8 x 8 weight matrix W is stored in RaPiD's local memories, one column per cell. Each cell
`of the resulting pipeline is configured as shown in Figure 7. The A matrix is passed through the
`array in row-major order. Within each cell, the local memory address is incremented each cycle, and
`a register accumulates the dot product of the stored column and the incoming row. When a cell
`receives the last element of a row, the resulting product is passed down an output pipeline, the
`address is cleared, and the cell is ready to compute the product of the next row on the next cycle.
`This effectively computes the matrix multiply of A x W.”
`
`RaPiD at Equations 5 and 6:
`
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 4
`
`

`

`
`
`
`RaPiD at 111: “As seen in Equation 5 and Equation 6, both zmj and yji are equivalent to N x N
`matrix multiplies. However, since the zmj values are produced in row-major order but required in
`column-major order, the results from the zmj DCT must be transposed prior to computing yji as
`illustrated in Figure 8. In addition, since both input streams are read in row-major order, it might be
`desirable to produce row-major output (potentially reducing memory stalls), requiring yet another
`transform (i.e. output yij instead of yji). The resulting computation is ((A x W)T x W)T.”
`
`RaPiD at Figure 8:
`
`
`
`RaPiD at 111: “We show the implementation of an 8 x 8 2-D DCT on a 16-cell RaPiD array.
`
`
`
`Consider an M x N image and an 8 x 8 weight matrix W. First, the image is divided into 𝐌𝐌𝐌𝐌𝟔𝟔𝟔𝟔 sub-
`
`images of size 8 x 8. The computation for each sub-image A is outlined in Figure 9.
`
`RaPiD at 111: “Since a 2-D DCT performs two multiplies by the same weight matrix, W is loaded
`only once: one column per cell in both the first 8 cells and last 8 cells. The transpose in between
`matrix multiplies is performed with two local memories per cell: one to store products of the current
`sub-image and the other to store the products of the previous sub-image. During the computation of
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 5
`
`

`

`the current sub-image, the transpose of the previous sub-image computation is passed to the next 8
`cells. The datapath for one RaPiD cell of a 2-D DCT is shown in Figure 10.”
`
`
`[1D] wherein only functional
`units needed to solve the
`calculation are formed and
`
`
`
`To the extent Plaintiff asserts this limitation is not expressly or inherently disclosed under Plaintiff’s
`apparent claim construction, or any other claim construction, the claimed subject matter would have
`been obvious to a person of ordinary skill in the art considering this reference in combination with
`the knowledge of one of ordinary skill in the art at the time of the alleged invention and/or the
`disclosures in one or more of the references identified in Section I.B.2 of the cover pleading.
`
`
`At least under Plaintiff’s apparent theories of infringement and interpretations of the claims in
`alleging that any of Defendant’s accused products satisfy this claim limitation, RaPiD alone or in
`combination with one or more references, discloses:
`
`RaPiD at 110: “5.1 1-D DCT
`An N-point 1-D DCT partitions an input vector A into N-element sub-vectors, and for each resulting
`subvector Ah computes
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 6
`
`

`

`
`
`for 0 ≤ i ≤ N - 1, where ahn is the n-th element of sub-vector Ah (and the (hN + n)-th element of
`vector A).l The N2 cosine terms are constant over all subvectors and hence can be read once as
`precomputed weights W where wni = cos πi/2N(2n + 1). This reduces Equation 1 to
`
`
`
`for 0 ≤ i ≤ N – 1. By viewing input vector A and weights W as matrices A and W, Equation 2
`reduces to the matrix multiply Y = A x W. Thus, to compute a 1-D DCT, RaPiD performs a matrix
`multiply. To implement an 8 point 1-D DCT on an 8 x 8 input matrix A (i.e. a 64-element vector),
`the entire 8 x 8 weight matrix W is stored in RaPiD's local memories, one column per cell. Each cell
`of the resulting pipeline is configured as shown in Figure 7. The A matrix is passed through the
`array in row-major order. Within each cell, the local memory address is incremented each cycle, and
`a register accumulates the dot product of the stored column and the incoming row. When a cell
`receives the last element of a row, the resulting product is passed down an output pipeline, the
`address is cleared, and the cell is ready to compute the product of the next row on the next cycle.
`This effectively computes the matrix multiply of A x W.”
`
`
`RaPiD at Equations 5 and 6:
`
`
`
`
`
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 7
`
`

`

`RaPiD at 111: “As seen in Equation 5 and Equation 6, both zmj and yji are equivalent to N x N
`matrix multiplies. However, since the zmj values are produced in row-major order but required in
`column-major order, the results from the zmj DCT must be transposed prior to computing yji as
`illustrated in Figure 8. In addition, since both input streams are read in row-major order, it might be
`desirable to produce row-major output (potentially reducing memory stalls), requiring yet another
`transform (i.e. output yij instead of yji). The resulting computation is ((A x W)T x W)T.”
`
`RaPiD at 111: “Since a 2-D DCT performs two multiplies by the same weight matrix, W is loaded
`only once: one column per cell in both the first 8 cells and last 8 cells. The transpose in between
`matrix multiplies is performed with two local memories per cell: one to store products of the current
`sub-image and the other to store the products of the previous sub-image. During the computation of
`the current sub-image, the transpose of the previous sub-image computation is passed to the next 8
`cells. The datapath for one RaPiD cell of a 2-D DCT is shown in Figure 10.”
`
`
`
`
`
`To the extent Plaintiff asserts this limitation is not expressly or inherently disclosed under Plaintiff’s
`apparent claim construction, or any other claim construction, the claimed subject matter would have
`been obvious to a person of ordinary skill in the art considering this reference in combination with
`
`
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 8
`
`

`

`[1E] wherein each formed
`functional unit at the at least
`one reconfigurable processor
`interconnects with each other
`formed functional unit at the at
`least one reconfigurable
`processor based on
`reconfigurable routing
`resources within the at least
`one reconfigurable processor
`as established at formation
`
`the knowledge of one of ordinary skill in the art at the time of the alleged invention and/or the
`disclosures in one or more of the references identified in Section I.B.2 of the cover pleading.
`
`At least under Plaintiff’s apparent theories of infringement and interpretations of the claims in
`alleging that any of Defendant’s accused products satisfy this claim limitation, RaPiD alone or in
`combination with one or more references, discloses:
`
`RaPiD at 110: “5.1 1-D DCT
`An N-point 1-D DCT partitions an input vector A into N-element sub-vectors, and for each resulting
`subvector Ah computes
`
`
`
`for 0 ≤ i ≤ N - 1, where ahn is the n-th element of sub-vector Ah (and the (hN + n)-th element of
`vector A).l The N2 cosine terms are constant over all subvectors and hence can be read once as
`precomputed weights W where wni = cos πi/2N(2n + 1). This reduces Equation 1 to
`
`
`
`for 0 ≤ i ≤ N – 1. By viewing input vector A and weights W as matrices A and W, Equation 2
`reduces to the matrix multiply Y = A x W. Thus, to compute a 1-D DCT, RaPiD performs a matrix
`multiply. To implement an 8 point 1-D DCT on an 8 x 8 input matrix A (i.e. a 64-element vector),
`the entire 8 x 8 weight matrix W is stored in RaPiD's local memories, one column per cell. Each cell
`of the resulting pipeline is configured as shown in Figure 7. The A matrix is passed through the
`array in row-major order. Within each cell, the local memory address is incremented each cycle, and
`a register accumulates the dot product of the stored column and the incoming row. When a cell
`receives the last element of a row, the resulting product is passed down an output pipeline, the
`address is cleared, and the cell is ready to compute the product of the next row on the next cycle.
`This effectively computes the matrix multiply of A x W.”
`
`
`RaPiD at Equations 5 and 6:
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 9
`
`

`

`
`
`
`
`
`RaPiD at 111: “As seen in Equation 5 and Equation 6, both zmj and yji are equivalent to N x N
`matrix multiplies. However, since the zmj values are produced in row-major order but required in
`column-major order, the results from the zmj DCT must be transposed prior to computing yji as
`illustrated in Figure 8. In addition, since both input streams are read in row-major order, it might be
`desirable to produce row-major output (potentially reducing memory stalls), requiring yet another
`transform (i.e. output yij instead of yji). The resulting computation is ((A x W)T x W)T.”
`
`RaPiD at 111: “Since a 2-D DCT performs two multiplies by the same weight matrix, W is loaded
`only once: one column per cell in both the first 8 cells and last 8 cells. The transpose in between
`matrix multiplies is performed with two local memories per cell: one to store products of the current
`sub-image and the other to store the products of the previous sub-image. During the computation of
`the current sub-image, the transpose of the previous sub-image computation is passed to the next 8
`cells. The datapath for one RaPiD cell of a 2-D DCT is shown in Figure 10.”
`
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 10
`
`

`

`[1F] wherein lines of code of
`said calculation are formed as
`clusters of functional units
`within the at least one
`reconfigurable processor;
`
`
`
`
`
`
`To the extent Plaintiff asserts this limitation is not expressly or inherently disclosed under Plaintiff’s
`apparent claim construction, or any other claim construction, the claimed subject matter would have
`been obvious to a person of ordinary skill in the art considering this reference in combination with
`the knowledge of one of ordinary skill in the art at the time of the alleged invention and/or the
`disclosures in one or more of the references identified in Section I.B.2 of the cover pleading.
`
`At least under Plaintiff’s apparent theories of infringement and interpretations of the claims in
`alleging that any of Defendant’s accused products satisfy this claim limitation, RaPiD alone or in
`combination with one or more references, discloses:
`
`RaPiD at 110: “5.1 1-D DCT
`An N-point 1-D DCT partitions an input vector A into N-element sub-vectors, and for each resulting
`subvector Ah computes
`
`
`
`
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 11
`
`

`

`for 0 ≤ i ≤ N - 1, where ahn is the n-th element of sub-vector Ah (and the (hN + n)-th element of
`vector A).l The N2 cosine terms are constant over all subvectors and hence can be read once as
`precomputed weights W where wni = cos πi/2N(2n + 1). This reduces Equation 1 to
`
`
`
`for 0 ≤ i ≤ N – 1. By viewing input vector A and weights W as matrices A and W, Equation 2
`reduces to the matrix multiply Y = A x W. Thus, to compute a 1-D DCT, RaPiD performs a matrix
`multiply. To implement an 8 point 1-D DCT on an 8 x 8 input matrix A (i.e. a 64-element vector),
`the entire 8 x 8 weight matrix W is stored in RaPiD's local memories, one column per cell. Each cell
`of the resulting pipeline is configured as shown in Figure 7. The A matrix is passed through the
`array in row-major order. Within each cell, the local memory address is incremented each cycle, and
`a register accumulates the dot product of the stored column and the incoming row. When a cell
`receives the last element of a row, the resulting product is passed down an output pipeline, the
`address is cleared, and the cell is ready to compute the product of the next row on the next cycle.
`This effectively computes the matrix multiply of A x W.”
`
`
`RaPiD at Equations 5 and 6:
`
`
`
`RaPiD at 111: “As seen in Equation 5 and Equation 6, both zmj and yji are equivalent to N x N
`matrix multiplies. However, since the zmj values are produced in row-major order but required in
`column-major order, the results from the zmj DCT must be transposed prior to computing yji as
`
`
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 12
`
`

`

`illustrated in Figure 8. In addition, since both input streams are read in row-major order, it might be
`desirable to produce row-major output (potentially reducing memory stalls), requiring yet another
`transform (i.e. output yij instead of yji). The resulting computation is ((A x W)T x W)T.”
`
`RaPiD at 111: “Since a 2-D DCT performs two multiplies by the same weight matrix, W is loaded
`only once: one column per cell in both the first 8 cells and last 8 cells. The transpose in between
`matrix multiplies is performed with two local memories per cell: one to store products of the current
`sub-image and the other to store the products of the previous sub-image. During the computation of
`the current sub-image, the transpose of the previous sub-image computation is passed to the next 8
`cells. The datapath for one RaPiD cell of a 2-D DCT is shown in Figure 10.”
`
`
`
`
`
`To the extent Plaintiff asserts this limitation is not expressly or inherently disclosed under Plaintiff’s
`apparent claim construction, or any other claim construction, the claimed subject matter would have
`been obvious to a person of ordinary skill in the art considering this reference in combination with
`the knowledge of one of ordinary skill in the art at the time of the alleged invention and/or the
`disclosures in one or more of the references identified in Section I.B.2 of the cover pleading.
`
`
`
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 13
`
`

`

`[1G] utilizing a first of said
`formed functional units to
`operate upon a subsequent data
`dimension of said calculation
`forming a first computational
`loop; and substantially
`concurrently utilizing a second
`of said formed functional units
`to operate upon a previous data
`dimension of said calculation
`forming a second
`computational loop
`
`At least under Plaintiff’s apparent theories of infringement and interpretations of the claims in
`alleging that any of Defendant’s accused products satisfy this claim limitation, RaPiD alone or in
`combination with one or more references, discloses:
`
`RaPiD at 110: “5.1 1-D DCT
`An N-point 1-D DCT partitions an input vector A into N-element sub-vectors, and for each resulting
`subvector Ah computes
`
`
`
`for 0 ≤ i ≤ N - 1, where ahn is the n-th element of sub-vector Ah (and the (hN + n)-th element of
`vector A).l The N2 cosine terms are constant over all subvectors and hence can be read once as
`precomputed weights W where wni = cos πi/2N(2n + 1). This reduces Equation 1 to
`
`
`
`for 0 ≤ i ≤ N – 1. By viewing input vector A and weights W as matrices A and W, Equation 2
`reduces to the matrix multiply Y = A x W. Thus, to compute a 1-D DCT, RaPiD performs a matrix
`multiply. To implement an 8 point 1-D DCT on an 8 x 8 input matrix A (i.e. a 64-element vector),
`the entire 8 x 8 weight matrix W is stored in RaPiD's local memories, one column per cell. Each cell
`of the resulting pipeline is configured as shown in Figure 7. The A matrix is passed through the
`array in row-major order. Within each cell, the local memory address is incremented each cycle, and
`a register accumulates the dot product of the stored column and the incoming row. When a cell
`receives the last element of a row, the resulting product is passed down an output pipeline, the
`address is cleared, and the cell is ready to compute the product of the next row on the next cycle.
`This effectively computes the matrix multiply of A x W.”
`
`
`RaPiD at Equations 5 and 6:
`
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 14
`
`

`

`
`
`
`RaPiD at 111: “As seen in Equation 5 and Equation 6, both zmj and yji are equivalent to N x N
`matrix multiplies. However, since the zmj values are produced in row-major order but required in
`column-major order, the results from the zmj DCT must be transposed prior to computing yji as
`illustrated in Figure 8. In addition, since both input streams are read in row-major order, it might be
`desirable to produce row-major output (potentially reducing memory stalls), requiring yet another
`transform (i.e. output yij instead of yji). The resulting computation is ((A x W)T x W)T.”
`
`RaPiD at 111: “Since a 2-D DCT performs two multiplies by the same weight matrix, W is loaded
`only once: one column per cell in both the first 8 cells and last 8 cells. The transpose in between
`matrix multiplies is performed with two local memories per cell: one to store products of the current
`sub-image and the other to store the products of the previous sub-image. During the computation of
`the current sub-image, the transpose of the previous sub-image computation is passed to the next 8
`cells. The datapath for one RaPiD cell of a 2-D DCT is shown in Figure 10.”
`
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 15
`
`

`

`
`
`
`
`
`To the extent Plaintiff asserts this limitation is not expressly or inherently disclosed under Plaintiff’s
`apparent claim construction, or any other claim construction, the claimed subject matter would have
`been obvious to a person of ordinary skill in the art considering this reference in combination with
`the knowledge of one of ordinary skill in the art at the time of the alleged invention and/or the
`disclosures in one or more of the references identified in Section I.B.2 of the cover pleading.
`
`At least under Plaintiff’s apparent theories of infringement and interpretations of the claims in
`alleging that any of Defendant’s accused products satisfy this claim limitation, RaPiD alone or in
`combination with one or more references, discloses:
`
`RaPiD at 110: “5.1 1-D DCT
`An N-point 1-D DCT partitions an input vector A into N-element sub-vectors, and for each resulting
`subvector Ah computes
`
`
`
`
`
`[1H] wherein said
`implementation of said
`calculation enables said first
`computational loop and said
`second computational loop to
`execute concurrently and pass
`computed data seamlessly
`between said computational
`loops.
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 16
`
`

`

`for 0 ≤ i ≤ N - 1, where ahn is the n-th element of sub-vector Ah (and the (hN + n)-th element of
`vector A).l The N2 cosine terms are constant over all subvectors and hence can be read once as
`precomputed weights W where wni = cos πi/2N(2n + 1). This reduces Equation 1 to
`
`
`
`for 0 ≤ i ≤ N – 1. By viewing input vector A and weights W as matrices A and W, Equation 2
`reduces to the matrix multiply Y = A x W. Thus, to compute a 1-D DCT, RaPiD performs a matrix
`multiply. To implement an 8 point 1-D DCT on an 8 x 8 input matrix A (i.e. a 64-element vector),
`the entire 8 x 8 weight matrix W is stored in RaPiD's local memories, one column per cell. Each cell
`of the resulting pipeline is configured as shown in Figure 7. The A matrix is passed through the
`array in row-major order. Within each cell, the local memory address is incremented each cycle, and
`a register accumulates the dot product of the stored column and the incoming row. When a cell
`receives the last element of a row, the resulting product is passed down an output pipeline, the
`address is cleared, and the cell is ready to compute the product of the next row on the next cycle.
`This effectively computes the matrix multiply of A x W.”
`
`
`RaPiD at Equations 5 and 6:
`
`
`
`RaPiD at 111: “As seen in Equation 5 and Equation 6, both zmj and yji are equivalent to N x N
`matrix multiplies. However, since the zmj values are produced in row-major order but required in
`column-major order, the results from the zmj DCT must be transposed prior to computing yji as
`
`
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 17
`
`

`

`illustrated in Figure 8. In addition, since both input streams are read in row-major order, it might be
`desirable to produce row-major output (potentially reducing memory stalls), requiring yet another
`transform (i.e. output yij instead of yji). The resulting computation is ((A x W)T x W)T.”
`
`RaPiD at 111: “Since a 2-D DCT performs two multiplies by the same weight matrix, W is loaded
`only once: one column per cell in both the first 8 cells and last 8 cells. The transpose in between
`matrix multiplies is performed with two local memories per cell: one to store products of the current
`sub-image and the other to store the products of the previous sub-image. During the computation of
`the current sub-image, the transpose of the previous sub-image computation is passed to the next 8
`cells. The datapath for one RaPiD cell of a 2-D DCT is shown in Figure 10.”
`
`
`
`
`
`To the extent Plaintiff asserts this limitation is not expressly or inherently disclosed under Plaintiff’s
`apparent claim construction, or any other claim construction, the claimed subject matter would have
`been obvious to a person of ordinary skill in the art considering this reference in combination with
`the knowledge of one of ordinary skill in the art at the time of the alleged invention and/or the
`disclosures in one or more of the references identified in Section I.B.2 of the cover pleading.
`
`
`
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 18
`
`

`

`
`
`[8] The method of claim 1
`wherein said calculation
`comprises a JPEG image
`compression calculation.
`
`At least under Plaintiff’s apparent theories of infringement and interpretations of the claims in
`alleging that any of Defendant’s accused products satisfy this claim limitation, RaPiD alone or in
`combination with one or more references, discloses:
`
`RaPiD at 110: “5.1 1-D DCT
`An N-point 1-D DCT partitions an input vector A into N-element sub-vectors, and for each resulting
`subvector Ah computes
`
`
`
`for 0 ≤ i ≤ N - 1, where ahn is the n-th element of sub-vector Ah (and the (hN + n)-th element of
`vector A).l The N2 cosine terms are constant over all subvectors and hence can be read once as
`precomputed weights W where wni = cos πi/2N(2n + 1). This reduces Equation 1 to
`
`
`
`for 0 ≤ i ≤ N – 1. By viewing input vector A and weights W as matrices A and W, Equation 2
`reduces to the matrix multiply Y = A x W. Thus, to compute a 1-D DCT, RaPiD performs a matrix
`multiply. To implement an 8 point 1-D DCT on an 8 x 8 input matrix A (i.e. a 64-element vector),
`the entire 8 x 8 weight matrix W is stored in RaPiD's local memories, one column per cell. Each cell
`of the resulting pipeline is configured as shown in Figure 7. The A matrix is passed through the
`array in row-major order. Within each cell, the local memory address is incremented each cycle, and
`a register accumulates the dot product of the stored column and the incoming row. When a cell
`receives the last element of a row, the resulting product is passed down an output pipeline, the
`address is cleared, and the cell is ready to compute the product of the next row on the next cycle.
`This effectively computes the matrix multiply of A x W.”
`
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 19
`
`

`

`
`
`
`
`
`RaPiD at 110: “5. Discrete Cosine Transform
`The discrete cosine transform (DCT) is used frequently in signal processing and graphics
`applications. For example, the 2-D DCT is used in JPEG/MPEG data compression to convert an
`image from the spatial domain to the frequency domain. A 2-D DCT can be decomposed into two
`sequential 1-D DCTs. We first describe how the 1-D DCT can be computed on RaPiD and then
`show how two 1-D DCTs can be composed to perform a 2-D DCT.”
`
`RaPiD at 111: “We show the implementation of an 8 x 8 2-D DCT on a 16-cell RaPiD array.
`Consider an M x N image and an 8 x 8 weight matrix W. First, the image is divided into sub-images
`of size 8 x 8. The computation for each sub-image A is outlined in Figure 9.”
`
`RaPiD at Equations 5 and 6:
`
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 20
`
`

`

`
`
`
`RaPiD at 111: “As seen in Equation 5 and Equation 6, both zmj and yji are equivalent to N x N
`matrix multiplies. However, since the zmj values are produced in row-major order but required in
`column-major order, the results from the zmj DCT must be transposed prior to computing yji as
`illustrated in Figure 8. In addition, since both input streams are read in row-major order, it might be
`desirable to produce row-major output (potentially reducing memory stalls), requiring yet another
`transform (i.e. output yij instead of yji). The resulting computation is ((A x W)T x W)T.”
`
`RaPiD at Figure 8:
`
`
`
`RaPiD at 111: “We show the implementation of an 8 x 8 2-D DCT on a 16-cell RaPiD array.
`
`
`
`Consider an M x N image and an 8 x 8 weight matrix W. First, the image is divided into 𝐌𝐌𝐌𝐌𝟔𝟔𝟔𝟔 sub-
`
`images of size 8 x 8. The computation for each sub-image A is outlined in Figure 9.
`
`
`RaPiD at Figure 9:
`
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 21
`
`

`

`
`
`RaPiD at 111: “Since a 2-D DCT performs two multiplies by the same weight matrix, W is loaded
`only once: one column per cell in both the first 8 cells and last 8 cells. The transpose in between
`matrix multiplies is performed with two local memories per cell: one to store products of the current
`sub-image and the other to store the products of the previous sub-image. During the computation of
`the current sub-image, the transpose of the previous sub-image computation is passed to the next 8
`cells. The datapath for one RaPiD cell of a 2-D DCT is shown in Figure 10.”
`
`
`Patent Owner Saint Regis Mohawk Tribe
`Ex. 2056, p. 22
`
`

`

`
`
`
`RaPiD at 112: “5.4 DCT Performance
`A 2-D DCT performs many consecutive 8 x 8 matrix multiplies, allowing initialization, finalization,
`and reconfiguration times to be small compared to the total computation performed. For example,
`[Reconfigurable Pipelined Datapath] RaPiD-1 (Section 2.3) incurs a setup overhead of only 0.5% to
`compute the 2-D DCT of a 720 x 576 image. As a result, RaPiD-1 performs very close to its peak of
`1.6 GOPS on 2-D DCT (where GOPS is a billion multiply accumulates per second).”
`
`RaPiD at 112: “6. Motion estimation
`Motion estimation is used in video data compression to reduce the amount of data required to
`represent a video frame. In most cases, objects do not move very much from one frame to the next.
`In motion estimation, a block in a frame is represented by the address of the most similar nearby
`block in the previous frame plus the differences between the two blocks. This sect