DCT
2:22-cv-00328
S3G Technology LLC v. Hennes Mauritz Ab doing Business As HM
I. Executive Summary and Procedural Information
- Parties & Counsel:
- Plaintiff: S3G Technology LLC (California)
- Defendant: Hennes & Mauritz AB (dba H&M) (Sweden)
- Plaintiff’s Counsel: PARKER, BUNT & AINSWORTH, P.C.
- Case Identification: 2:22-cv-00328, E.D. Tex., 08/24/2022
- Venue Allegations: Plaintiff alleges venue is proper because Defendant has a regular and established place of business in the district, has purposely transacted business involving the accused products in the district, and committed infringing acts within the district.
- Core Dispute: Plaintiff alleges that Defendant’s H&M mobile applications and associated server infrastructure infringe patents related to a system for efficiently modifying software applications on remote devices using small data modules rather than full application updates.
- Technical Context: The technology addresses bandwidth and efficiency challenges in updating client-server applications, a foundational issue in mobile app development and distribution.
- Key Procedural History: The complaint references a prior litigation involving the asserted patent family, S3G Tech. LLC v. Unikey Techs., Inc., and cites claim constructions adopted in that case for key terms including "code" and "dialogue module." The complaint also cites the Examiner’s Statement of Reasons for Allowance during the prosecution of the ’571 patent to argue that the claimed three-entity structure and the specific composition of the terminal application were considered novel and non-obvious over the prior art.
Case Timeline
| Date | Event |
|---|---|
| 2009-07-23 | Earliest Priority Date for ’571, ’124, and ’082 Patents |
| 2013-07-11 | ’571 Patent Notice of Allowability Issued |
| 2013-10-29 | U.S. Patent No. 8,572,571 Issues |
| 2018-04-10 | U.S. Patent No. 9,940,124 Issues |
| 2021-12-28 | U.S. Patent No. 11,210,082 Issues |
| 2022-08-24 | Complaint Filed |
II. Technology and Patent(s)-in-Suit Analysis
U.S. Patent No. 8,572,571 - "Modification of Terminal and Service Provider Machines Using an Update Server Machine"
The Invention Explained
- Problem Addressed: The patent addresses the difficulty and inefficiency of distributing large, newly compiled software updates to numerous remote devices, particularly over wireless networks with limited bandwidth (Compl. ¶12-14; ’571 Patent, col. 2:1-52). Sending an entire updated application can be slow, costly, and difficult to manage across different application versions (Compl. ¶13-14).
- The Patented Solution: The invention proposes a three-entity system comprising an update server, a service provider machine, and a terminal machine (Compl. ¶15, p. 6, FIG. 1). Instead of replacing an entire application, the update server sends small "dialogue modules" to the terminal and service provider machines. These modules modify a specific part of the application defined as "code"—information that must be translated before execution (e.g., bytecode)—without altering the core "computer-executable instructions" that run directly on the processor (Compl. ¶16-17; ’571 Patent, col. 4:21-25). This allows for targeted updates to an application's functionality or user interface dialogue (Compl. ¶19).
- Technical Importance: This architectural approach aims to reduce network bandwidth consumption and enable more efficient, granular modification of applications running on remote devices (Compl. ¶23).
Key Claims at a Glance
- The complaint asserts infringement of at least claim 2, which depends on independent claim 1 (Compl. ¶28).
- Essential elements of independent claim 1 (a system claim) include:
- An update server machine operable for sending a terminal dialogue module and a provider dialogue module.
- A terminal machine configured to run a terminal application.
- A service provider machine configured to run a provider application.
- The terminal application comprises a first set of computer-executable instructions (able to execute directly on a terminal processor) and a first set of code (not able to execute directly).
- The provider application comprises a second set of computer-executable instructions and a second set of code.
- The terminal dialogue module modifies the first set of code to produce a first set of updated code, adapting the terminal application for a modified dialogue sequence.
- The provider dialogue module modifies the second set of code to produce a second set of updated code.
- Crucially, the dialogue modules do not modify the first or second sets of computer-executable instructions.
U.S. Patent No. 9,940,124 - "Modification of Terminal and Service Provider Machines Using an Update Server Machine"
The Invention Explained
- Problem Addressed: The patent addresses the same technical problem as the ’571 Patent: the inefficiency of distributing full software application updates to remote devices over networks with limited bandwidth (Compl. ¶12-14; ’124 Patent, col. 2:1-52).
- The Patented Solution: The ’124 Patent claims a method for conducting a dialogue between a terminal and a service provider machine. The terminal application, comprising both directly executable instructions and translatable code, displays a prompt and communicates user-entered data to the service provider. The terminal machine then receives a "terminal dialogue module" that updates a portion of its code to produce "first updated code." This updated code adapts the terminal application to display a second prompt as part of a modified dialogue sequence (Compl. ¶42-47; ’124 Patent, Abstract). The patent's figures illustrate this specific software structure, differentiating between executable instructions and code (Compl. ¶16, p. 6, FIG. 2).
- Technical Importance: The claimed method provides a mechanism for dynamically altering a client-side application's behavior in response to server communication without requiring a full application reinstall (Compl. ¶23).
Key Claims at a Glance
- The complaint asserts infringement of at least independent claim 1 (Compl. ¶41).
- Essential elements of independent claim 1 (a method claim) include:
- Displaying a first prompt on a terminal machine by running a terminal application comprising first computer-executable instructions and first code.
- Accepting a first data entry.
- Communicating information associated with the data entry to a service provider machine.
- Storing at least a portion of the information for analysis.
- Receiving, at the terminal machine, a terminal dialogue module.
- The dialogue module updates at least a portion of the first code to produce first updated code.
- The first updated code adapts the terminal application to display a second prompt for a modified dialogue sequence.
U.S. Patent No. 11,210,082 - "Modification of Terminal and Service Provider Machines Using an Update Server Machine"
Technology Synopsis
The ’082 Patent claims a method performed by the service provider machine. The method involves conducting a dialogue sequence where the provider machine receives and stores information, and then receives "second code" that supplements or replaces its existing application code to produce "first updated code." This updated code adapts the provider application for a modified dialogue, and the provider machine then sends "third code" to a recipient to facilitate that modified dialogue (Compl. ¶56-61; ’082 Patent, Abstract).
Asserted Claims
At least independent claim 1 (Compl. ¶55).
Accused Features
The complaint alleges that H&M's server system infringes by receiving user data (e.g., a user favoriting an item), which is received as "second code" (e.g., a JSON message) that supplements the server's existing code. This creates "updated code" that adapts the server application to conduct a modified dialogue (e.g., displaying the newly favorited item to the user), which involves sending "third code" (e.g., another JSON message) back to the user's device (Compl. ¶60-61).
III. The Accused Instrumentality
Product Identification
- The "Accused Instrumentalities" or "Accused System" are identified as the H&M mobile applications for Android and iOS devices, along with the supporting backend infrastructure, including servers, software, and methods that facilitate the use of the apps (Compl. ¶7).
Functionality and Market Context
- The complaint describes a client-server system where the H&M mobile app (the "terminal machine") interacts with H&M's servers (the "service provider machine") (Compl. ¶29, ¶31-32). The core accused functionality involves modifying the application's behavior when a user performs actions such as adding a "favorite item" (Compl. ¶30). The complaint alleges this action triggers the sending of a "dialogue module"—the "terminal machine portion of a favorite item"—which is characterized as a data packet, potentially in JSON format (Compl. ¶30, ¶33). This module allegedly modifies the application "code" (identified as the app's bytecode for Android or the .Net program on the server) to produce "updated code" that changes the dialogue sequence (e.g., displaying the newly favorited item), without modifying the underlying "computer-executable instructions" (identified as the Android Runtime or the server's CLR engine) (Compl. ¶31-33). The complaint alleges Defendant derives significant revenue from the promotion and distribution of these services (Compl. ¶7).
IV. Analysis of Infringement Allegations
8,572,571 Patent Infringement Allegations
| Claim Element (from Independent Claim 1) | Alleged Infringing Functionality | Complaint Citation | Patent Citation |
|---|---|---|---|
| an update server machine ... operable for sending a terminal dialogue module to the terminal machine and a provider dialogue module to the service provider machine... | The user's device or the Defendant's server acts as an update server, sending a "dialogue module" (e.g., "portion of a favorite item") to the H&M app and the H&M server. | ¶30 | col. 7:31-38 |
| a terminal machine ... configured to run a terminal application ... comprises a first set of computer-executable instructions and a first set of code, wherein the first set of computer-executable instructions are able to execute directly on a terminal processor ... and wherein the first set of code is not able to execute directly... | An Android smartphone running the H&M app. The Android Runtime (ART) is alleged to be the "computer-executable instructions," while the app's bytecode is alleged to be the "code" that cannot execute directly and must be translated. | ¶31 | col. 7:39-45 |
| a service provider machine ... configured to run a provider application ... comprises a second set of computer-executable instructions and a second set of code... | The Defendant's server runs a server application. The Common Language Runtime (CLR) engine is alleged to be the "computer-executable instructions," while the .Net program is alleged to be the "code." | ¶32 | col. 8:1-15 |
| the terminal dialogue module modifies the first set of code to produce a first set of updated code wherein the first set of updated code adapts the terminal application to use a second sequence of prompts... | The "terminal machine portion of a favorite item" allegedly modifies the app's bytecode to produce updated code, which adapts the app to display a new prompt, such as showing the newly added favorite item. | ¶33 | col. 8:44-52 |
| wherein the terminal dialogue module does not modify the first set of computer-executable instructions. | The complaint alleges that the dialogue module does not modify the first set of computer-executable instructions (e.g., the ART). | ¶33 | col. 8:53-55 |
9,940,124 Patent Infringement Allegations
| Claim Element (from Independent Claim 1) | Alleged Infringing Functionality | Complaint Citation | Patent Citation |
|---|---|---|---|
| displaying a first prompt on a terminal display ... by running a terminal application, the terminal application comprising first computer-executable instructions and first code... | The H&M app prompts the user to interact with a "favorite items list." The app allegedly comprises the Android Runtime (executable instructions) and bytecode (code). | ¶43 | col. 7:39-45 |
| accepting a first data entry at the terminal machine... | The user interacts with the app, for example, by adding an item to the favorites list or placing an order. | ¶44 | col. 7:46-49 |
| communicating information associated with the first data entry from the terminal machine to the service provider machine... | Information about the user's action (e.g., adding a favorite) is communicated to the Defendant's server. | ¶45 | col. 8:1-15 |
| storing at least a portion of the information ... in memory for analysis. | The server stores information related to the user's action, such as an order of a favorite item, for analysis and to add to the user's order history. | ¶46 | col. 8:16-20 |
| receiving, at the terminal machine, a terminal dialogue module that updates at least a portion of the first code to produce first updated code... | The H&M app receives information (allegedly a "terminal dialogue module" in JSON format) from the server that updates a portion of the app's bytecode to produce updated code. | ¶47 | col. 8:44-48 |
| wherein the first updated code adapts the terminal application to display a second prompt for the terminal machine's portion of a modified dialogue sequence... | The updated code adapts the H&M app to display a second prompt, which is evidenced by the ability to access the newly added favorite items. | ¶47 | col. 8:49-52 |
Identified Points of Contention
- Scope Questions: A central question may be whether the routine exchange of data packets (allegedly JSON) in a standard client-server e-commerce application constitutes a "dialogue module" as that term has been construed in prior litigation ("code or instructions related to a dialogue sequence"). The analysis may focus on whether these data packets represent the specific "particular type of structure" required by the prior construction, rather than just any data structure that performs a function (Compl. ¶20).
- Technical Questions: The complaint's theory hinges on a specific technical distinction: that the accused system modifies only the application "code" (e.g., bytecode) while the underlying "computer-executable instructions" (e.g., the Android Runtime) remain unmodified. A key factual dispute may be whether the H&M system actually operates in this manner, or if the alleged "modification" is simply the runtime environment interpreting data, a process that may not map cleanly onto the claim limitations.
V. Key Claim Terms for Construction
The Term: "dialogue module"
Context and Importance
This term is the central vehicle for modification in the asserted patents. The infringement case depends on characterizing data packets in the H&M system, such as those related to "favorite items," as meeting this definition. Practitioners may focus on this term because the complaint itself relies on a prior court construction that it is a "particular type of structure rather than ... any structure for performing a function" (Compl. ¶20), raising the question of whether standard e-commerce data packets possess the required structure.
Intrinsic Evidence for Interpretation
- Evidence for a Broader Interpretation: The specification describes the module as containing "code or other data" that can be "communicated," which could be argued to encompass a wide range of data structures used for client-server communication (’571 Patent, col. 8:44-52).
- Evidence for a Narrower Interpretation: The complaint cites a court holding that the term refers to a "particular type of structure," suggesting it is not a generic data packet (Compl. ¶20). The specification's discussion of modifying a "dialogue protocol" and its depiction in system diagrams like Figure 1 may suggest a more specific role than routine data exchange (’571 Patent, Fig. 1).
The Term: "code" (...wherein the first set of code is not able to execute directly on the terminal processor)
Context and Importance
The distinction between modifiable "code" and non-modifiable "computer-executable instructions" is the core technical mechanism of the invention. Plaintiff's infringement theory maps this to application bytecode versus a runtime environment (Compl. ¶31). The viability of this mapping is critical to the case.
Intrinsic Evidence for Interpretation
- Evidence for a Broader Interpretation: The definition could arguably apply to various forms of interpreted or just-in-time compiled software components common in modern applications.
- Evidence for a Narrower Interpretation: The specification explicitly states that "code represents at least some information that must be translated by the software application before it can be implemented on the machine processor" (’571 Patent, col. 4:21-25). The complaint also cites a prior construction as "information that must be translated before it can be executed on a processor" (Compl. ¶17, fn 5), providing a specific functional test for what qualifies as "code."
VI. Other Allegations
Indirect Infringement
- The complaint alleges inducement by Defendant marketing and promoting the H&M app, intending for customers to download and use it in a manner that, in conjunction with Defendant's servers, infringes the patents (Compl. ¶34, ¶48, ¶62). Contributory infringement is also alleged on the basis that the accused instrumentalities are not staple articles of commerce and are especially adapted for infringement (Compl. ¶35, ¶49, ¶63).
Willful Infringement
- The complaint alleges knowledge of the patents "At least since the filing of this Complaint" (Compl. ¶27, ¶40, ¶54). This allegation supports a claim for post-suit willfulness but does not plead facts showing pre-suit knowledge of the patents or willful infringement.
VII. Analyst’s Conclusion: Key Questions for the Case
- A core issue will be one of definitional scope: can the term "dialogue module", construed in prior litigation as a "particular type of structure," be read to cover the routine JSON data packets allegedly exchanged in the accused e-commerce application to manage features like a user's "favorites" list? Or does the patent contemplate a more specific and unconventional data structure for modifying application behavior?
- A key evidentiary question will be one of technical operation: does the complaint's mapping of the claims onto modern mobile application architecture hold true? Specifically, can Plaintiff demonstrate that the H&M system modifies only the application "code" (bytecode) while leaving the underlying "computer-executable instructions" (the runtime environment) untouched, as required by the claims, or is there a fundamental mismatch in how the accused system actually functions?