UNITED STATES PATENT AND TRADEMARK OFFICE
`
`____________
`
`BEFORE THE PATENT TRIAL AND APPEAL BOARD
`
` ____________
`
`SEGA OF AMERICA, INC., UBISOFT, INC., KOFAX, INC.,
`CAMBIUM LEARNING GROUP, INC. AND PERFECT WORLD
`ENTERTAINMENT, INC.
`Petitioners
`
`v.
`
`UNILOC USA, INC. and UNILOC LUXEMBOURG S.A.,
`Patent Owner
`
`____________
`
`Case No. IPR2014-014531
`Patent 5,490,216
` ____________
`
`
`
`SUPPLEMENTAL DECLARATION OF DR. VIJAY K. MADISETTI
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`1 Case IPR2015-01026 has been joined with this proceeding.
`
`
`
`1
`
`Petitioner Ex. 1039 Page 1
`
`
`
`____________
`
`BEFORE THE PATENT TRIAL AND APPEAL BOARD
`
` ____________
`
`SEGA OF AMERICA, INC., UBISOFT, INC., KOFAX, INC.,
`CAMBIUM LEARNING GROUP, INC. AND PERFECT WORLD
`ENTERTAINMENT, INC.
`Petitioners
`
`v.
`
`UNILOC USA, INC. and UNILOC LUXEMBOURG S.A.,
`Patent Owner
`
`____________
`
`Case No. IPR2014-014531
`Patent 5,490,216
` ____________
`
`
`
`SUPPLEMENTAL DECLARATION OF DR. VIJAY K. MADISETTI
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`1 Case IPR2015-01026 has been joined with this proceeding.
`
`
`
`1
`
`Petitioner Ex. 1039 Page 1
`
`
`
`
`
`I, Vijay K. Madisetti, hereby declare the following:
`I.
`BACKGROUND AND EDUCATION
`1. My background, education and experience were detailed in my original
`
`declaration (Exhibit 1007) submitted with the Petition for Inter Partes Review and
`
`are incorporated by reference here.
`
`2.
`
`I have been retained by Ubisoft Inc., Sega of America, Inc., Kofax,
`
`Inc., Cambium Learning Group, Inc. and Perfect World Entertainment, Inc. and am
`
`submitting this declaration to offer my independent expert opinion concerning
`
`certain issues raised in Patent Owner’s Response (“PO’s Response”) to the Petition
`
`for inter partes Review (“Petition”). I am being compensated at my normal
`
`consulting rate of $450/hour. My compensation is not based on the substance of
`
`the opinions rendered here. As part of my work in connection with this matter, I
`
`have studied U.S. Patent No. 5,490,216 (“the ‘216 patent”), including the
`
`respective written descriptions, figures, claims, in addition to the original file
`
`history and subsequent reexamination proceedings. I have also reviewed various
`
`documents from the prior litigation proceeding in the U.S. District Court for the
`
`District of Rhode Island, Uniloc USA, Inc. et al. v. Microsoft Corp., No. 03-
`
`CV0440 (WES) and subsequent Federal Circuit opinions on appeals. Moreover, I
`
`
`
`2
`
`Petitioner Ex. 1039 Page 2
`
`
`
`have reviewed the Petition for Inter Partes Review of the ‘216 patent, the Board’s
`
`Institution Decision, Patent Owner’s Response, the Declaration of Dr. Val DiEuliis
`
`and references cited therein, and also considered at least the following:
`
`• U.S. Patent No. 5,509,070 to Schull, et al., (“Schull”), entitled
`“Method for Encouraging Purchase of Executable and Non-
`Executable Software” filed on December 15, 1992 and issued on April
`16, 1996 [Exhibit 1002]
`
`• Turbo Pascal 4.0: Owner’s Handbook, Published by Borland
`International, 1987 [Appendix A]
`
`• Turbo Pascal: Introduction to Pascal and Structured Design (Third
`Edition), by Nell Dale and Chip Weems, published by D.C. Heath and
`Company, 1992 [Appendix B]
`
`• “MIPS-X Instruction Set and Programmer’s Manual,” by Paul Chow,
`Technical Report No. CSL-86-289, May 1988 [Appendix C]
`
`• “A Painless Guide to CRC Error Detection Algorithms,” by Ross N.
`Williams, August 19, 1993 [Ex. 2014]
`
`• “Cyclic Redundancy Check Computation: An Implementation Using
`the TMS320C54x,” Patrick Geremia, Texas Instruments Application
`Report SPRA530, April 1999 [Ex. 2015]
`
`• “Fast Hashing of Variable-Length Text Strings,” Peter K. Pearson,
`Communications of the ACM, June 1990, Volume 33, Number 6 [Ex.
`2016]
`
`• Federal Circuit Opinion, dated January 4, 2011, entered in Uniloc
`USA, Inc. and Uniloc Singapore Private Ltd., v. Microsoft Corp.
`[Exhibit 1010]
`
`3
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`Petitioner Ex. 1039 Page 3
`
`
`
`II. OPINION
`A. Level of a Person Having Ordinary Skill in the Art
`3.
`It is my understanding that Patent Owner has previously identified, and
`
`the Petitioners are presently suggesting, that the level of a person having ordinary
`
`skill in the art as having a Bachelor’s Degree or equivalent, in Electrical
`
`Engineering or Computer Science, or one to two years of experience in software
`
`development or the equivalent work experience. I have no reason to disagree with
`
`this suggested level of ordinary skill in the art. Based on my education, training,
`
`and professional experience in the field of the claimed invention, I am familiar
`
`with the level and abilities of a person of ordinary skill in the art at the time of the
`
`claimed invention. Additionally, I was a person having ordinary skill in the art as
`
`of the filing date of the ‘216 Patent and as of the filing dates of the two Australian
`
`patent applications to which the ‘216 Patent claims priority.
`
`4.
`
`In my earlier declaration of September 5, 2014, I opined that Schull
`
`discloses a summation algorithm in two ways. One is the use of concatenation
`
`(Ex. 1002, Schull at 7:16-27) and one through the disclosure of the checksum (Ex.
`
`1002, Schull at 7:28-36). Ex. 1007, 9/5/2014 Declaration at 40-48.
`
`5. Dr. DiEuliis attempts to rebut these opinions by first opining that the
`
`concatenation of three numbers as described in Schull is not a summation allegedly
`
`because it discloses a “linked list” and not a single number, despite explicit support
`
`of the latter in the specification. Secondly, he opines that the disclosure of
`
`
`
`4
`
`Petitioner Ex. 1039 Page 4
`
`
`
`checksums does not disclose a summation algorithm to one of ordinary skill in the
`
`art by citing three references that he argues support his opinion. I disagree with
`
`his contentions, and provide the bases for my disagreement in the sections that
`
`follow.
`
`B.
`Schull Teaches a Summation Algorithm, Summer, Or Equivalent
`6. Dr. DiEuliis opines in his declaration dated June 8, 2015, that one of
`
`ordinary skill in the art would understand that Schull’s concatenation is “normally”
`
`accomplished in a different approach, and, when using his approach, Schull does
`
`not disclose a summation algorithm or a summer. Ex. 2008, DiEuliis Declaration
`
`at ¶¶75-105. I was asked to consider whether one of skill in the art as of September
`
`21, 1993, the filing date of the ‘216 patent, upon reading Schull would have
`
`programmatically concatenated three numbers using the approach suggested by Dr.
`
`DiEuliis and to respond to certain of Dr. DiEuliis’s characterizations of my
`
`opinions.
`
`1.
`Detailed Explanation of Schull
`7. As described in Schull, “[o]ne object of the present invention is to
`
`allow programmers to conveniently invoke the first-described methods by adding a
`
`relatively small number of lines of code to their programs.” Id. at 12:46-50. With
`
`this in mind, Schull provides a “[d]escription of one possible software-tool
`
`Implementation” of his disclosed invention using the “Pascal language.” Ex. 1002,
`
`
`
`5
`
`Petitioner Ex. 1039 Page 5
`
`
`
`Schull at 12:46-59; see generally id. at 12:53-14:13. Specifically, Schull provides
`
`a description of
`
`the disclosed programming functions using
`
`the Pascal
`
`programming language. In computer programming, a function is a recognized
`
`module of code, which when “called” from a main program is designed to perform
`
`a specific task and calculate a result returned after execution according to the
`
`instructions present within the code. The format or type of data structure that stores
`
`the result is also specified as part of the function call. Appendix A, Turbo Pascal
`
`4.0: Owner’s Handbook at 57-58, 268-272; Appendix B, Turbo Pascal:
`
`Introduction to Pascal and Structured Design at 350-355. Generally a function
`
`will accept or “take in” variables, or pieces of data called parameters, modify or
`
`use them in an operation, and “return” a result that comports to a particular format
`
`or data structure, e.g., floating point or an integer. Id. Functions can be “called” or
`
`used over and over again within a program, with different parameters.
`
`8.
`
`Schull discloses a “Passwordable ID” is a single number that is
`
`generated by concatenating three numbers:
`
`[I]n one preferred embodiment, each item of protected
`software
`is assigned an adequately unique P-digit
`Program ID, and each licensed Feature is assigned an F-
`digit Feature-ID, and each ID-Target can be associated
`with a T-digit Target-ID such as a serial number. Once
`assigned (using methods described below) these ID
`numbers are combined in a fashion which preserves their
`uniqueness (e.g., by concatenating them to produce a
`number with N+M+T digits capable encoding l0^(N+M+T)
`values) and then using this combination, an encryption of
`
`
`
`6
`
`Petitioner Ex. 1039 Page 6
`
`
`
`it, or some other adequately-unique transform of it, as the
`ID.
`
`Ex. 1002, Schull at 7:17-27; see also id. at 8:50-53 (“Once the Feature-, Program-,
`
`and Target-IDs are assigned, the Passwordable ID which synthesizes them can be
`
`generated using methods like those described above.”).
`
`9.
`
` Indeed, the function that “generates the Passwordable ID,” called
`
`“MakeID,” is described as follows:
`
`function MakeID(GetTargetID, FeatureID, ProgrammerID):longint;
`
`Id. at 13:3-10. The purpose of the MakeID() function in Schull is to generate the
`
`passwordable ID based upon the TargetID (returned by a function called
`
`“GetTargetID”), the FeatureID, and the ProgrammerID. Ex. 1002, Schull at 13:3-
`
`10.
`
`10. Here, one of ordinary skill in the art would understand that, “MakeID”
`
`is the function name, the items enclosed in parentheses (i.e., “GetTargetID,
`
`FeatureID, ProgrammerID”) are the input parameters, and “longint” defines the
`
`data type or format of the returned result, which is a single number. Appendix A,
`
`Turbo Pascal 4.0: Owner’s Handbook at 58; Appendix B, Turbo Pascal:
`
`Introduction to Pascal and Structured Design at 350-355, 363.
`
`11. The data type of the result of this function is a “longint,” which is a
`
`specific type of integer in the Pascal programming language that ranges in whole
`
`numbers (i.e., numbers without fractions or decimals) from -2147483648 to
`
`
`
`7
`
`Petitioner Ex. 1039 Page 7
`
`
`
`+2147483648 and is 4 bytes in size (i.e., 32 bits). Appendix A, Turbo Pascal 4.0:
`
`Owner’s Handbook at 39-40, 209; Appendix B, Turbo Pascal: Introduction to
`
`Pascal and Structured Design at 363. Accordingly, Schull expressly discloses that
`
`the generated passwordable ID is a single integer, single number, or a whole
`
`number.
`
`12. Schull discloses that the process for generating a PasswordableID (i.e.,
`
`the MakeID function) is performed every time “a User executes the Protected
`
`Software.” Ex. 1002, Schull at 5:20-22, Fig. 1. Additionally, every time a
`
`PasswordableID is generated (i.e., every time the user uses the software), the
`
`Programmer’s Program “looks in an information storage location for a Previously
`
`Installed Password” and, if one is present, compares the generated PasswordableID
`
`with the previously stored PasswordableID in order to determine whether the user
`
`is allowed access to advanced/protected features of the software. Id. at 5:33-46,
`
`Fig. 1. The function that performs this comparison is called “PasswordIsGood.”
`
`Id. at 13:18-25, 14:4-13. Schull describ es the behavior for the function
`
`PasswordIsGood() and the subsequent actions taken by the sofware using
`
`pseudocode, which is an accurate representation of computer programming code
`
`and its algorithm, that provides a readable description of what the corresponding
`
`computer program must do.
`
`
`
`8
`
`Petitioner Ex. 1039 Page 8
`
`
`
`
`Id. at 14:4-13. Here, the PasswordIsGood() function is a Boolean function, which
`
`means that the function will perform an operation and, as a result of the opeartion,
`
`return either “true” or “false.” Id. at 13:18-19; see also Appendix A, Turbo Pascal
`
`4.0: Owner’s Handbook at 43-44; Appendix B, Turbo Pascal: Introduction to
`
`Pascal and Structured Design at 355-356. The PasswordIsGood() function
`
`specifically takes as inputs the numeric password generated by the previously
`
`described MakeID() function and another function called GetInsalledPassword().
`
`Id. at 14:4-13. The GetInstalledPassword() function is a function that “looks in a
`
`predetermined storage location . . . for a candidate password” and “returns the
`
`value of that Password.” Id. at 13:11-17.
`
`13. Like
`
`the result of
`
`the MakeID() function,
`
`the result of
`
`the
`
`GetInstalledPassword() function is a “longint” (i.e., a single 32 bit integer that is a
`
`whole number ranging from -2147483648 to +2147483648). Id. at 13:11
`
`(“function GetInstalledPasswrod:longint;”).
`
` The PasswordIsGood() function
`
`compares these two integers (i.e., the generated PasswordableID and the stored
`
`
`
`9
`
`Petitioner Ex. 1039 Page 9
`
`
`
`“InstalledPassword”). If the two integers are the same, the PasswordIsGood()
`
`function returns true (i.e., a valid passwordableID was found) and the state of a
`
`boolean array called “AdvancedFeatureIsLocked[FeatureID]” is set to false for a
`
`given program feature (i.e., the user has acces to the Advanced program feature in
`
`question). Id. at 13:18-25, 14:4-13. If the PasswordIsGood() function returns false
`
`(i.e., a valid passwordable ID was not found), then the user is invited to obtain a
`
`valid password. Id.
`
`14.
`
` As set forth in my Declaration dated September 5, 2014, it is my
`
`opinion that Schull’s disclosed concatenation of three numbers (i.e., a Program ID,
`
`a Feature ID and a Target-ID) constitutes a summation algorithm or an equivalent
`
`thereof .
`
`2.
`
`Schull’s Concatenated PasswordableID Cannot be Achieved
`by Copying Data into Contiguous Sections of Memory as
`Dr. DiEuliis Suggests
`15. Dr. DiEuliis contends, “concatenation is normally accomplished by
`
`copying the data to a contiguous section of memory so that the result is stored as a
`
`continuous array.” Ex. 2008, DiEuliis Declaration at ¶78. Specifically, Dr.
`
`DiEuliis contends that in order to concatenate three numbers—X=1234; Y=56;
`
`Z=789— to arrive at the number 123456789, each of the three numbers is stored as
`
`a two-byte structure and “all that is required is to rearrange (that is, move or copy)
`
`the numbers into a contiguous section of memory.” Id. at ¶¶82-83. Dr. DiEuliis
`
`
`
`10
`
`Petitioner Ex. 1039 Page 10
`
`
`
`further contends, “the contiguous list of numbers may be stored in a data structure
`
`that includes a linking address to another list,” which is a “well-known data
`
`structure known as a ‘linked list.’” Id. at fn. 10.
`
`16.
`
`I disagree with Dr. DiEuliis. The result of moving bytes into
`
`contiguous sections of memory in the form of a linked list cannot be a single whole
`
`number or “longint” integer. Instead, the result is three separate integers/numbers
`
`(e.g., [1234], [56], [789]) that are stored in separate places in memory. As Schull
`
`expressly discloses that the generation of a PasswordableID (i.e., concatenation of
`
`the TargetID, ProgramID, and FeatureID) produces a “longint,” one of ordinary
`
`skill in the art would not simply move these three IDs to contiguous sections of
`
`memory in the form of a linked list, as this approach would not result in the
`
`required “longint” (i.e., a single 32 bit integer that is a whole number ranging from
`
`-2147483648 to +2147483648). Instead, if two bytes were assigned to each
`
`number, as alleged by Dr. DiEuliis, it would result in 3 x 2 = 6 bytes or 48 bits, and
`
`not a 32-bit integer as described by the use of “longint” in Schull. This is an
`
`additional reason as to why Dr. DiEuliis is incorrect in proposing a third approach
`
`for concatenation that is unsupported even by the specification of Schull.
`
`17.
`
`It would be clear to one of ordinary skill in the art that if Schull had
`
`contemplated concatenation through storing three separate numbers in contiguous
`
`
`
`11
`
`Petitioner Ex. 1039 Page 11
`
`
`
`sections of memory or in a “linked list” as Dr. DiEuliis suggests, the result of the
`
`“MakeID” function would not be a single longint.
`
`18.
`
`In the Pascal programming language, a function can return only one
`
`value of a certain format or data type. Appendix A, Turbo Pascal 4.0: Owner’s
`
`Handbook at 57-58, 268-270; Appendix B, Turbo Pascal: Introduction to Pascal
`
`and Structured Design at 70-71, 350-357. The value returned by a function can be
`
`a native or Pascal-defined data type such as an integer number (i.e., longint), a real
`
`number, a character or string, a Boolean, or a Pointer. Appendix A, Turbo Pascal
`
`4.0: Owner’s Handbook at 39-45. If Schull had contemplated concatenation
`
`through storing three separate numbers in contiguous sections of memory or in a
`
`“linked list” as Dr. DiEuliis suggests, the result of the “MakeID” function would
`
`not be a single longint.
`
`19.
`
`In the Pascal programming language, functions are not used when
`
`more than one value must be returned or when the result is a non-native data type
`
`that has to be user-defined (i.e., an array – continuous or otherwise – or a linked
`
`list). Appendix A, Turbo Pascal 4.0: Owner’s Handbook at 214-215; Appendix B,
`
`Turbo Pascal: Introduction to Pascal and Structured Design at 357, 738-760.
`
`Accordingly, one of ordinary skill in the art would not have even considered
`
`storing three numbers in contiguous sections of memory or as a linked list as a
`
`
`
`12
`
`Petitioner Ex. 1039 Page 12
`
`
`
`“normal” way to accomplish concatenation of the Program ID, Feature ID, and
`
`Target ID of Schull.
`
`20. Additionally, a skilled artisan would know that three numbers stored in
`
`contiguous sections of memory are not concatenated (i.e., connected or linked to
`
`“form a single unit”2) because the result is not a single number, much less a single
`
`number of data type “longint,” without additional operations being performed on
`
`the data. Specifically, in order to obtain a single number from 3 separate numbers
`
`stored in memory (either in contiguous sections of memory or as part of a linked
`
`list), a programmer would have to actually concatenate the three numbers into a
`
`single number by either (1) left shifting the original numbers by the appropriate
`
`number of digits (e.g., multiplying by a power of ten) and adding those numbers,
`
`or (2) converting the integers to strings, concatenating the strings, and converting
`
`the result back to an integer. Ex. 1007, Sept. 5, 2014 Madisetti Declaration at
`
`¶¶40-48, which Dr. DiEuliis has not disputed disclose the summation algorithm or
`
`its equivalents.
`
`3.
`
`Contrary to Dr. DiEuliis’s Assertion, Concatenation Using
`Summation Does Not Require Hundreds of Operations
`
`21.
`
`In my declaration dated September 5, 2014, I provide an explanation
`
`for why the concatenation disclosed by Schull would preferably be accomplished
`
`using summation. Ex. 1007 at ¶42. As an example, I note that concatenating three
`
`2 See Dictionary definitions provided in ¶¶79-81 of Ex. 2008.
`
`
`
`13
`
`Petitioner Ex. 1039 Page 13
`
`
`
`integers (X=1234, Y=56, and Z=789) would preferably be accomplished using the
`
`following algorithm: 1234*10^5 + 56*10^3 + 789, which would result in a single
`
`number 123456789. Id. at ¶44. In response, Dr. DiEuliis states that the numbers
`
`“will be processed as binary numbers” and that “[t]his calculation will require
`
`hundreds of addition operations.” Ex. 2008, DiEuliis Declaration at ¶84. To arrive
`
`at his conclusion, Dr. DiEuliis notes that, for this example, the final number
`
`123456789 will ultimately be represented by a 32-bit binary number and that to
`
`perform (1234 x 105), one would need “at least 11 bit shifts (one per bit for the
`
`smaller number except for the first) and 128 binary bit additions (4 additions times
`
`32 bits per addition)” Id. at ¶87. Dr. DiEuliis uses this approach for all the
`
`calculations in the example and arrives at the approximation of 288 bit additions
`
`and that “each bit addition requires the CPU to execute at least one instruction.” Id.
`
`at ¶89. Furthermore, Dr. DiEuliis uses this number (288) to compare to the alleged
`
`6 instructions needed for his proposed version of “concatenation” to conclude that
`
`his method is 48 times faster. Id. at ¶90. However, the efficiency of moving data
`
`to different places in memory is irrelevant and misleading, because, as discussed at
`
`length above, it does not achieve the goal of generating a “passwordable ID” in the
`
`context of Schull.
`
`22. Additionally, contrary to Dr. DiEuliis’s opinion, each bit addition does
`
`not require its own CPU instruction. In fact, there is only one CPU instruction
`
`
`
`14
`
`Petitioner Ex. 1039 Page 14
`
`
`
`needed to add two pieces of data. For example, the MIPS (originally an acronym
`
`for Microprocessor without Interlocked Pipeline Stages) instruction set, describing
`
`the popular MIPS-X Processor used in the MIPS R2000 computer, includes a
`
`“Load” instruction for loading data from memory to a register, an “Add”
`
`instruction for computing the sum of two 32-bit registers and storing the output in
`
`a third register, a “Shift Left” instruction for performing a shift to the left by a
`
`specified number of bits, and a “Store” instruction for storing data from a register
`
`to memory. Appendix C, MIPS-X Instruction Set and Programmer’s Manual at
`
`20-23, 39-40, 43, 55, 75-76; April 11, 1988 edition of InfoWorld at p. 26 (available
`
`for free from Google Books). MIPS is an important example of a widely used and
`
`leading instruction set used to implement algorithms on processors in computers.
`
`Measuring efficiency of an algorithm by number of bit additions is neither
`
`practical nor standard in the industry. A hardware arithmetic unit can perform
`
`dozens of bit-level operations in parallel at the same time while performing a
`
`single operation.
`
`23. A more accurate description of
`
`the summation approach
`
`to
`
`concatenation, in terms of CPU instructions, would include 3 load instructions, 2
`
`shift instructions, 2 addition instructions, and 1 store instruction. The numbers
`
`1234 and 56 require one load operation each (to load each number from memory
`
`into its own register) and one shift instruction each, to create the numbers
`
`
`
`15
`
`Petitioner Ex. 1039 Page 15
`
`
`
`123400000 and 56000. Those shifted values would be added together with one
`
`addition instruction, making 123456000. The number 789 would then be loaded
`
`into a register via one load instruction and added to the previously computed
`
`number with one more addition instruction to result in 123456789. Finally, one
`
`store instruction would be used store the final value in memory. This would
`
`indicate that the operation 1234 x 105 + 56 x 103 + 789 would be about 8 CPU
`
`instructions, which can be performed very fast.
`
`4.
`
`Dr. DiEuliis’s References use Table Lookup Algorithms for
`Checksums that are Summation Algorithms
`
`24.
`
`In the rebuttal to my declaration dated September 5, 2014, where I
`
`state that “all of the methods for calculating check digits utilize some form of
`
`addition” (Ex. 1007 at ¶48), Dr. DiEuliis contends that “[s]ummation is not
`
`inherent in the generation of checksums” because table lookup methods can be
`
`used “to compute checksums without incorporating summation (addition).” Ex.
`
`2008, DiEuliis Declaration at ¶97. As support for his opinion, Dr. DiEuliis relies
`
`on three publications – two of which describe table-driven implementations for
`
`cyclic redundancy check (CRC) error detection algorithms (Ex. 2014 and 2015)
`
`and one that describes a “Fast Hashing” algorithm that uses an exclusive-OR
`
`operation (Ex. 2016). However, in my opinion, these references do not support
`
`Dr. DiEuliis’ opinion, since each of these articles disclose that checksums use
`
`summation algorithms.
`
`
`
`16
`
`Petitioner Ex. 1039 Page 16
`
`
`
`25. The first reference, the Williams article, provides a “simple no-
`
`nonsense explanation of CRCs” where “[t]he basic idea of CRC algorithms is
`
`simply to treat the message as an enormous binary number, to divide it by another
`
`fixed binary number, and to make the remainder from this division the checksum.”
`
`Ex. 2014 at 1-2, 3. The Williams article specifically describes the “CRC
`
`arithmetic” used for CRC calculations as “primarily about XORing particular
`
`values at various shifting offsets” where “both addition and subtraction in CRC
`
`arithmetic is equivalent to the XOR operation” and “[a]dding two numbers in CRC
`
`arithmetic is the same as adding numbers in ordinary binary arithmetic except there
`
`is no carry.” Id. at 6-9. Willaims, thus, confirms that XOR operation is a special
`
`type of addition that is similar to binary arithmetic. Indeed, XOR is known to one
`
`of ordinary skill in the art as a type of modulo addition operation.
`
`26. According to Williams, the CRC algorithm implements division using
`
`CRC arithmetic where the algorithm performs a series of left shifts and XOR
`
`operations. Id. at 12-13. Williams discloses that while “most of the calculation can
`
`be precomputed and assembled into a table,” the “main loop” of the CRC
`
`algorithm still requires left shifting and XOR operations (i.e., summation as noted
`
`above). Id. at 15. Furthermore, like the MD5 algorithm (that also uses “left
`
`shifting” and is referred to as a “checksum”) that the Federal Circuit found to be
`
`fairly capable of being categorized as summation, the Williams CRC algorithm
`
`
`
`17
`
`Petitioner Ex. 1039 Page 17
`
`
`
`uses left shifting and addition and therefore is also fairly capable of being
`
`categorized as summation. See, e.g., Ex. 1010, Federal Circuit Opinion dated Jan.
`
`11, 2011 at 16-21.
`
`27. Further, a lookup table, if used, only precomputes the checksum (using
`
`a summation algorithm), and does not convey to one of ordinary skill in the art that
`
`a summation algorithm was not used.
`
`28. For these reasons above, I disagree with Dr. DiEuliis. Williams does
`
`disclose summation algorithms in the computation of the CRC checksums.
`
`29. The second reference cited by Dr. DiEuliis, the Geremia article,
`
`discloses a software implemenation of a CRC algortihm that (again, like Williams)
`
`performs a series of shifts and XOR operations. Ex. 2015 at 6, 7. Dr. DiEuliis
`
`contends that “[a] person of ordinary skill in the art understands that TI’s [(Texas
`
`Instruments’ or Geremia’s)] description is consistent with table lookup alogrithms,
`
`which store the results of pre-computations in a table so that the algorithm need
`
`only search for the entry that is appropriate for the data being processed.” Ex.
`
`2008, DiEuliis Declaration at ¶99. I disagree. Both Geremia and Williams
`
`disclose that a table of values is precomputed (using summation algorithms or
`
`XOR operations). Ex. 2015 at 7, Ex. 2014 at 15. However, both Geremia and
`
`Williams disclose that, in addition to finding a corresponding value in a lookup
`
`table the algorithm still requires shifting and XOR operations (i.e., summation).
`
`
`
`18
`
`Petitioner Ex. 1039 Page 18
`
`
`
`See, e.g., Ex. 2015 at 7 (Step 2: “XOR the α input bits with the CRC register
`
`content shifted right by n-k-α bits” and Step 3: “find the corresopnding value in the
`
`lookup table and XOR the CRC register content shifted left by α bits”); Ex. 2014 at
`
`15 (Step 1: “shift the register left by one byte”; Step 2: “Use the top byte just
`
`rotated out of the register to index the table of 256 32-bit values”; and Step 3:
`
`“XOR the table value into the register”).
`
`30. Therefore, Dr. DiEuliis has not established that the Geremia reference
`
`does not disclose a summation algorithm. It uses the XOR operation (like
`
`Williams) and the precomputed lookup table clearly discloses the use of
`
`summation algorithms to one of ordinary skill in the art.
`
`31. Finally, Dr. DiEuliis relies on the Pearson article to support his opinion
`
`that checksums do not disclose a summation algorithm. However, the Pearson
`
`article describes a “Fast Hashing” algorithm that uses an explicit XOR operation as
`
`noted below:
`
`Ex. 2016 at 1.
`
`
`
`32. As noted by Pearson, “the processing of each additional character of
`
`text requires only an exclusive-OR operation and an indexed memory read.” Ex.
`
`
`
`19
`
`Petitioner Ex. 1039 Page 19
`
`
`
`2016 at 1 (emphasis added). An exclusive-OR operation is a logical operation that
`
`is equivalent to adding numbers in ordinary binary arithmetic and discarding the
`
`carry and is referred to as modulo-2 addition. See, e.g., Ex. 2014 at 6-9, Ex. 2015
`
`at 5. Accordingly, it is my opinion that the Pearson Fast Hashing algorithm, which
`
`relies heavily upon the exclusive-OR operation, is also fairly capable of
`
`categorization as a summation algorithm.
`
`33. Furthermore, I also note that Dr. DiEuliis fails to provide any
`
`explanation for how or why one of skill in the art reading Schull would consider
`
`using the hashing algorithm described in Pearson. In my opinion, one of skill in the
`
`art would not consider Pearson’s Hashing Algorithm as a way to compute Schull’s
`
`checksums. Pearson describes “a hashing function specifically tailored to variable-
`
`length text strings” “in the absence of prior knowledge about the strings being
`
`hashed.” Ex. 2016 at 1 (emphasis added). As Schull clearly describes appending a
`
`two or more digit checksum to fixed-length numbers, e.g., to a number with
`
`N+M+T digits (i.e., an integer), one of skill in the art would not look to Pearson’s
`
`hashing algorithm for computing checksums of complex text strings of unknown
`
`length. See, e.g., Ex. 1002, Schull at 7:22-36. Pearson also discloses that the
`
`variable-length text strings are “map[ped] onto integers that are spread as
`
`uniformly as possible over the intended range of output values.” Ex. 2016 at 1. In
`
`my opinion, there is no reason to map Schull’s fixed length integer onto randomly
`
`
`
`20
`
`Petitioner Ex. 1039 Page 20
`
`
`
`generated integer output values, as taught by Pearson, for the purpose of
`
`computing a simple checksum. This is illogical and unreasonable to one of
`
`ordinary skill in the art.
`
`34. Further, Pearson, acknowledges that one of the “main advantages” of
`
`the disclosed Hashing Algorithm is that “very little arithmetic is performed on each
`
`character being hashed.” Ex. 2016 at 4. Notably, the author admits that some
`
`arithmetic is performed, and this is confirmed by the express disclosure of the
`
`XOR operation, as noted above.
`
`35. Not surprisingly, the Pearson reference acknowledges an “alternative”
`
`hashing algorithm that “is suspected to be widely used” and also clearly includes
`
`summation:
`
`
`Ex. 2016 at 2. Pearson describes this function as an “additive hashing function”
`
`where “addition [of this function] being commutative.” Id; see also id. at 3 (longer
`
`range of hash values implementation includes step of “Add 1 (modulo 256) to the
`
`first character of the string” and permuted index space implementation includes
`
`step of “repeatedly incrementing the first character of the input string, modulo
`
`
`
`21
`
`Petitioner Ex. 1039 Page 21
`
`
`
`256”). In summary, all the algorithms disclosed for hashing in Pearson disclose a
`
`summation algorithm.
`
`36.
`
`It is my opinion that Dr. DiEuliis has not provided correct support for
`
`his opinions, and the three references he relies on expressly disclose a summation
`
`algorithm to one of ordinary skill in the art.
`
`III. CONCLUSION
`37.
`I declare that all statements made herein of my knowledge are true, and
`
`that all statements made on information and belief are believed to be true, and that
`
`these statements were made with the knowledge that willful false statements and
`
`the like so made are punishable by fine or imprisonment, or both, under Section
`
`1001 of Title 18 of the United States Code.
`
`
`
`Date:
`
`Sep 16, 2015, Atlanta
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`_ ___________________________
`By:
`Vijay K. Madisetti
`
`22
`
`
`
`
`
`
`
`Petitioner Ex. 1039 Page 22
`
`
`
`Petitioner Ex. 1039
`Appendix A Page 1
`
`
`
`TURBO PASCAL®
`
`Owner’s Handbook
`
`Borlond Inferndrional
`4585 Scofis VoHey Drive
`Scofis Vcmey. CA 05066
`
`Petitioner Ex. 1039
`Appendix A Page 2
`
`
`
`This manual was produced in its entirety with
`Sprint:“’ The Professional Word Processor,
`available from Borland.
`
`Ber
`not
`ml
`witi
`
`Purl
`inch
`
`
`
`Ali Boriand Droducis are frcrderrrcrrks Or registered Trademarks of
`Borlond Inierr-oiiohor. Ene. or Borlcrrra‘/Arrolyrico. inc Oiher brand and producr
`no-fines cure rrodemorks or regisrored rrodemcrrks of their respective hoéders
`CO,DyrighT ©1987 BOr|Or‘d Iniernoironoi
`
`Copyrighi ©1087
`All righis reserved
`Primed in The LJ.S.r’\.
`
`10’~?-87652132‘
`
`Petitioner Ex. 1039
`
`Appendix A Page 3
`
`Petitioner Ex. 1039
`Appendix A Page 3
`
`
`
`
`
`Table of Contents
`
`Introduction
`
`1
`
`. 2
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`.
`. . .
`.
`.
`. . .
`.
`.
`.
`.
`.
`Understanding 4.0 .
`. . .2
`.
`.
`.
`.
`. . .
`Integrated Environment
Accessing this document will incur an additional charge of $.
After purchase, you can access this document again without charge.
Accept $ Charge
Still Working On It
This document is taking longer than usual to download. This can happen if we need to contact the court directly to obtain the document and their servers are running slowly.
Give it another minute or two to complete, and then try the refresh button.
A few More Minutes ... Still Working
It can take up to 5 minutes for us to download a document if the court servers are running slowly.
Thank you for your continued patience.
This document could not be displayed.
We could not find this document within its docket. Please go back to the docket page and check the link. If that does not work, go back to the docket and refresh it to pull the newest information.
Your account does not support viewing this document.
You need a Paid Account to view this document. Click here to change your account type.
Your account does not support viewing this document.
Set your membership
status to view this document.
With a Docket Alarm membership, you'll
get a whole lot more, including:
- Up-to-date information for this case.
- Email alerts whenever there is an update.
- Full text search for other cases.
- Get email alerts whenever a new case matches your search.
One Moment Please
The filing “” is large (MB) and is being downloaded.
Please refresh this page in a few minutes to see if the filing has been downloaded. The filing will also be emailed to you when the download completes.
Your document is on its way!
If you do not receive the document in five minutes, contact support at support@docketalarm.com.
Sealed Document
We are unable to display this document, it may be under a court ordered seal.
If you have proper credentials to access the file, you may proceed directly to the court's system using your government issued username and password.
Access Government Site
