Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A computing device comprising a processor, wherein the processor is configured to carry out a method comprising: storing, in a memory of the computing device, a causal tree structure corresponding to a document, wherein the causal tree structure comprises a sequence of editing instructions and each editing instruction is assigned an identifier unique to such editing instruction; receiving a user editing instruction for the document, wherein the user editing instruction is assigned an identifier unique to the user editing instruction; storing the user editing instruction and the identifier assigned to the user editing instruction as an additional node to the causal tree structure; and broadcasting, to one or more client devices connected to the computing device, the user editing instruction and the identifier assigned to the user editing instruction, wherein the causal tree structure includes an editing instruction that is assigned a cause identifier, and the cause identifier is an identifier of a prior editing instruction in the causal tree structure that precedes the editing instruction, and wherein the causal tree structure further includes a second editing instruction that is assigned the same cause identifier as the editing instruction, and the editing instruction and the second editing instruction form separate branches of the causal tree structure.
A computing device manages document editing operations using a causal tree structure to track and synchronize changes across multiple client devices. The system addresses the challenge of maintaining consistency in collaborative editing environments where multiple users may modify a shared document simultaneously. The device includes a processor and memory that store a causal tree, which represents a sequence of editing instructions for a document. Each editing instruction in the tree is assigned a unique identifier, and some instructions include a cause identifier that references a prior instruction, indicating a causal relationship between edits. When a user submits an editing instruction, the system assigns it a unique identifier, stores it as a new node in the causal tree, and broadcasts the instruction along with its identifier to connected client devices. The causal tree allows multiple editing instructions to share the same cause identifier, forming separate branches that reflect concurrent or independent edits stemming from a common prior instruction. This structure ensures that all clients receive and apply edits in a way that preserves the document's integrity and the causal relationships between changes, enabling efficient conflict resolution and real-time synchronization.
2. The computing device of claim 1 , wherein the identifier assigned to the user editing instruction comprises: a site identifier unique to an editing session of the user; and a stamp, which is a numeric value based on identifiers assigned to editing instructions in the causal tree structure.
This invention relates to computing devices that manage collaborative editing sessions, particularly in systems where multiple users edit shared content concurrently. The problem addressed is tracking and resolving conflicts in editing instructions to maintain consistency across distributed systems. The computing device assigns a unique identifier to each user editing instruction. This identifier includes a site identifier specific to the editing session and a numeric stamp derived from identifiers of related editing instructions in a causal tree structure. The causal tree structure represents dependencies between editing instructions, ensuring that edits are applied in the correct order. The site identifier distinguishes instructions from different sessions, while the numeric stamp reflects the sequence and causal relationships of edits. The system uses these identifiers to detect and resolve conflicts by analyzing the causal tree structure. If two edits conflict, the system determines their order based on the numeric stamps and applies them accordingly. This approach ensures that edits are processed in a way that preserves the intended sequence of changes, even when multiple users edit the same content simultaneously. The invention improves collaborative editing by providing a structured way to track and resolve conflicts, enhancing consistency and reliability in distributed editing environments. The use of site identifiers and numeric stamps allows the system to maintain accurate causal relationships between edits, reducing errors and improving user experience.
3. The computing device of claim 2 , wherein the identifier assigned to the user editing instruction further comprises a cause identifier, wherein the cause identifier is an identifier of a prior editing instruction in a node in the causal tree structure that precedes the additional node.
The invention relates to a computing device that manages user editing instructions using a causal tree structure to track dependencies between edits. The device assigns unique identifiers to each editing instruction, where each identifier includes a cause identifier that references a prior editing instruction in the tree. This causal tree structure ensures that each new editing instruction is linked to its originating or preceding edit, maintaining a clear history of modifications. By embedding the cause identifier within the user editing instruction's identifier, the system can efficiently trace the lineage of changes, enabling better conflict resolution, version control, and collaborative editing workflows. The approach is particularly useful in multi-user environments where edits may overlap or depend on prior modifications, as it provides a structured way to determine the sequence and causality of changes. The computing device implements this by dynamically updating the causal tree as new edits are introduced, ensuring that each instruction's identifier reflects its position and dependencies within the tree.
4. The computing device of claim 1 , wherein the document is composed by traversing identifiers of the editing instructions in a sequential order.
A system for document composition involves a computing device that processes editing instructions to generate a document. The device includes a processor and memory storing instructions that, when executed, cause the processor to receive a set of editing instructions, each associated with an identifier. The instructions are processed to generate a document by traversing the identifiers in a sequential order. This traversal ensures that the editing instructions are applied in a predefined sequence, allowing for structured and predictable document generation. The system may also include a display for presenting the generated document and an input interface for receiving user inputs to modify the editing instructions. The sequential traversal of identifiers ensures that the document is composed in a consistent and ordered manner, addressing challenges in maintaining document structure and coherence when multiple editing operations are involved. The system is particularly useful in applications requiring precise document formatting, such as legal documents, technical manuals, or automated report generation, where the order of operations directly impacts the final output. The sequential processing of identifiers ensures that the document is built step-by-step, reducing errors and inconsistencies that may arise from out-of-order operations.
5. The computing device of claim 1 , wherein the user editing instruction comprises an instruction to modify a series of consecutive data in the document.
A computing device is configured to process user editing instructions for modifying documents. The device includes a processor and memory storing instructions that, when executed, cause the processor to receive a user editing instruction to modify a series of consecutive data in a document. The device further includes a display for presenting the document and an input interface for receiving user inputs. The processor analyzes the editing instruction to determine the scope of the modification, which may involve altering text, numerical data, or other sequential information. The device ensures the modification is applied accurately to the specified consecutive data, maintaining document integrity. This functionality is particularly useful in applications requiring precise edits, such as text processing, data analysis, or spreadsheet management, where maintaining the logical sequence of data is critical. The system may also include error-checking mechanisms to verify the validity of the editing instruction before execution, preventing unintended disruptions to the document structure. The device supports various editing operations, including insertion, deletion, or replacement of data, while preserving the continuity of the modified series. This capability enhances user efficiency by automating the handling of sequential edits, reducing manual intervention and potential errors.
6. The computing device of claim 1 , wherein each editing instruction in the causal tree structure comprises at least one instruction selected from the group consisting of a modification of a value, a modification of metadata, a link to another node of the causal tree structure, a link to a node in another causal tree structure corresponding to another document, a link to the other causal tree, and a link to data residing outside the causal tree structure.
This invention relates to a computing device that processes and manages document edits using a causal tree structure. The system addresses the challenge of tracking and synchronizing changes across multiple documents or data sources, ensuring consistency and traceability of modifications. The causal tree structure organizes editing instructions, where each instruction can include various types of operations. These operations may involve modifying a value or metadata within a node, creating links to other nodes within the same tree, linking to nodes in different causal trees representing other documents, or referencing external data outside the tree structure. The system enables efficient collaboration and version control by maintaining a structured, interconnected representation of changes, allowing for precise tracking of dependencies and relationships between edits. This approach enhances data integrity and simplifies the process of reconstructing document states or resolving conflicts in distributed editing environments. The invention is particularly useful in collaborative software applications, version control systems, and distributed databases where maintaining a clear history of changes is critical.
7. A computing device comprising a processor, wherein the processor is configured to carry out a method comprising: receiving, from a server connected to the computing device, at least a portion of a causal tree structure corresponding to a document, wherein the causal tree structure is stored on the server and comprises a sequence of editing instructions and each editing instruction is assigned an identifier unique to such editing instruction; storing the portion of the causal tree structure; receiving a user editing instruction for the document, wherein the user editing instruction comprises an instruction to modify a series of consecutive data in the document; assigning an identifier to the user editing instruction; transmitting, to the server, the user editing instruction and the identifier assigned to the user editing instruction; receiving, from the server, another user editing instruction for the document and an identifier assigned to the other user editing instruction; storing the user editing instruction and the identifier assigned to the user instruction, and the received other user editing instruction and the received identifier as additional nodes to the portion of the causal tree structure; and rendering the user editing instruction and the received other user instruction on a display device.
This invention relates to collaborative document editing systems, specifically a method for managing and synchronizing edits across multiple users in real-time. The problem addressed is maintaining consistency and tracking changes in a shared document when multiple users edit it simultaneously, ensuring all modifications are properly recorded and synchronized without conflicts. The system involves a computing device with a processor that handles a causal tree structure representing a document's edit history. This tree stores a sequence of editing instructions, each uniquely identified. The device receives a portion of this tree from a server, stores it locally, and processes user edits. When a user modifies a series of consecutive data in the document, the system assigns a unique identifier to the edit and transmits it to the server. The device also receives edits from other users, along with their identifiers, and integrates them into the local causal tree. All edits, including those from other users, are then rendered on the display. This approach ensures that all edits are tracked, synchronized, and displayed in the correct order, enabling real-time collaborative editing while preserving the document's integrity. The unique identifiers and causal tree structure prevent conflicts and ensure consistency across all connected devices.
8. The computing device of claim 7 , wherein assigning the identifier to the user editing instruction comprises: assigning a site identifier unique to the user's editing session on the client device; and assigning a stamp, which is a numeric value based on identifiers assigned to editing instructions in the causal tree structure stored on the server.
This invention relates to collaborative editing systems where multiple users edit a shared document or data structure in real time. The problem addressed is ensuring consistency and tracking changes across distributed editing sessions, particularly in systems where edits may occur asynchronously or out of order. The system involves a client device and a server that maintains a causal tree structure representing the sequence and dependencies of editing instructions. Each user's editing instruction is assigned a unique identifier to track its position in the causal tree. The identifier includes a site identifier unique to the user's editing session on the client device, ensuring that each user's edits are distinguishable. Additionally, the identifier includes a numeric stamp derived from identifiers of previously stored editing instructions in the causal tree, which helps maintain the causal relationships between edits. This allows the server to reconstruct the correct order of edits and resolve conflicts when integrating changes from multiple users. The system ensures that edits are applied in a way that preserves the intended sequence of operations, even if they are received out of order. This approach is particularly useful in collaborative environments where low-latency synchronization is critical, such as real-time document editing or collaborative coding platforms.
9. The computing device of claim 8 , wherein assigning the identifier to the user editing instruction further comprises assigning a cause identifier, wherein the cause identifier is an identifier of a prior editing instruction in the causal tree structure that precedes the additional node.
This invention relates to computing systems that track and manage editing instructions in a collaborative or version-controlled environment, such as document editing or software development. The problem addressed is the need to efficiently track the relationships between editing instructions, particularly in systems where multiple users or processes contribute changes over time. Existing systems may struggle to maintain a clear causal chain of edits, making it difficult to understand dependencies, resolve conflicts, or revert changes accurately. The invention improves upon prior systems by assigning identifiers to editing instructions within a causal tree structure, where each instruction is represented as a node. The tree structure captures the sequence and dependencies of edits, allowing the system to trace how one instruction influences another. Specifically, when a new editing instruction is added as a node in the tree, the system assigns an identifier to it and also assigns a cause identifier. The cause identifier links the new instruction to a prior instruction in the tree that directly or indirectly led to its creation. This ensures that the causal relationships between edits are explicitly recorded, enabling more precise tracking of changes and their origins. The system can then use these identifiers to analyze dependencies, detect conflicts, or reconstruct the state of the document or software at any point in time. This approach enhances collaboration by providing a clear, structured history of edits and their interactions.
10. The computing device of claim 7 , further comprising composing the document by traversing identifiers of the editing instructions in the portion of the causal tree structure in a sequential order.
A computing device processes and edits documents using a causal tree structure to manage editing instructions. The device stores a document as a series of editing instructions organized in a causal tree, where each instruction depends on prior instructions. The tree structure allows efficient tracking of document versions and collaborative editing by maintaining causal relationships between edits. The device includes a module to traverse the identifiers of editing instructions in a portion of the causal tree in sequential order to reconstruct or compose the document. This traversal ensures that edits are applied in the correct sequence, preserving the intended structure and content of the document. The system supports real-time collaboration by synchronizing edits across multiple users while maintaining consistency. The causal tree structure enables efficient conflict resolution and version control, allowing users to track changes and revert to previous states if needed. The device may also include a display for visualizing the document and a user interface for inputting new editing instructions. The traversal mechanism ensures that the document is accurately reconstructed from the causal tree, even when edits are made concurrently by different users. This approach improves collaboration efficiency and reduces errors in document editing.
11. The computing device of claim 7 , wherein each editing instruction in the causal tree structure comprises at least one instruction selected from the group consisting of a modification of a value, a modification of metadata, a link to another node of the causal tree structure, a link to a node in another causal tree structure corresponding to another document, a link to another causal tree structure, and a link to data residing outside the causal tree structure.
This invention relates to computing systems that manage document editing operations using a causal tree structure to track changes and relationships between edits. The problem addressed is the need for efficient, scalable, and traceable document editing, particularly in collaborative environments where multiple users may modify documents simultaneously. The system organizes editing instructions into a causal tree structure, where each node represents an edit operation and edges represent dependencies between edits. Each editing instruction in the tree can include various types of modifications, such as changing a value, updating metadata, or creating links. These links can connect nodes within the same tree, to nodes in other trees representing different documents, or to external data sources. The structure ensures that edits are recorded in a way that preserves their causal relationships, enabling accurate version tracking, conflict resolution, and collaborative editing. The system improves upon traditional version control methods by providing a more granular and flexible way to represent document changes, supporting complex editing scenarios while maintaining consistency and traceability.
12. The computing device of claim 7 , wherein the user editing instruction and the other user editing instruction share a cause identifier, and the cause identifier is an identifier of a prior editing instruction in the causal tree structure that precedes both the user editing instruction and the other user editing instruction.
This invention relates to collaborative editing systems, specifically improving the tracking and management of editing operations in distributed environments. The problem addressed is the difficulty in maintaining consistency and causality in collaborative editing systems where multiple users simultaneously edit shared content. Existing systems often struggle to accurately track the relationships between edits, leading to conflicts or lost changes. The invention involves a computing device configured to process editing instructions in a collaborative editing system. The device receives a user editing instruction and another user editing instruction, both of which share a cause identifier. This cause identifier is an identifier of a prior editing instruction in a causal tree structure that precedes both the user editing instruction and the other user editing instruction. The causal tree structure represents the hierarchical relationships between editing operations, ensuring that edits are applied in the correct order and dependencies are preserved. By associating edits with a common cause identifier, the system can determine which edits are causally related, reducing conflicts and improving synchronization. The computing device also processes the editing instructions based on their positions in the causal tree structure, ensuring that edits are applied in a way that maintains consistency across all collaborating users. This approach enhances the reliability of collaborative editing systems, particularly in scenarios where multiple users edit the same content simultaneously. The invention improves upon prior art by providing a more robust method for tracking and resolving edit dependencies, ensuring that changes are applied in a logical and conflict-free manner.
13. The computing device of claim 7 , further comprising: receiving a next user editing instruction; and assigning an identifier to the next user editing instruction based on the identifier assigned to the user instruction and the identifier assigned to the other user instruction.
A computing device is configured to process user editing instructions in a collaborative editing environment, where multiple users can simultaneously edit a shared document. The device receives a user instruction from a first user and assigns a unique identifier to it. It also receives another user instruction from a second user and assigns a different unique identifier to that instruction. When a next user editing instruction is received, the device assigns a new identifier to it based on the identifiers of the previous instructions. This ensures that all editing operations are uniquely tracked and synchronized across the collaborative environment. The identifiers may be generated using a deterministic algorithm that incorporates the identifiers of prior instructions, allowing the system to maintain consistency and resolve conflicts in real-time. The device may also include a conflict resolution module that uses the assigned identifiers to determine the order of operations and apply them correctly to the shared document. This system enables seamless collaboration by ensuring that all edits are properly sequenced and applied without data loss or corruption.
14. A computing device comprising a processor, wherein the processor is configured to carry out a method comprising: receiving, from a server, at least a portion of a causal tree structure corresponding to a document, wherein the causal tree structure comprises a sequence of nodes, and each node comprises an editing instruction and an identifier unique to such editing instruction; storing the portion of the causal tree structure; receiving a user editing instruction for the document; assigning, using a processor of the client device, an identifier to the user editing instruction; transmitting, to the server, the user editing instruction and the identifier assigned to the user editing instruction; receiving, from the server, another user editing instruction for the document and an identifier assigned to the other user editing instruction, wherein the user editing instruction and the other user editing instruction share a cause identifier, and the cause identifier is an identifier of a prior editing instruction in the causal tree structure that precedes both the user editing instruction and the other user editing instruction; storing the user editing instruction and the received other user editing instruction as additional nodes to the portion of the causal tree structure; and rendering the user editing instruction and the received other user instruction, wherein assigning the identifier to the user editing instruction comprises assigning a site identifier unique to the user's editing session on the client device, and assigning a stamp, which is a numeric value based on identifiers assigned to editing instructions in the causal tree structure stored on the server.
This invention relates to collaborative document editing systems, specifically addressing the challenge of tracking and synchronizing edits across multiple users in real-time. The system uses a causal tree structure to manage document edits, where each edit is represented as a node containing an editing instruction and a unique identifier. The tree structure ensures that edits are properly ordered and synchronized, even when multiple users make changes simultaneously. A computing device, such as a client device, receives a portion of this causal tree structure from a server, which includes a sequence of nodes representing prior edits. The device stores this portion and processes new user edits by assigning each edit a unique identifier composed of a site identifier (unique to the user's session) and a stamp (a numeric value derived from identifiers of existing edits in the server's tree structure). The device then transmits the edited instruction and its identifier to the server. The system also handles concurrent edits by receiving another user's edit, where both edits share a common cause identifier—a reference to a prior edit in the tree that precedes them. The device stores these edits as new nodes in the causal tree and renders the changes. This approach ensures that all edits are properly synchronized, maintaining document consistency across collaborative sessions. The use of unique identifiers and causal relationships prevents conflicts and ensures that edits are applied in the correct order.
15. The computing device of claim 14 , wherein the processor is further configured to compose the document by traversing identifiers of the nodes in the portion of the causal tree structure in a sequential order.
This invention relates to computing devices that generate documents from causal tree structures, addressing the challenge of efficiently organizing and presenting interconnected data. The system processes a causal tree structure, which represents relationships between nodes, where each node corresponds to a data element. The processor identifies a portion of the tree structure relevant to a specific task or query, then composes a document by sequentially traversing the identifiers of the nodes in that portion. This traversal ensures the document reflects the logical flow of the causal relationships, maintaining coherence and context. The traversal order may follow a predefined sequence, such as chronological or hierarchical, to optimize readability and usability. The invention improves document generation by dynamically adapting to the structure of the causal tree, ensuring accurate representation of dependencies and interactions between data elements. This approach is particularly useful in applications requiring structured documentation, such as knowledge management, decision support, or automated reporting systems. The system enhances efficiency by automating the document composition process while preserving the integrity of the underlying causal relationships.
16. The computing device of claim 14 , wherein the user editing instruction comprises an instruction to modify a series of consecutive data in the document.
This invention relates to computing devices that process user instructions for editing documents. The problem addressed is the need for efficient handling of user edits, particularly when modifying a series of consecutive data in a document. The invention provides a computing device with a processor and memory storing instructions that, when executed, enable the device to receive a user editing instruction and apply it to the document. The device includes a display for presenting the document and an input interface for receiving user commands. The editing instruction may involve modifying a sequence of consecutive data, such as text, numbers, or other structured information. The device processes the instruction to update the document while maintaining data integrity and ensuring the edit is applied correctly to the specified consecutive data series. The system may also include features for validating the edit, tracking changes, or providing feedback to the user. The invention improves document editing efficiency by streamlining the modification of consecutive data, reducing errors, and enhancing user experience.
17. The computing device of claim 14 , wherein each editing instruction in the nodes of the causal tree structure comprises at least one instruction selected from the group consisting of a modification of a value, a modification of metadata, a link to another node of the causal tree structure, a link to a node in another causal tree structure corresponding to another document, a link to another causal tree structure, and a link to data residing outside the causal tree structure.
A computing device processes documents using a causal tree structure to track and manage editing instructions. The system addresses the challenge of maintaining document integrity and collaboration by representing document edits as a structured, versioned tree where each node contains an editing instruction. These instructions can modify values or metadata within the document, create links to other nodes within the same tree, or reference nodes in external trees corresponding to other documents. Additionally, the instructions may link to entire external causal tree structures or external data sources outside the tree framework. This approach enables precise tracking of changes, supports collaborative editing, and ensures referential integrity across interconnected documents. The system allows for efficient versioning, conflict resolution, and seamless integration of external data, enhancing document management in collaborative environments.
Unknown
December 29, 2020
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.