`
`
`
`
`
`
`
`UNITED STATES PATENT AND TRADEMARK OFFICE
`
`____________________
`
`BEFORE THE PATENT TRIAL AND APPEAL BOARD
`
`____________________
`
`
`APPLE INC.,
`TWITTER, INC., AND YELP INC.,
`Petitioners,
`
`v.
`
`EVOLUTIONARY INTELLIGENCE LLC
`Patent Owner.
`
`____________________
`
`Inter Partes Review No. IPR2014-00086
`Inter Partes Review No. IPR2014-00812
`
`____________________
`
`
`Supplemental Declaration of Henry Houh Regarding
`U.S. Patent No. 7,010,536
`
`
`Apple, Yelp, & Twitter v. Evolutionary Intelligence
`IPR2014-00086 & IPR2014-00812
`Petitioner Apple, Ex. 1009, p. i
`
`
`
`
`
`I, Henry Houh, do hereby declare and state, that all statements made herein of my
`
`own knowledge are true and that all statements made on information and belief are
`
`believed to be true; and further 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.
`
`
`
`
`
`
`
`
`
`Dated: October 27, 2014
`
`
`
`
`
`
`
`Henry Houh
`
`
`
`
`
`
`
`
`
`
`
`
`Petitioner Apple, Ex. 1009, p. ii
`
`
`
`
`
`
`
`Table of Contents
`
`Table of Contents ................................................................................................... iii
`
`I.
`
`Introduction .......................................................................................................... 1
`
`II. Analysis ............................................................................................................... 1
`
`A. Background ....................................................................................................... 1
`
`B. The ’536 Specification Describes Many Types of “Containers” ..................... 5
`
`C. Gibbs Discloses a “Plurality of Containers” ..................................................10
`
`D. Gibbs Warning Criteria. .................................................................................18
`
`E. New Claim Construction Issues .....................................................................21
`
`1. “First Register Having a Unique Container Identification Value” .............21
`
`2. “Neutral Space Register”.............................................................................24
`
`
`
`
`
`
`
`Petitioner Apple, Ex. 1009, p. iii
`
`
`
`
`
`I.
`
`Introduction
`
`1.
`
`I have been retained by counsel for Apple Inc. (“Apple”) as an expert
`
`witness in the above-captioned proceeding. I was asked to provide my opinion
`
`about the state of the art of the technology described in U.S. Patent No. 7,010,536
`
`(“the ’536 patent”) and on the patentability of claims 2-14, and 16 of the ’536
`
`patent. I submitted a written declaration on these topics, which was filed as
`
`Exhibit 1003 (“First Declaration or Ex. 1003”). I also provided testimony in this
`
`proceeding, which was filed as Exhibit 1008.
`
`2.
`
`I have been asked to review information provided in the proceeding
`
`after I provided my earlier filed Declaration (Exhibit 1003) and offer my views on
`
`that information. In particular, I have reviewed the Patent Owner’s Response to
`
`the Petition (Paper No. 20), as well as the accompanying Declaration (Exhibit
`
`2006) and deposition testimony of Matthew Green (Exhibit 2009).
`
`3. My opinions are based on my years of education, research and
`
`experience, as well as my investigation and study of relevant materials.
`
`II. Analysis
`
`A. Background
`
`4.
`
`After reviewing Patent Owner’s Response to the Petition, the
`
`Declaration of Matthew Green, and the deposition testimony of Matthew Green,
`
`my opinions in my First Declaration have not changed. I also offer the following
`
`Petitioner Apple, Ex. 1009, p. 1
`
`
`
`
`
`additional observations based on statements that Dr. Green or the Patent Owner
`
`made in their documents.
`
`5.
`
`It appears that Patent Owner is attempting to create confusion in the
`
`record about what I identified in the Gibbs reference (Ex. 1006) as corresponding
`
`the claimed “plurality of containers” in the ’536 patent. E.g., P.O. Resp. at 22-24,
`
`29-36, 54-56; Ex. 2006 (Green Dec.) at ¶¶ 127-29. I am submitting this
`
`declaration to dispel that confusion.
`
`6.
`
`In addition, I am addressing a number of additional topics raised by
`
`Patent Owner and Dr. Green about the Gibbs (Ex. 1006) reference, as well as the
`
`Patent Owner's statements suggesting new or additional interpretations of terms in
`
`the claims. I address these new issues at the end of this declaration.
`
`7.
`
`To provide a little background, Gibbs describes a railroad
`
`management system, where each end-user has a personal computer running a
`
`software package that allows that user to generate maps and reports about the train
`
`system. The software package is written using an object-oriented software design
`
`scheme.
`
`8.
`
`In object-oriented software design, the components of an application
`
`are represented using objects. In the Gibbs system, this means that the items from
`
`the real world train system are represented as transport objects; the maps and
`
`reports that a user can generate are represented by map objects and report objects,
`
`Petitioner Apple, Ex. 1009, p. 2
`
`
`
`
`
`and the user interface component of the system is represented as the context menu
`
`object. Each of these “objects” encapsulates a variety of data and methods for
`
`accessing those data.
`
`9.
`
`Patent Owner offers a similar description of the Gibbs system. See
`
`P.O. Resp. at 10-13.
`
`10. Gibbs shows that, when the system is running on a particular
`
`computer, the instantiated objects from the transport, map, and report libraries
`
`interact to enable an end-user to obtain data about the railroad system. See, e.g.,
`
`Ex. 1006 (Gibbs) at Fig. 8a, 9b, 4:18-37, 22:25-47; Ex. 1003 at ¶¶ 73, 79, 94, 99-
`
`102, 122, 138. In particular, when the Gibbs software is running, the map and
`
`report objects include routines for collecting data from each of the transport objects
`
`that meet user defined criteria and for generating output (e.g., a report or a map)
`
`containing those data for display to the user. See, e.g., Ex. 1006 (Gibbs) at 8:53-
`
`63, 9:31-40, 13:13-23; Ex. 1003 at ¶¶ 90, 95, 97.
`
`11.
`
`In my analysis, I have focused on the instances of the objects in a
`
`running system, as opposed to just the code libraries. This is because while the
`
`code libraries contain the software routines that are used to build the objects, the
`
`libraries themselves do not contain any data from the railroad system. When the
`
`software is executed on a user’s workstation, it uses the code libraries to create
`
`instances of the objects, and these objects acquire and store data about the railroad
`
`Petitioner Apple, Ex. 1009, p. 3
`
`
`
`
`
`system, about other objects, and from the user. This is how software
`
`conventionally works, and a person of ordinary skill in the art would understand
`
`that.
`
`12.
`
`In my First Declaration and at my deposition, I explained that the
`
`Gibbs system shows a “container” that is a collection of instantiated objects used to
`
`generate maps and reports in a running TWS workstation. Patent Owner’s counsel
`
`did not like my description of the claimed “container” and pushed me to adopt a
`
`short-hand description, as the extended quote on pages 31-34 of Patent Owner’s
`
`Response shows. In response to the many requests made by Patent Owner’s
`
`counsel for a more convenient term to use at the deposition, I described this
`
`collection of objects as the transport object, map object, report object subsystem, or
`
`“TMR subsystem.”
`
`13.
`
`It appears that Patent Owner is now arguing that I have changed my
`
`opinion because the term “TMR subsystem” did not appear in my original report.
`
`P.O. Resp. at 2-3. Of course, that term does not appear in my First Declaration
`
`because I adopted that term for the convenience of Patent Owner’s counsel during
`
`my deposition.
`
`14.
`
`I have not changed my opinion. As I explained in my First
`
`Declaration, the instantiated transport, map, and report objects interact to create
`
`maps and reports for display to an end-user. E.g., Ex. 1003 at ¶¶ 86-98, 109, 122.
`
`Petitioner Apple, Ex. 1009, p. 4
`
`
`
`
`
`When instantiated (i.e., when running in an instance of the software on a user's
`
`workstation), all of these objects are present and in memory, and perform the
`
`operations I previously explained. This was clear from my previous explanation.
`
`15.
`
`I also note that the Patent Owner is now suggesting that I have
`
`changed my opinion because I previously explained that Gibbs describes many
`
`different “containers” within the meaning of the ’536 patent, and some of those
`
`containers do not include every register specified in claims 2 and 16 and of the
`
`’536 patent. This again mischaracterizes my previous statements in my First
`
`Declaration and in my deposition.
`
`16.
`
`I also note that Patent Owner’s argument appears to be based on a
`
`misunderstanding of its own patent specification. The Patent Owner's
`
`interpretation suggests that a container cannot comprise a set of discrete entities.
`
`P.O. Resp. at 38-39. This definition of a “container” would exclude examples of
`
`the invention as it is described in the ’536 patent specification.
`
`17. Below, I address the ’536 specification’s description of what a
`
`“container” is and can be, before turning to the Gibbs reference. I address several
`
`additional topics raised by Patent Owner at the end.
`
`B.
`
`The ’536 Specification Describes Many Types of “Containers”
`
`18. Patent Owner and Dr. Green argue that Gibbs cannot disclose a
`
`“container” that encapsulates multiple types of objects because Gibbs describes
`
`Petitioner Apple, Ex. 1009, p. 5
`
`
`
`
`
`each object as being a discrete entity. P.O. Resp. at 38-39; Ex. 2006 (Green Dec)
`
`at ¶¶ 154-55. The apparent premise of Patent Owner’s argument is that a
`
`“container” cannot encapsulate other containers.
`
`19. To support its argument, Patent Owner presents several isolated
`
`quotes from the ’536 specification that state that one embodiment of a container is
`
`an “interactive nestable logical domain.” Ex. 1001 at 3:28-35, 4:46-53; see P.O.
`
`Resp. at 7 (citing Ex. 1001 (536) at 3:29-35), 39 (“‘Nesting,’ as used by the ’536
`
`patent, is present only when a container includes ‘the logical description of another
`
`container.’” (quoting Ex. 1001 (536) at 9:4-9)); Ex. 2006 (Green Dec) at ¶¶ 156-
`
`58. Patent Owner then suggests that this means a “container” cannot encapsulate a
`
`set of containers.
`
`20. Patent Owner’s argument cannot be squared with the ’536
`
`specification. Throughout the specification, “containers” are described as being
`
`able to encapsulate sets of other containers. For example, as I explained in ¶ 54 of
`
`my First Declaration, the '536 patent specification states that a container can
`
`encapsulate another container or “sets of containers.” Ex. 1001 (536) at 8:64-9:2.
`
`This configuration is also depicted in Figures 3A and 3B of the ’536 patent, which
`
`show a container that is encapsulating several nested containers. See also Ex. 1001
`
`(536 patent) at 12:13-22. As another example, the ’536 specification states that
`
`Petitioner Apple, Ex. 1009, p. 6
`
`
`
`
`
`“Any container may include (n) other containers, to infinity.” Ex. 1001 (536) at
`
`12:45-46.
`
`21. The ’536 specification also explains that each container has a set of
`
`“registers,” which contain values or code that are used to govern the interaction of
`
`that container within other containers, systems, and processes. E.g., Ex. 1001
`
`(536) at 9:13-22.
`
`22. The ’536 specification explains that its system that can include many
`
`different types of “containers.” For example, the '536 specification explains that
`
`there can be multiple “classes” or types of containers in the system, and each
`
`container does not need to have the same registers. Ex. 1001 (536) at 3:47-48
`
`(“Containers and registers, upon creation, may be universal or class-specific.”),
`
`4:26-28 (“determining the set, class and range of containers upon which that
`
`container will act”), 13:1-7, 16:1-3.
`
`23. The '536 patent specification also describes a container as a dynamic
`
`structure, and that each container’s registers can be added, removed, or changed.
`
`E.g., Ex. 1001 (536) at 3:47-56, 9:63-67 (“container editor 110 for creating,
`
`selecting, acquiring, modifying and appending registers 120 and gateways 200 to
`
`containers 100”), 13:14-20 (“Registers 120 are also unique in that they can interact
`
`with any register of a similar definition on any container 100 residing on the
`
`network 201, independent of that container's contents. Registers 120, once
`
`Petitioner Apple, Ex. 1009, p. 7
`
`
`
`
`
`constructed, may be copied and appended to other containers 100 with their
`
`internal values reset, to form new containers.”).
`
`24. According the ’536 patent, this hierarchical design enables many of
`
`the beneficial searching and evolutionary features of the invention. E.g., Ex. 1001
`
`(536) at 2:13-18, 5:6-11, 5:28-31.
`
`25.
`
`It is odd that Patent Owner would try to deny its invention does not
`
`include a feature that is described throughout its specification – namely, the ability
`
`of containers to both to be nested within other containers and to have different sets
`
`of registers that registers can be added, deleted and modified containers as the
`
`system is operating.
`
`26. Patent Owner also suggests that containers will contain other
`
`containers only in several limited situations mentioned in its patent. In particular,
`
`the Patent Owner appears to suggest that containers will contain other containers
`
`only when the patent uses the word “nesting.” See P.O. Resp. at 39 (quoting Ex.
`
`1001 (536) at 9:4-9).(“‘Nesting,’ as used by the ’536 patent, is present only when a
`
`container includes ‘the logical description of another container.’”).
`
`27. This is not an accurate description of what the '536 patent says. While
`
`including a “logical description” of another container is one way of encapsulating
`
`other containers, it is not the only way the '536 patent says a container can
`
`encapsulate other containers.
`
`Petitioner Apple, Ex. 1009, p. 8
`
`
`
`
`
`28. The '536 patent specification explains that “containers” are a
`
`“logically defined data enclosure.” Ex. 1001 (536) at 8:64-65. Dr. Green has
`
`explained that a logically defined data enclosure means that the data enclosure is
`
`simply defined by a “software mechanism.” Ex. 2006 at ¶ 35. That definition is
`
`consistent with my understanding of the phrase, and I believe it is consistent with
`
`the broadest reasonable interpretation of the term “container” in view of the
`
`specification.
`
`29. A person of ordinary skill in the art would understand that a “logically
`
`defined data enclosure” (or a data enclosure defined by a “software mechanism”)
`
`covers more than just a “logical description” of a container. For example, a logical
`
`data enclosure would include a system process, an execution stack (the memory
`
`allocated to a running software application), contiguous blocks of physical
`
`memory, a file structure or file header, various instances of object-oriented
`
`programming design concepts (e.g., a class interface, polymorphic object, or object
`
`with inheritance), amongst others.
`
`30.
`
`I understand that the Board interpreted the word “container” to mean
`
`“a logically defined data enclosure which encapsulates any element or digital
`
`segment (text, graphic, photograph, audio, video, or other), or set of digital
`
`elements.” Decision at 9. I believe the Board’s construction accurately describes
`
`Petitioner Apple, Ex. 1009, p. 9
`
`
`
`
`
`the broadest reasonable construction of the term “container” that is consistent with
`
`the '536 specification.
`
`31.
`
`I note that the Board’s construction means that containers can be
`
`nested, as it provides that one container can encapsulate a “set of digital elements”
`
`(e.g., a set of other containers). The Board’s construction also means that to be a
`
`“container,” a data structure does not need to possess any specific registers – it just
`
`needs to be a logically defined data enclosure that encapsulates data.
`
`C. Gibbs Discloses a “Plurality of Containers”
`
`32. As I explained in my First Declaration, a user of the Gibbs system
`
`accesses data about the railroad system by instructing the software to generate
`
`maps and reports about the system. The user will initiate this process by
`
`interacting with the context menu object (“CMO”). The user will select map
`
`boundaries and other criteria, and these criteria will be passed to a map object for
`
`processing. The CMO also will pass the data to a report object so any selected
`
`reports are created as well. E.g., Ex. 1006 (Gibbs) at 8:20-31, 8:53-63; Ex. 1003 at
`
`¶¶ 88-90.
`
`33. As I explained throughout my First Declaration, when the Gibbs
`
`system is in operation, the software will create specific instances of the transport,
`
`map, and report objects. The instantiated map and report objects respond to
`
`requests from a user to create maps and reports about the system, by collecting the
`
`Petitioner Apple, Ex. 1009, p. 10
`
`
`
`
`
`relevant instances of the transport objects and generating depictions of all the
`
`objects for display to the user. E.g., Ex. 1003 at ¶¶ 90 (“Each map object contains
`
`routines and program which collect data from other objects in the system in order
`
`to generate a map requested by the user”), 92 (“This map object is used to generate
`
`a map of the railroad transportation network, which includes a representation of the
`
`railroad infrastructure within a user-selected area”), 94, 96-97, 104 (“Both the map
`
`and report objects monitor a set of warning criteria for the various transport objects
`
`which are included in the selected maps and reports.”).
`
`34. Gibbs shows that when generating a requested map, the map object
`
`determines which transport objects are within the selected boundaries, collects the
`
`unique ID and other data from each transport object, and then uses that data to
`
`generate a map that is displayed to a user. Ex. 1003 at ¶¶ 92-93; see also Ex. 1006
`
`at Figs. 9a-9c (flowcharts of process for building and displaying maps and reports),
`
`13:13-61, 21:55-65, 22:2-12, 22:23-55 (describing the same). The report object
`
`will follow the same process. Ex. 1003 at ¶¶ 96-97; see also Ex. 1006 at 9:31-40,
`
`13:13-61, 16:31-33, 21:39-45 (“Referring now to FIG. 9a, a flowchart of a
`
`preferred method for object based railroad transportation network management is
`
`shown. The preferred method is preferably the same for each map object (400
`
`through 412) or report object (414 through 420) regardless of which map object
`
`(400 through 412) or report object (414 through 420) is generating an output
`
`Petitioner Apple, Ex. 1009, p. 11
`
`
`
`
`
`display.”). When these processes finish, the result is a set of maps and reports that
`
`are displayed on an output device. Id. at ¶¶ 91, 94, 98; e.g., Ex. 1006 (Gibbs) at
`
`Fig. 8a. The displayed output reflects the selected maps and reports, and it depicts
`
`the instantiated transport objects, map objects, and report objects.
`
`35. This collection of instantiated objects can clearly be seen in Figure 8a
`
`of Gibbs. See Ex. 1003 at ¶¶ 91-95.
`
`Petitioner Apple, Ex. 1009, p. 12
`
`
`
`
`
`36. The set of instantiated objects in the Gibbs system that is used to
`
`
`
`generate the maps and reports is the “container” specified in claim 2. E.g., Ex.
`
`1003 at ¶¶ 109 (“The railroad management system also uses objects to display and
`
`transmit information to the user, such as through maps and reports.”), 122 (“The
`
`transport objects interact with the map and report objects to display
`
`information . . .”), 126, 128, 138 (“Gibbs describes instances in which transport,
`
`Petitioner Apple, Ex. 1009, p. 13
`
`
`
`
`
`map, and report objects intersect.”), 141-43 (“The map and report objects also
`
`contain program instructions and routines. These instructions and routines are used
`
`to gather information from the various transport objects in order to generate and
`
`modify maps and reports for the user.”).
`
`37. The instantiated transport, map, and report objects are treated by the
`
`processing unit within an object-oriented programming structure as conventionally
`
`known in the art. Ex. 1003 at ¶¶ 78, 88, 89 (emphasis added) (citing Ex. 1006 at
`
`7:24-27, 8:48-53). I understand this object-oriented structure, as would anyone
`
`with ordinary skill in the art, to mean that each object is instantiated as part of a
`
`logical data structure in the system as it is operating. In addition, Gibbs shows that
`
`the software keeps track of all the instantiated objects, and will iterate through the
`
`objects as part of building maps and reports for display to a user. See ¶¶ 43-48,
`
`below.
`
`38. Because I described this collection of instantiated objects as the
`
`“TMR subsystem” at my deposition, Patent Owner now suggests I have offered a
`
`new opinion. My opinion is not new. As explained in the preceding paragraphs
`
`(¶¶ 10-15, 32-37), I previously described this collection of instantiated objects
`
`created when the Gibbs system is in operation in my analysis of the Gibbs the
`
`patent, (e.g., Ex. 1003 at ¶¶ 90, 92, 94, 96-97, 104), and I identified the collection
`
`Petitioner Apple, Ex. 1009, p. 14
`
`
`
`
`
`of objects as the claimed “container” in my comparison of the Gibbs patent to
`
`claim 2 of the ’536 patent, (id. at ¶¶ 109, 122, 126, 128, 138, 141-43).
`
`39. Patent Owner also appears to be confusing two different aspects of my
`
`prior analysis. See P.O. Resp. at 54-56. I had explained in my First Declaration
`
`that claim 2 of the ’536 patent specifies an apparatus that comprises a “plurality of
`
`containers” where each container includes a number of registers. I also explained
`
`that dependent claim 8 (and independent claim 16) specifies that each of the
`
`plurality of containers include an “acquire register” for adding “a register from
`
`other containers or add[ing] a container from other containers.” Claim 8 specifies
`
`only that a register or another container is acquired – it places no limitations on the
`
`types of registers that container must have.
`
`40.
`
`In my First Declaration, I explained that Gibbs discloses another set of
`
`containers. I explained that the individual transport objects, map objects, and
`
`report objects in Gibbs are each a “container” within the meaning of the ’536
`
`patent. I explained that when generating maps and reports for display to a user, the
`
`Gibbs system builds the output by collecting all the relevant objects. E.g., Ex.
`
`1003 at ¶¶ 159-61.
`
`41. The individual transport objects, map objects, and report objects are
`
`containers because each is a logically defined enclosure that encapsulates data. Dr.
`
`Green agrees that the objects can be “containers.” See Ex. 2009 (Green Dep. Tr.)
`
`Petitioner Apple, Ex. 1009, p. 15
`
`
`
`
`
`at 162:5-9, 164:8-18 (agreeing that each object contains data “encapsulated within
`
`a data structure”).
`
`42. As I explained above and in my First Declaration, Gibbs shows that,
`
`when generating the maps and reports, each map or report will collect all the
`
`relevant transport objects. This process can be seen in Figures 9a and 9b. See Ex.
`
`1006 (Gibbs) at 9a-9c, 8:53-63, 21:49-65, 22:2-12, 22:23-55; Ex. 1003 at ¶¶ 102-
`
`06.
`
`43.
`
`In Figure 9a, Gibbs shows that a map object iterating through the
`
`transport objects and determining whether each object is within the boundaries set
`
`by a user. Ex. 1006 (Gibbs) at 9a, 8:53-63, 12:49-61, 21:39-65, 22:2-12. If the
`
`transport object is within the boundaries, that object is added to the map. Id.; see
`
`Ex. 1003 at ¶¶ 90-95. To add the object to the map, Gibbs shows that the map
`
`object collects the unique IDs of transport objects that should be displayed on the
`
`map. Ex. 1006 (Gibbs) at 9a (steps 604 & 608), 21:55-65, 22:2-12; see Ex. 1003 at
`
`¶¶ 90, 96-97, 159-61. It also “obtain[s] and retain[s]” the data from each
`
`individual transport object. Ex. 1003 at ¶ 90 (quoting Ex. 1006 (Gibbs) at 8:53-
`
`63).
`
`44.
`
`In this process, the individual transport object (“containers”) are
`
`added to the display list by collecting their unique IDs. The unique IDs are an
`
`example of a “logical description” of a container that is described in the ’536
`
`Petitioner Apple, Ex. 1009, p. 16
`
`
`
`
`
`patent, and the list of unique IDs would be a logical data enclosure. Therefore, the
`
`objects are “acquired” into the generated maps and reports.
`
`45. The other way objects are added to the map is by “obtaining and
`
`retaining” the data from each individual transport object. Ex. 1006 (Gibbs) at
`
`8:53-63; see Ex. 1003 at ¶¶ 90, 96-97, 159-61. I note that Dr. Green agrees that the
`
`map object obtains data from the relevant transport objects and stores it. Ex. 2009
`
`(Green Dep. Tr.) at 228:16-229:11. The map object stores the data that is collected
`
`from the transport objects, which would be an example of “acquiring” “registers”
`
`from another container.
`
`46. That these objects are acquired into a logically defined data enclosure
`
`can be seen in Figure 9b. In Figure 9b, Gibbs shows a map object iterating through
`
`all the transport objects within the map boundaries to determine if the transport
`
`object satisfies warning criteria. To be able to iterate through those objects, the
`
`Gibbs system is able to determine which items are within the maps boundaries.
`
`See Ex. 1003 at ¶¶ 102-06.
`
`47. Patent Owner argues that my opinion is based on inherency, and that I
`
`did not mention any “inherent” features of Gibbs in my First Declaration. P.O.
`
`Resp. at 38. Patent Owner has mischaracterized my opinion.
`
`48. The Gibbs patent discloses that each TWS workstation maintains a set
`
`of instantiated transport objects, map objects, and report objects. There are
`
`Petitioner Apple, Ex. 1009, p. 17
`
`
`
`
`
`multiple TWS workstations running the Gibbs software, allowing users to generate
`
`multiple maps and reports. These disclosures are explicitly described in the Gibbs
`
`patent, and I pointed them out in my First Declaration. Ex. 1003 at ¶¶ 71-72, 88-
`
`90; see Ex. 1006 at Fig. 2, 6:32-39, 8:20-63. While Gibbs does not give these
`
`collections of instantiated objects a name, that doesn’t mean they aren’t there.
`
`Instead, as I explained in my First Declaration, a person of ordinary skill in the art
`
`would understand that Gibbs discloses creates this set of instantiated objects when
`
`it is in operation, and would recognize they are containers within the meaning of
`
`the claims in the ’536 patent.
`
`D. Gibbs Warning Criteria.
`
`49. Dr. Green states that Gibbs does not show an example where warning
`
`criteria are based on space data. Ex. 2006 (Green Dec.) at ¶¶ 165-68. Although
`
`Dr. Green recognizes that Gibbs provides that a user can instruct the system to
`
`monitor “any selected map or report data item,” he suggests that the physical
`
`location of a train is not a map or report data item apparently because he believes
`
`there are no specific examples in Gibbs showing use of this space data.
`
`50. Gibbs states the system can monitor “any selected map or report data
`
`item,” Ex. 1006 at 12:36-41, and a train’s physical location is clearly a data item
`
`on a map. There are many possible uses for monitoring such data, such as to avoid
`
`Petitioner Apple, Ex. 1009, p. 18
`
`
`
`
`
`“the high costs associated with late trains, unavailable locomotives and empty cars,
`
`just to name a few.” Id. at 2:31-35.
`
`51.
`
`In addition, Dr. Green’s premise – that Gibbs does not show examples
`
`where the system monitors an object’s physical location – is simply wrong. In the
`
`example of showing how the system determines whether trains are late, Gibbs
`
`shows that the system will retrieve each object’s location and use it to determine
`
`whether the train is on time or late.
`
`52.
`
`I reviewed Dr. Green’s deposition transcript, and I see that he refused
`
`to admit that a train’s location had anything to do with whether the train was late.
`
`Ex. 2009 (Green Dep. Tr.) at 260:15-261:18. Dr. Green’s answers are illogical.
`
`The Gibbs patent plainly shows that the system is using the train’s location to
`
`determine if a particular train is late or not – the actual location of the train relative
`
`to its anticipated or expected location (e.g., based on its anticipated arrival time) is
`
`what determines if it is “late.” Ex. 1006 at 9:60-62 (“The data structure 98
`
`comprises a first data field for storing the transport object's (70 through 89)
`
`locational attributes 100”) (emphasis added); 9:67-10:4 (“The actual data items
`
`that the transport objects (70 through 89) store within each of the data fields 100,
`
`102, 104, 106 and the data items retrieved to effect the maps in the map object
`
`library 92 and the reports in the report object library 96 is described in detail
`
`below.”); 12:36-41 (“To generate an alert, the map object (400 through 412) or the
`
`Petitioner Apple, Ex. 1009, p. 19
`
`
`
`
`
`report object (414 through 420) prompts the user to specify a value or range of
`
`values for any selected map or report data item, preferably coinciding with the
`
`data item's nominal or expected performance.) (emphasis added); 13:46-57 (“To
`
`generate a map showing which trains are late, the train map object 404 first
`
`prompts the user to select a first variable "A" for those trains that are more than
`
`"A" hours late, a second variable "B'" for those trains that are less than "B" hours
`
`late. The train map object 404 then compares these timing attributes with the data
`
`items in the train object's 72 timing attributes data field 106 and retrieves a latitude
`
`and longitude for each train and assigns the train to either a first group of trains
`
`that are more than "A" hours late, a second group of trains that are between "A"
`
`and "B" hours late, and a third group of trains that are less than "B" hours late.”
`
`(emphasis added)).
`
`53. Ultimately, the discussion of whether Gibbs explicitly shows using a
`
`train’s positional data to determine if the train it is late or not is irrelevant. This is
`
`because Gibbs clearly shows that a train’s physical location is a data item on a
`
`map, and that Gibbs explains that any data item (i.e., including the physical
`
`location of the train) can be monitored using warning criteria. It is illogical to read
`
`Gibbs as saying that a train’s location is not a data item on a map or that Gibbs
`
`does not show that these data items can be monitored simply because Gibbs does
`
`Petitioner Apple, Ex. 1009, p. 20
`
`
`
`
`
`not explicitly describe an example where the train’s the physical location data is
`
`the only data being monitored for an alert.
`
`E. New Claim Construction Issues
`
`1.
`
`“First Register Having a Unique Container Identification
`Value”
`
`54. Patent Owner asserts that the claim element “a first register for storing
`
`a unique container identification value” requires an additional interpretation
`
`beyond what the Board provided.
`
`55. This claim element specifies a register for storing “a unique container
`
`identification value.” It does not specify “a unique identification value for the
`
`container.” This is different from the other four claimed registers (each of which
`
`involves “space”), each of which explicitly recites that the register’s value related
`
`to “the container” (e.g., “an active space register for identifying space in which the
`
`container will act . . .”).
`
`56. A person of ordinary skill in the art would understand “a first register
`
`for storing a unique container identification value” could correspond to a unique
`
`value that identified any container. It does not require that the value be matched to
`
`the specific container in which the register is located.
`
`57. The ’536 patent does not define the phrase “first register for storing a
`
`unique container identification value.” It also does not define the phrase “a unique
`
`Petitioner Apple, Ex. 1009, p. 21
`
`
`
`
`
`container identification value.” I understand that Dr. Green has admitted as much.
`
`Ex. 2006 (Green Dec.) at ¶ 48.
`
`58.
`
`In ¶ 48 of his declaration (Ex. 2006), Dr. Green says that the unique
`
`container identification value must identify the container of which the register is
`
`part, and he cites to a number of passages from the ’536 patent. The passage Dr.
`
`Green cites do not support his conclusion.
`
`59. For example, Dr. Green cites to the ’536 patent’s description of “an
`
`
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
