US20220391597A1

US20220391597A1 - Dynamically generating documents using natural language processing of apparatus claims

Info

Publication number: US20220391597A1
Application number: US17/804,267
Authority: US
Inventors: Simon Booth; Brian McKnight; Gregory Durbin; Tom Isaacson; Shelton Austin
Original assignee: Rowan Tels Corp
Current assignee: Rowan Tels Corp
Priority date: 2021-05-27
Filing date: 2022-05-26
Publication date: 2022-12-08
Also published as: US20220382983A1

Abstract

Disclosed are systems, apparatuses, processes, and computer-readable media to convert apparatus and method claims into patent application disclosure. A process includes displaying a user interface for writing a patent application, the user interface including a plurality of objects that can be converted into content for the patent application; displaying a claim based on phrases that are separated based on a phrase variant, the phrase variant including at least one of an adjective phrase and a verb phrase; determining that a first phrase of the claim is dragged in the user interface and dropped into an object of the plurality of objects; creating and displaying a first object within the user interface based on the first phrase; and converting the plurality of objects in the user interface into the patent application including content based on the plurality of objects within the user interface

Description

CROSS-REFERENCE TO RELATED APPLICATIONS

This application claims the benefit of U.S. provisional application number 63/193,981, filed on May 27, 2021, which is expressly incorporated by reference herein in its entirety.

TECHNICAL FIELD

The present technology pertains to a method and apparatus for generating documents using natural language processing and a dynamic user interface.

BACKGROUND

Formal documents that are authored for administrative agencies are required to have a specific structure to comport with requirements of the administrative agency. The requirements include procedural-based requirements (e.g., margins, font size, etc.) and statutory-based requirements (content).

BRIEF DESCRIPTION OF THE DRAWINGS

In order to describe the manner in which the above-recited and other advantages and features of the disclosure can be obtained, a more particular description of the principles briefly described above will be rendered by reference to specific embodiments thereof which are illustrated in the appended drawings. Understanding that these drawings depict only exemplary embodiments of the disclosure and are not therefore to be considered to be limiting of its scope, the principles herein are described and explained with additional specificity and detail through the use of the accompanying drawings in which:

FIGS. 1 and 2 illustrate conventional systems for generating a patent specification;

FIG. 3 illustrates a sequence diagram of an example system for dynamically generating documents using natural language processing (NLP), in accordance with some examples;

FIG. 4 illustrates an example method for analyzing claims for generating descriptions for a patent application irrespective of statutory form, in accordance with some examples;

FIGS. 5A to 5E are various example claims that are analyzed based on the disclosed methods to illustrate identification of descriptive phrases, functional phrases, and linking phrases, in accordance with some examples;

FIG. 6 illustrates a conceptual diagram illustrating a method to identify a context and a subject of different lines of the claim in accordance with some examples;

FIG. 7 illustrates a graph illustrating a relationship of various contexts and phrases identified in the claim 600 in accordance with some examples;

FIG. 8 illustrates an example method for visually building a specification description from an apparatus claim in accordance with some examples;

FIG. 9 illustrates a function of an application for normalizing claim terms with various content within a drawing in accordance with some examples;

FIG. 10 illustrates a function of an application using phrases to visually prepare a description associated with an apparatus claim in accordance some examples;

FIG. 11 illustrates another function of an application that uses intuitive input to visually prepare, organize, and draft an application using apparatus claims in accordance with some examples;

FIG. 12 illustrates an example computer system for executing client or server operations, in accordance with some examples; and

FIG. 13 illustrates an example of a computing system in accordance with some examples.

DESCRIPTION

Various embodiments of the disclosure are discussed in detail below. While specific implementations are discussed, it should be understood that this is done for illustration purposes only. A person skilled in the relevant art will recognize that other components and configurations may be used without parting from the spirit and scope of the disclosure.
As machine learning, especially natural language processing (NLP) become more robust it is tempting to look to these tools to perform certain tasks that are considered formulaic. While these tools are indeed beneficial, they are not suitable for producing completed work product in most instances. Machine learning tools are not yet able to take raw inputs, understand them, and write an explanatory document about those raw inputs. Therefore previous attempts at document creation using machine learning tools have focused on using structured inputs.
In the example tools used for drafting patent applications, a common structured input has been claims. Indeed those skilled in the art of drafting patent applications often begin with claims because they are the most important part of the document, and are designed to recite the novel aspects of an invention. However, such tools are limited to restructuring clauses of claims into sentences and pasting them into a document, which is insufficient to produce any useful work product. Further, existing tools only use method claims as inputs because method claims are predictable and structure can be inferred based on a gerund verb phrase (e.g., “transmitting a message”) and identifying non-gerund phrases based on inferences and lack of gerund verbs. Other types of claims, such as apparatus or system claims, have a larger amount of variety and cannot be handled based on inferences.
In other examples, the existing tools only repeat the claims in the order they are input via the document and do not distinguish between the differences in the claims. In a patent application, a dependent claim could occur before the first limitation of an independent claim, could occur after the last limitation of the independent claim, or occur anywhere in between the first and last limitations. Moreover, a dependent claim may add subject matter or may further define previous actions. For example, a passive phrase in a dependent claim further defines subject matter to which it refers. Further, an active phrase may be defined by additional active phrases. The dependent claims may encompass multiple embodiments that are mutually exclusive (i.e., different species).
Existing tools may only generate a drawing based on the independent method claim, thereby producing an incomplete drawing. Further, the existing systems are also unable to identify condition-action sequences (e.g., if a condition is satisfied, perform a function) that would cause the flowchart to have branching logic because NLP itself is unable to disambiguate the meaning of phrases. The existing systems are also unable to represent inherent conditions, thus omitting content in the drawing that should be explicit.
The present technology improves over existing solutions by allowing input of any type of claim, whether apparatus, device, or system by distinguishing between descriptive phrases and functional phrases, irrespective of the root of the phrase. In some examples, a descriptive phrase describes an object (e.g., a processor connected to a memory), and a functional phrase describes a function of an object (e.g., a processor configured to process contents). The methods disclosed herein allow disambiguation of these different phrase types to allow each different phrase to be converted into a sentence. However, the descriptive phrases and functional phrases are different than previously disclosed verb phrases and adjective phrases because the prior phrase types (the verb phrase and the adjective phrase) use the root token as the premise of the type of phrase. The descriptive functional phrases and descriptive are different because the root token provides context, but both descriptive and functional phrases can include root tokens that are either a noun or a verb. For example, “a processor configured to process information” is a functional phrase even though the root token is a noun (the processor). By identifying functional and descriptive phrases, any type of claim can be disambiguated, such as claims related to a mechanical structure.
The present technology can perform functions previously that have been impossible, such as the conversion of apparatus into method claims. Conventional technology only converts method claims into apparatus claims by adding generic language (e.g., a processor configured to”) and changing conjugations of the gerund verbs (e.g., “processing the data” to “process the data”) to yield an apparatus recitation (e.g., “a processor configured to process the data”). The present technology also allows additional inputs (e.g., drawings) that can be combined with natural language processing to automatically generate descriptions of the input drawings.
By enabling the processing of apparatus claims, the present technology can be used to further automate tasks for application drafters and provide a usable draft of an application that discloses the claims, irrespective of the type of claim. Allowing different types of claim inputs allow patent drafting automation software to be extended from purely functional subject matter to concepts that include structure, and mix structure and function (e.g., electrical circuits, mechanical structures, electro-mechanical, etc.). In some aspects, the present technology can provide prompts to a user to provide disambiguation for terms, or to provide additional descriptive details. In this way, the present technology can encourage the user to provide additional input that may be beneficial to the NLP analysis.
A goal of the present technology is to provide the output that provides efficiency to an author, while leaving room for an author to provide the ingenuity and thoughtfulness that only a human author can provide. These and other improvements to tools that use algorithms or NLP to create documents are described herein.
FIGS. 1 and 2 illustrate systems for generating patent applications. In particular, FIG. 1 illustrates a server-based process to generate the formal document, and FIG. 2 illustrates an application-based generation process to generate the patent specification. In general, each of these systems generally receives method claims as input and (1) converts the method claims into apparatus or device claims, (2) generates a description of a flowchart-based on a set of method claims (i.e., a single independent claim and generally at least one dependent claim that depends from that single independent claim), and (3) creates a single generic flowchart diagram based on the independent claim. The systems may also be able to insert generic device descriptions and boilerplate based on a client's requirements.
Referring to FIG. 1 , a system 100 comprises a client 110 that connects to a webserver 120 for generating the patent specification. In the system 100, the client 110 transmits a document at step 135 that includes a set of method claims to the webserver 120. Having received the document with method claims, the webserver 120 extracts the method claims from the document at step 140. After extracting the claim, the webserver 120 transmits text that corresponds to the method claims to a natural language processing (NLP) server at step 145
The NLP server 130 receives the text and processes the text into NLP tokens at step 150. An NLP token (or token) is generally a single word or a single character (e.g., punctuation) and is assigned several properties. For instance, each NLP token is generally assigned an identifier (ID), a part of speech tag that identifies the part of speech (e.g., noun, verb, etc.), and a dependency label that identifies how the part of speech depends on other tokens, and so forth. In general, NLP engines also assign what is referred to as a fine part of speech, which further clarifies the purpose of that word. For example, a noun can be the object of the sentence, but could also be part of a compound noun (that is, a single object that has a name including several words), which is also referred to as an n-gram.
A dependency label identifies how the token depends on other tokens. For example, an NLP token may be a determiner (i.e., an article such as “the” or “an”), a nominal subject, a clausal subject, an adverbial clause, conjunction, punctuation, and so forth. A dependency label referred to as root corresponds to the root of the sentence or phrase and is not dependent on any other tokens in that sentence. For example, in the sentence “I love fries,” the NLP token “love” is the root, “I” is the proper noun having a dependency of noun subject from the root, and “fries” is the noun that is a direct object of the root. For example, the output of this sentence is illustrated in Table 1 below.

TABLE 1

Id	RootId	Text	Course Tag	Fine Tag	Dependency Label

0	1	I	Noun	Personal Pronoun	Nominal Subject
1	1	love	Verb	Non-3^rdperson	Root
				present verb
2	1	fries	Noun	Plural Noun	Direct Object

The NLP server 130 transmits the tokens to the webserver 120 at step 155, which converts the tokens into a patent specification at step 160. The webserver 120 creates a flowchart and a corresponding description to that flowchart based on NLP tokens from the method claims. To create the description of the flowchart, the webserver 120 extracts the individual portions of tokens that can be converted into a single sentence based on the order in which they are identified in the method claim (i.e., text).
Specifically, the webserver 120 converts an active step, which is a clause having an active gerund as its root word, into a sentence using a different tense. For example, the webserver 120 may convert a phrase “performing a function” into “perform a function” and then add generic content such as “a processor may” to the beginning of the phrase, thus forming “a processor may perform a function.” In this case, the generic structure is predetermined and not associated with user input. That is, the webserver 120 receives the method claims in a particular sequence and then generates a flowchart description based on the order of claims. After generating the specification, the webserver 120 transmits the patent specification with the flowchart description and additional boilerplate back to the client 110 at step 165. The webserver 120 may also transmit any created flowchart drawings or generic drawings at step 165.
FIG. 2 illustrates a system 200 that is similar to the system 100, but has a different architecture. In particular, the system 200 comprises an application 210, which may be executing on a client computer, which communicates with the NLP server 230.
The application 210 extracts the text of the method claims and transmits the text to the NLP server 230 at step 240. The NLP server 230 processes the text into NLP tokens at step 250 and returns the text as NLP tokens at step 260 to the application 210. In response to receiving the NLP tokens, the application 210 may generate the specification or part of the specification at step 270. The application 210 generates a flowchart based on the independent claim, generates a flowchart description based on the order of the claims, and composes apparatus or device claims from the method claims.
As noted above, the system 100 or system 200 may also compose additional claims from the method claims. In more detail, the system 100 or system 200 converts a method claim, which has gerund verbs, into a device or system claim, which has present tense verbs. However, in each case, the system 100 or system 200 will only provide generic structure (e.g., a processor, a memory, a display). The system 100 or system 200 may also generate “means” claims by changing the preamble and adding “means for” before the root gerund verb.
FIG. 3 illustrates a system to extract phrases of a claim irrespective of the statutory type (e.g., method, apparatus, etc.) of the claim. FIG. 4 illustrate methods executed by an device of the system to extract phrases irrespective of the statutory type of the claim. FIGS. 5A to 5E illustrate various examples of claims and phrases identified from the claims by using the methods disclosed in FIG. 4 . FIG. 7 illustrates an example graph that can be built using subject/context of an apparatus claim. FIG. 8 illustrates a method that an example application can execute to build specification descriptions using an apparatus claim. FIGS. 9 to 11 depict various examples of user interfaces of an application for building specification descriptions using an apparatus claim. FIGS. 12 and 13 illustrate various systems that can implement the disclosed technology. The disclosure now turns to FIG. 3 to illustrate a system for creating standardized documents from a set of inputs.
FIG. 3 illustrates a sequence diagram of an example system 300 for dynamically generating standardized documents using NLP and a dynamic user interface. For example, the documents can be a document for submission to an administrative agency based on that administrative agency's procedural requirements. The disclosed system can be applied to any type of standardized document that has a structure that may benefit from visually organizing concepts to form complex relationships from input text.
In the context of a patent application, the system 300 provides an improved NLP analysis method to extract phrases of a claim irrespective of the statutory type (e.g., method, apparatus, etc.). The system 300 comprises a client 302, a server 304, and an NLP server 306. In some examples, the server 304 and NLP server 306 can be different server processes executing on the same hardware or configured virtual machine. If the NLP server 306 is hosted locally on the same server as the server 304, the NLP engine may be based on a local NLP engine such as natural language toolkit (NLTK), Stanford CoreNLP, etc. However, the NLP server 306 may also be a third-party server such as Google Natural Language, Microsoft Cognitive Services, or Amazon Comprehend.
As an example, a virtual machine can execute a webserver in a reverse proxy configuration, which parses the requested uniform resource identifier (URI) and directs the request to the server 304 or NLP server 306 based on the URI. For example, any URI beginning with “/nlp” (e.g., “/nlp/document”, “/nlp/phrases”, etc.) is forwarded to the NLP server executing on port 9000. Any other URI is forwarded to the server 304 executing on port 6000. In another example, the functionality provided by the server 304 may be performed based on an application executing on the client 302 (e.g., an Electron application, a React Native Desktop application, etc.) that includes local libraries and can directly access the file system of the client 302.
In this example, the client 302 receives an application from the server 304 at step 308. For example, the application may be a component object model (COM) plugin application that executes within another application (e.g., Microsoft Word®), a stand-alone application that natively executes as an application (e.g., a Windows® Presentation Foundation (WPF) application, etc.), or a hosted application that uses another application such as a web browser to render the user interface (e.g., React Native, React Native Desktop, Electron JS, Blazor WebWindow, .net MAUI, etc.). In some examples, the application can be a web application (e.g., a Microsoft 365® add-in) that is sideloaded into a local application (e.g., Microsoft Word) or a web application (e.g., Microsoft 365®) and uses an application programming interface (API) to perform functions.
The client 302 may execute the application at step 310. As noted above, the application may be executed within a browser's sandbox. However, the application may also be an add-in that executes within another application such as a React-based add-in that is executed within Microsoft Word® and can use various APIs to interact with the document and the application. In the example illustrated in FIG. 3 , the system 300 is presumed to execute in a browser sandbox and any descriptions in FIG. 3 may be modified or changed based on the execution environment of the application.
At step 312, the application transmits the document including at least one claim to the server. As noted above, FIG. 3 may be modified based on the execution environment. As an example, if the application is a React add-in that is executing within Microsoft Word, at step 312 the application may, using an API available via the application (Office.js, etc.), retrieve the text corresponding to the claims and transmit the text to the NLP server 306.
After receiving the document, the server 304 extracts text from the claims at step 314 and transmits text from the claims at step 316 to the NLP server 306. For example, the claim generally is separated by line breaks and may include whitespace (e.g., spaces, tabs, line breaks, etc.) to illustrate relationships that matter in the claims. The margins, indents, and other paragraph properties can also be used to identify relationships in the claims. Accordingly, identification information of the claim is also extracted and transmitted to the NLP server at step 316. For example, the identification information may be the claim number and claim line encoded into a unique value, and the text may be transmitted as a key-value pair at step 316. The NLP server 306 processes the text into NLP tokens at step 318 and transmits the tokens and token identification information to the server at step 320. The NLP server 306 generates token identification information to indicate a position of the token in the input text and to identify token relationships based on the various token properties (e.g., dependency label, part of speech, etc.).
At step 322, the server 304 extracts phrases and subjects of the phrases from the tokens. In some instances, the phrases do not have a subject (e.g., the phrase is a gerund verb in a method claim and the subject is the preamble of the claim) or a subject for the sentence can be provided based on a context of the phrase. The phrases may be extracted based on the identification of grammar features that link complete phrases such as adpositional phrases (e.g., “after receiving the message”, etc.) and conjunctions (e.g., “receiving, processing, and storing”) that can be used to form a complete sentence. For example, an adpositional phrase cannot be used to create a sentence because it provides context to another phrase. In some examples, the server 304 may need to reprocess phrases outside of the context of the region at step 324 to identify the phrases. In some aspects, the server 304 may create a data structure for sending the phrases to the client 302 for efficient transmission. In particular, because the tokens have a large amount of data, the transmission of all tokens using JavaScript object notation (JSON) structures can consume significant bandwidth due to the number of properties that must be explicitly identified. An example data structure of a single paragraph in extensible markup language (XML) format is illustrated in Table 2 that can configure the various sentences using different types of spans that identify the different phrases of the paragraph. The paragraph in Table 2 is further illustrated in FIG. 5A.

TABLE 2

<p>
<descriptiveSpan subject=“filter circuit” context =“feedback circuit”
sentencePreamble=“The feedback circuit ”>
a filter circuit on a path that connects the output terminal of the
replica transistor to a base or a gate of the bias transistor via the
current mirror circuit and the control path
</descriptiveSpan>
<span>, </span>
<functionalSpan subject=“filter circuit” context =“feedback circuit”
asPresent=“the filter circuit attenuates a frequency component of
a fundamental wave of the input signal and a frequency component
of a modulated wave of the input signal” asPast=“the first circuit
attenuated a frequency component of a fundamental wave of the
input signal and a frequency component of a modulated wave of the
input signal”>
the filter circuit being configured to attenuate a frequency component
of a fundamental wave of the input signal and a frequency component of a
modulated wave of the input signal
</functionalSpan>
<span>, and wherein </span>
<descriptiveSpan subject=“filter circuit” context =“feedback circuit”
sentencePreamble=“In some examples, ”>
the base voltage or the gate voltage of the bias transistor is
controlled in accordance with a current flowing in the control path
</descriptiveSpan>
<span>.</span>
</p>

The phrases 326 from the claims are generated by the server and then sent to the client 302. In some aspects, the phrases can be configured at the client 302. For example, if the client 302 is a desktop application (.net MAUI, Electron, Tauri, React Native Desktop) that does not execute in a sandbox, the desktop application may perform these functions.
In some cases, the subject of the sentence is not the subject of the phrase because a context of the phrase, which can be determined based on whitespace, linebreaks, and other formatting, may impute a subject. To this end, a “context” may be detected from previous phrases and a “subject” may be identified in the current phrase. For example, a previous phrase could be a linking phrase such as “the feedback circuit includes:” which is followed by a whitespace or formatting to indicate that the following items are integral to or part of the parent item (e.g., “the feedback circuit”). Based on the context and the subject, the phrase can be converted into a complete sentence.
The identification of different types of phrases is challenging and may not always be correct because the NLP may not handle some aspects of grammar and the meaning of some words. The NLP understands the relationship of the words, but cannot understand their meaning, and words may sometimes have multiple meanings and forms. For example, “scheduling” is a gerund verb, but “scheduling information” is a noun. To address this issue, the application may include a user interface to permit a user to request analysis of a phrase from the claims or a new phrase (e.g., a phrase not in the claims) at block 328. In some aspects, the user can select the text using a cursor and right-click to select a new analysis of the phrase based on a type determined by the user. For example, the contextual menu displays two options to analyze the highlighted text as a descriptive phrase or a functional phrase. In other examples, the user interface may display an option to input text and allow the user to analyze the new text based on additional input (e.g., a context, a subject).
Creating a new phrase independent of its context can lead to incorrect results because the subject of the phrase can have a context that may not be input. In some cases, the selected text and parts of the claim 330 can be identified and transmitted to the server 304, which forwards the selected text and parts of the claim 330 to the NLP server 306 for processing at block 332. The NLP server 304 returns tokens 334 to the server 304 and, at block 336, the server 304 generates a phrase 338 associated with the user request based on the tokens 336 and the selected text and parts of the claim 330. After the creation of the new or modified phrase, the user may perform input into the application to sequence a patent application together. For example, the user may use a flowchart user interface to sequence a method together and the application can create a specification based on that flowchart user interface.
In some aspects, the application may be configured to create drawings or a specification at block 340 based on the phrases and associated data (e.g., subject and context). In some aspects, the drawings or specification can be created at the client 302 using the application or the client 302 can request the server 304 to create the application.
In the example illustrated in FIG. 3 , an improved NLP analysis method is described that allows the processing of both method and apparatus claims. By allowing input of method or apparatus claims and identification of structure (descriptive phrases) and functions (functional phrases), common types of claims can be converted into sentences. This allows applications to be developed to create patent specifications from apparatus claims, which has been impossible because of the large variety of variation in these claims types. In some cases, the understanding of the different types of phrases can also be used to train machine learning (ML) models to perform similar functions. In some cases, the disclosed methods and processes, which are further disclosed herein with reference to FIG. 4 , can be used for training an ML model. In some other cases, the disclosed methods and processes can be used to preprocess text for input into an ML model to identify the different phrase types. FIGS. 5A to 5E illustrate various results of processing different claims based on the disclosed methods and processes.
FIG. 4 illustrates an example method 400 for analyzing claims for generating descriptions for a patent application irrespective of the statutory type (e.g., method or apparatus claim). Although example method 400 depicts a particular sequence of operations, the sequence may be altered without departing from the scope of the present disclosure. For example, some of the operations depicted may be performed in parallel or in a different sequence that does not materially affect the function of method 400. In other examples, different components of an example device or system that implements the method 400 may perform functions at substantially the same time or in a specific sequence.
According to some examples, method 400 includes receiving a claim to be included in a patent application at block 402. For example, an application that is executing on a processor 1205 illustrated in FIG. 12 may receive a claim to be included in a patent application.
According to some examples, method 400 includes separating (e.g., by the processor 1205) the claim into a plurality of regions based on a breakpoint at block 404. The text can be in different forms such as a word document, a hypertext markup language (HTML) element, or text, and the text can be used to separate different regions and identify relationships using line breaks, paragraph elements (e.g., <w:p> elements in a word .docx file, etc.).
According to some examples, method 400 may analyze text associated with each region using a natural language processor at block 406. For example, the application may send the text to a natural language processor for analysis of each token in the text of that region. A token can be a word, punctuation, or a part of words (e.g., hyphenated words such as processor-based, etc.). In some examples, the regions correspond to a new line of the text, or a particular element (e.g., paragraph elements).
According to some examples, method 400 includes identifying (e.g., by the processor 1205) at least one phrase within each region at block 408. For example, the processor 1205, illustrated in FIG. 12 (or the processor 1310), may identify at least one phrase within each region. The phrases can be identified based on, for example, identifying tokens in results of the natural language processor that are immaterial to creating sentences from the claim. For example, a claim includes a number of text items that are immaterial for creating language, such as a preamble of a dependent claim, or punctuation at the end of a line. In some cases, a “wherein” or a “whereby” clause can be deemed immaterial. After identifying immaterial tokens, method 400 separates the region into groups of words based on punctuation in the region. In some cases, punctuation can be part of a single phrase (e.g., conjunction) or can separate phrases.
According to some examples, block 408 may further include analyzing each group of words using the natural language processor. For example, each phrase can be analyzed to determine if the group of words includes information that would be sufficient to form an entire sentence. Based on the analysis of each group of words, block 408 can determine whether to merge any group of words. For example, adpositional phrases (e.g., “in response to receiving the message” and “upon detection of the person”) and conjunctional phrases can be identified and linked to a corresponding phrase (e.g., “in response to receiving the message, sending a response” and “upon detection of the person, activating an alarm”) that can be converted into a complete sentence.
According to some examples, method 400 includes determining (e.g., by the processor 1205) a type of the at least one phrase. In some aspects, the type of phrase includes a functional phrase or a descriptive phrase at block 410. As noted above, a functional phrase identifies a function that is performed, and the descriptive phrase may describe a configuration such as an object being connected to another object, a device integral to another object, and the like.
When the root token corresponds to the noun, the type of the at least one phrase may correspond to the descriptive phrase, and, when the root token corresponds to the verb, the type of the at least one phrase may correspond to the functional phrase. However, the possibility of being accurate is insufficient, and using a root verb approach will yield incorrect detection because each phrase is different, each client has different preferences, and each attorney responsible for the claim has different preferences. For example, some claims may lead with what appears to be a gerund verb that may be incorrectly identified as a root verb but is incorrect based on the language style. For example, an adpositional phrase can include a gerund verb, but the root of the language can be a noun (e.g., “after receiving the message, the processor processes the message”). Examples of different phrases processed according to the instant disclosure are illustrated in FIGS. 5A to 5E.
According to some examples, method 400 includes, if the claim is independent, determining a statutory category of the claim at block 412. In some examples, determining a statutory category of the claim can be based on types of phrases. For example, if a first phrase of a claim recitation is a descriptive phrase, the statutory category is an apparatus (or system) claim. If the first phrase of a claim recitation is a functional phrase (e.g., functional), the statutory category is a method claim. In some aspects, in the event a claim is determined to be an apparatus or system (e.g., based on the first phrase or based on a statutory category of a parent claim that a dependent claim depends from), block 412 can include generating a method claim based on the phrases in the claim. In some aspects, the generation of the method claim can occur after various user inputs for creating the patent application.
In further aspects of block 412, method 400 may include determining a statutory category of the claim based on a first noun in the claim. The statutory category may comprise a method claim based on the first noun including a keyword and the statutory category comprises an apparatus based on the first noun not including the keyword. For example, if the first noun in the claim is determined to be similar to a method, the claim is determined to be a method claim.
Method 400 may further include receiving input to modify a phrase of the claim at block 414. In some aspects, the descriptive phrase can be incorrect because a word can have multiple meanings and the phrase may reasonably correspond to both a descriptive and a functional language. Accordingly, a user interface may be implemented that allows a user to remove phrases and create new phrases, as described above with reference to FIG. 3 .
In one example of block 414, method 400 can receive an input to delete an incorrectly identified phrase. For example, a user can select a delete option 510 illustrated in FIG. 5A to remove the identified phrase. After removing the identified phrase, the user may create text for a revised phrase based on the user interface. For example, the user can use a cursor and select text in the claim (which limits the text the user can create), or the user can insert text into a user interface for creating entirely new phrases that do not exist in the claims. In response to the new text, the user can submit a request to analyze the text. In some aspects, the request can specify a type of phrase to enforce a particular type of analysis of the claim language. In some aspects, important aspects of the phrase can be omitted from this text, and the user interface can be configured to send a portion of the claim to allow the server to understand the context of the phrase and correctly generate a sentence based on the modified phrase. For example, the phrase can be functional but can be linked to a structure. Accordingly, if the user requests analysis, the user interface can ensure that the appropriate information is sent with the new phrase to allow the processing to correctly identify structures relevant to generating the sentence. For example, if the phrase is “configured to store information,” the appropriate context of the phrase is important because a subject cannot be extracted from that phrase itself.
According to some examples, method 400 includes creating text for the at least one phrase to be used in a complete sentence based on the type of the at least one phrase at block 416. For example, the processor 1205 illustrated in FIG. 12 may create text for the at least one phrase to be used in a complete sentence based on the type of the at least one phrase.
FIGS. 5A to 5E are various example claims that are analyzed based on the disclosed methods to illustrate identification of descriptive phrases, functional phrases, and linking phrases, in accordance with some examples. In each illustration, a region including square corners (e.g., reference numeral 505) indicates a descriptive phrase, and a region including rounded corners (e.g., reference numeral 515) indicates a functional phrase. A region including a dashed border illustrates a linking phrase.
FIG. 5A illustrates an example of a user interface that displays a result of an analysis of a filter circuit recitation from an apparatus claim, in accordance with some examples. The filter circuit provides a good example because it includes both structure and function within a single region, which is extracted based on linebreaks or different paragraph elements in an OpenXML document (e.g., <w:p> elements). The first phrase 505 is descriptive because it describes an electrical configuration of the first circuit. The first phrase also includes a delete option 510 to delete the phrase and allow a user to select and identify specific phrase types. A second phrase 515 is a functional phrase because it describes a function of the filter circuit (attenuating a frequency component). A third phrase 520 is based on a wherein phrase and is determined to be a descriptive phrase, but in some cases could be deemed to be a function. However, the third phrase 520 is descriptive of the base or gate voltage and does not identify a function of the filter circuit. The third phrase 520 also illustrates an example of subject and context. In particular, the subject of the sentence is the filter circuit. However, the subject of the third phrase is the base voltage or the gate voltage. In this case, the subject of the phrase can be mapped to the prior phrases and the sentence for the third phrase 520 can be generated based on the subject of the first phrase. In this case, the third phrase can be mapped to a transitional phrase.
FIG. 5B illustrates an example of a user interface that displays a result of an analysis of an independent method claim, in accordance with some examples. In particular, FIG. 5B illustrates the analysis of claim 1 of the instant application and each of the recitations, except phrase 525, are functional phrases. The phrase 525 is descriptive and further defines the type of phrase, and no keyword or trigger language (e.g., wherein, whereby) indicates that the phrase 525 is descriptive.
FIG. 5C illustrates an example of a user interface that displays a result of an analysis of a dependent apparatus claim, in accordance with some examples. The dependent apparatus claim in FIG. 5C includes a linking phrase 530 that is deemed immaterial, a descriptive phrase 535, and a functional phrase 540. In this example, the functional phrase does not include a subject, and the method is capable of identification of the functional phrase without any subject. In this case, the context of the functional phrase can be used to identify the subject, which can be extracted from phrase 535 to form a complete sentence.
FIG. 5D illustrates an example of a user interface that displays a result of an analysis of a dependent apparatus claim without any function, in accordance with some examples. In some examples, the phrase 545 may be incorrectly detected because the object of the verb (comprises) is present. Accordingly, a user can delete the phrase 545 to correct this issue.
FIG. 5E illustrates an example of a user interface that displays a result of an analysis of a dependent apparatus claim with a complex series of conjunctions, in accordance with some examples. In particular, this example illustrates that conjunctions can The first phrase 550 can be used to form a sentence based on the context, which can be identified in the preamble of the claim, and the second phrase 555 can be reconfigured into a complete sentence, despite the complexity of the language.
FIG. 6 illustrates a conceptual diagram illustrating a method to identify a context and a subject of different lines of the claim in accordance with some aspects. In particular, FIG. 6 illustrates an example claim 600 that includes a mixture of structure and function that can be separated into functional and descriptive phrases as described above. Unlike a method claim, an apparatus claim can have different structures that have relationships with each other and the formation of language based on the claims should consider the context of a line of claim, whether the line includes a subject, and whether the line has a relationship with a prior line. In some aspects, a line of a claim is separated by a suitable linebreak as illustrated by the pilcrow symbol (¶).
The method of identifying a context and a subject will generally consist of a queue with three lines including a current line, a previous line, and a next line. The queue will be populated during the iteration of each line and build a dictionary that identifies previously identified subjects of a line, and a context stack that identifies a current position within a graph. For example, the method would identify a preamble that provides a root context 602 or can be the subject of any sentence when iterating over an independent claim. The root context 602 would be added to the context stack. As the method iterates over the next line, the method can determine that a subject 604 of the line begins with a functional phrase or a descriptive phrase that includes a subject. The line including subject 604 has a single phrase (“an amplifier configured to amplify and input signal”), the method can generate a sentence based on the root context 602. Specifically, the root context can be modified to include a reference label, if available, and conjugate the phrases based on the type of phrase (e.g., “the power amplifier 600 includes an amplifier transistor configured to amplify an input”).
Similarly, lines that begin with subject 606 and subject 608 are siblings of subject 604 and the method configures a sentence with the root context 602. If any of the lines include an additional phrase that was separate from the leading phrase, the subject of the additional phrases is identified from the subject of the line. For example, the line leading with subject 610 includes a second descriptive phrase (“the base voltage or the gate voltage is reverse biased”) that further describes the feedback circuit. The method can use the subject 610 and the NLP of the phrase to generate a sentence by, for example, inserting a preposition into the phrase (e.g., “the bias voltage or gate voltage of the feedback circuit is reverse biased”). As described above, the subjects are placed into a dictionary or a hash that uniquely identifies an object. For example, in a hash of string types (e.g., Hashset<string>), each value in the hash corresponds to a unique string value that corresponds to the subject.
The next line includes a wherein clause with the root token corresponding to subject 612. The method can recognize the subject 612 and identify that the subject 612 has been identified in the hash. A dictionary is different from a hash and includes a key-value pair (e.g., Dictionary<string, Boolean>). In this aspect, the method can identify that the line comprises a linking phrase and ends with an open transition (e.g., the trailing colon). In response to detecting the linking phrase, the method adds the identified subject 612 to the context stack. The method can continue iterating through the various lines, but can now build the sentence based on the identified context or subject (e.g., “the feedback circuit includes a control path, a replica transistor, a current mirror, and a filter circuit.”). In some cases, the claim term may be different that the description of the corresponding item or the drawing may identify the object differently, as illustrated herein with reference to FIG. 9 . The method can therefore use related terms to generically describe the structure or specific terms and then provide a generic example. For example, the filter circuit may be described as a low pass filter in the drawings, and the method can use knowledge of alternative language for the claim term to build a description that links terms (e.g., “The feedback circuit includes a filter circuit, such as low pass filter 300, on a path that connects the output terminal of the replica transistor to a base or a gate of the bias transistor via the current mirror circuit and the control path.”).
In some aspects, the method can also use whitespace characters such as tabs to imply relationships. For example, the tab character illustrated in the lines having subjects 614, 616, 618, and 620 may imply a relationship with a previous object. In one aspect, the method comprises evaluating the next line to determine whether the subject of the sentence should be added to the context stack. Similarly, whitespace can also be used to identify the end of a context such as the end of a description related to the feedback circuit. Although not illustrated in FIG. 6 , the claim can include further context, such as a description of functions, or a description of additional structures. For example, a common claim strategy is to identify a structure with a linking phrase followed by a colon (e.g., “a processor configured to:”, and then the immediate lines following the structure are functional phrases that identify the functions performed by the structure. In this illustrative example, the method can identify that the functional phrases do not include a subject and therefore use the last item in the context stack as the subject of the sentence.
When a context ends, the context stack is popped, which causes the last item to be removed. The context stack may not be popped if the context stack only consists of the root context 602. The identification of a context and a stack in purely functional programming techniques and is a challenging task because small errors that a person can readily recognize are difficult for a machine to understand. For example, the difference between a tab character and paragraph formatting to apply whitespace can be difficult to write specific instructions for the machine to process. In some aspects, a machine learning (ML) model can be trained to identify the subject and context associated with the various phrases based on text and other metadata such as paragraph formatting. In one aspect, each line illustrated in FIG. 6 corresponds to an OpenXML paragraph object (e.g., <w:p>) and each OpenXML paragraph object further includes a paragraph properties object (e.g., <w:ppr>) that identifies intending, position, line spacing, margins, etc.
FIG. 7 illustrates a graph 700 illustrating a relationship of various contexts and phrases identified in the claim 600 in accordance with some aspects. In one aspect, the root context 602 serves as a root node of the graph 700 and all elements associated with the language of the claim are descendants. For example, the root context 602 includes child nodes corresponding to subject 604, subject 606, subject 608, and subject 610. As noted by the legend, the subject 604, subject 606, subject 608, and subject 610 are descriptive, but the child nodes of the root context 602 may also be functional phrases. Each node of the graph 700 can include further children, such as subject 610 including children nodes including subject 614, subject 616, subject 618, and subject 620. Each node can include child nodes such as phrase 630, phrase 632, and phrase 634.
In some aspects, the construction of the graph 700 also includes other subject matter in the claim, such as dependent claims. The graph 700 should include all subject matter recited in the claim, and based on the structure of the graph 700, the language of the claim can be converted into a strict description. In other aspects, the graph 700 can serve as a basis for applying portions of a description in conjunction with a user interface, such as the user interface illustrated in FIGS. 9, 10, and 11 . In one aspect described below, a context of a drawing can understood and a description of the apparatus claim can be generated based on a combination of the graph 700 and user inputs into a user interface, thereby allowing a patent application drafter the ability to visually prepare a patent application that fully supports the claim. In other aspects, the graph 700 can be used to derive a paragraph for literal support in some jurisdictions.
FIG. 8 illustrates an example method 800 for visually building a specification description from an apparatus claim in accordance with some aspects of the disclosure. Although the example method 800 depicts a particular sequence of operations, the sequence may be altered without departing from the scope of the present disclosure. For example, some of the operations depicted may be performed in parallel or in a different sequence that does not materially affect the function of the method 800. In other examples, different components of an example device or system that implements the method 800 may perform functions at substantially the same time or in a specific sequence.
In some aspects, the method 800 can be performed by a computing system (e.g., computing system 1200). For example, the computing system may receive instructions from a remote server and configure the computing system to generate a patent application based on claim language, drawings, and user input. In some aspects, the method of FIG. 8 is presumed to have sent the document, a portion of the document, or a portion of the text of the document to a server (e.g., server 1255) for processing, and the server has received the results including at least one phrase as described above. Further, the method of FIG. 8 is presumed to have received drawings associated with the patent application to perform the functions identified below. The drawings can be in any suitable format and may be converted into a format that is ideal for the identification of relationships. For example, scalable vector graphic (SVG) files can identify points and relationships after the normalization of various vectors.
The method 800 includes constructing a graph including a plurality of nodes associated with at least a portion of phrases from a set of claims based on a context and a subject for each phrase of the portion of phrases at block 802. For example, each phrase of a set of claims correspond to a different node in the graph. The graph can be a data structure that forms hierarchal or graph relationships. For example, the data structure can be a pure hierarchical structure. In other cases, the graph can be a graph data structure that identifies nodes and edges that identify relationships between the node (e.g., an edge from node A to node B that identifies a sequence or a parent-child relationship).
At block 804, the method includes displaying (e.g., based on instructions from the computing system to display associated with a computing system) a user interface for writing a patent application. In one aspect, part of the user interface can include a claim panel that identifies a state of the claims, for example, whether a phrase of a claim is associated with a structure in a drawing. For example, at block 806, the method 800 includes displaying a claim based on phrases that are separated based on a phrase variant. As described above, the phrase variant includes at least one of an adjective phrase and a verb phrase. Non-limiting phrase variants that can also be displayed include a linking phrase, a preamble phrase (e.g., the computer-implemented method of a claim), and an adpositional phrase.
In one aspect, the computing system can display a user interface that illustrates relevant content in the document section or the different document, and allows input to identify relationships. For example, claim terms in the document may not necessarily align with extracted text in the drawings, and reference labels in the drawings may not necessarily be identified to correspond to text. The user interface allows a user to normalize the various terms by predictive text inputs, and then excluding the data that is assigned to to related data. As illustrated below in FIG. 9 , the claim text, the drawing text (if available), and a reference label can be different and the user interface enables a user to create relationships to assist in creating text associated with the drawing. For example, when a sentence is generated based on a phrase, the sentence can be generated with an example that relates a claim term to the drawing.
In one aspect, the computing system inserts at least one metadata node into the graph based on the context of child content. For example, the computing system can insert metadata nodes that correspond to structures to identify regions of description corresponding to that node. The user can also create metadata nodes. The metadata node defines a collapsible parent node that provides a context associated with child nodes and can be used to help a drafter to organize concepts in an efficient manner. A document does not represent how a person visually perceives content in the most efficient manner, but a tree structure and various nodes that can hide/display content can allow a user to visually understand the writing and organization of the document using spatial awareness. The draggable tree structure can also simply reorganization and review of concepts within a patent specification.
At block 808, a user can drag a phrase associated with a claim to interact with the user interface. For example, the computing system can determine that a first phrase of the claim is dragged in the user interface and dropped into an object of the plurality of objects. In one example, the plurality of objects are nodes within a tree view component based on a hierarchical relationship or a graph data structure. The tree view component can be configured to drag and drop nodes to conveniently reorganize parent/child relationships and sequence nodes in a suitable order.
As an example, a tree view component can represent a specification with a root node that represents the entire patent specification and the first nodes of the root correspond to different document sections (e.g., document description, brief description of the drawings, summary, etc.). In another example, the root node can represent a portion of the document such as represent the root node corresponding to content associated with a single figure. As will be described later, metadata can be injected into the document and the root node of the single figure can encompass all content associated with that drawing, and it would be possible to extract the entire description corresponding to this figure, including the drawing too, to reincorporate into a later or a related application. For example, if two drafters are working on a single application in parallel, this user interface feature would allow drafters to seamlessly merge two different patent applications into a single patent application with minimal effort and stress.
Based on the user interface input, the method can create (e.g., by a computing system) and display a first object within the user interface based on the first phrase at block 810. For example, the first phrase can have a subject and a context as described above and the computing system generate a tree view node that includes a sentence that can use the subject or the context to create a sentence associated with the first phrase. For example, at block 810, the computing system can construct a sentence based on the first phrase, a subject of the first phrase, and a context associated with the first phrase. In some cases, the context can be injected into a phrase as noted above, or the sentence can be generated without the context (e.g., when the phrase begins with the subject. Generation of language with apparatus claims is different from method claims because method claims generally do not consider the organization and structure of the different components. An apparatus claim can have different structures, and those different structures can have sub-structures (e.g., a processor includes a cache). The context and subject are necessary to correctly form a sentence for apparatus claims, but not for method claims.
As will be described below, the user interface in FIG. 9 can identify relationships between claim terms and other material. The first object can include the identified relationships, such as specifically relating a claim term to a text description and a reference label within the drawing. In another example, the first object can include a plain English description example of the claim term.
In some cases, at block 810, the computing system can display a user interface to edit the sentence. For example, the sentence can be a custom sentence that does not correspond to a claim. In other aspects, the user interface to edit the sentence can be a customized editor (e.g., a content editable block element) that causes a conjugated version of the first phrase to be immutable. In other aspects, the user interface can allow the conjugated version of the first phrase to be mutable.
At block 812, the computing system can convert the plurality of objects in the user interface into the patent application including content based on the plurality of objects within the user interface. For example, the computing system can take the various inputs and sequence together a plurality of objects into a written description based on the generated sentence, as well as custom input sentences. In one aspect, the computing system can insert metadata into a document of the patent application that identifies at least one object of the plurality of objects in the user interface. In general, it has not been possible to insert metadata into OpenXML documents because third-party application programming interfaces (APIs) do not support all features, including open-source APIs that are sponsored by vendors such as Microsoft. Unsupported metadata inserted into the document is removed during the XML validation process (e.g., when the document is saved). A custom XML library has been created to build or modify OpenXML content to support OpenXML smart tags, which can enable paragraph-based tagging or content-based tagging. Paragraph-based tagging is the identification of content at the paragraph level (e.g., an order of the paragraphs). Content-based tagging identifies a range of content in the paragraph and can, for example, link a phrase in a claim to the language generated for the document based on that claim. An example of paragraph-based tagging and content-based tagging is illustrated below in Table 3.
In one aspect, the metadata nodes of the graph can be embedded into the document itself. At block 814, at a later time (e.g., a week), an application can read the document of the patent application and can restore a state of the plurality of the objects based on the embedded metadata. In some cases, block 814 can also include the identification of changes in the document and mapping those changes into the application state. For example, if a phrase is generated based on a claim and that phrase is detected to be modified (based on the metadata indicating what the phrase should be), the application can alert the user to the change in text.
Table 3 below illustrates an example paragraph with custom tags and illustrates various types of information that can be embedded into a single paragraph. For purpose of simplicity, the example paragraph omits some tags (e.g., the text <w:t> tag) and attributes in an OpenXML document for clarity. In Table 3, the paragraph can include metadata that identifies a paragraph number of the paragraph and a unique identifier, a linked previous neighbor paragraphs, a related figure, a claim source (e.g., claim 1), and so forth. Further, the paragraph can include runs (<w:r>, which can also be referred to as spans) of text and the runs can identify a phrase of that paragraph. When the method views the paragraph in Table 2, the method can determine that the child content (e.g., within the tags) and the attribute that the method embeds in the custom tag are different. In this aspect, the patent-specific application can therefore determine that the text was edited, and the related paragraphs that are identified in the custom tag's attributes should be updated.

TABLE 3

<w:p>
<w:smartXml>
<w:smartXmlPr>
<w:attr w: paragraphicId w:val=“100”/>
<w:attr w:Id w:val=“AJi1a-1mUf1”/>
<w:attr w:nextParagraphId w:val=“lkk1j-00091”/>
<w:attr w:prevParagraphIUd w:val=“m5YH1-POnb1”/>
<w:attr w:relatedFigureId w:val=“5”/>
<w:attr w:claimId w:val=“1”/>
</w:smartXmlPr>
<w:smartXml>
<w:r>In one example, the computing device may </w:r>
<w:smartXml phrase=“receive a network route from the PCE” claimSource=“1”,
phraseld=“kd81d-24akO” relatedParagraph=“XXXXX-XXXXX”
relatedParagraph=“XXXXX-XXXXX” relatedParagraph=“XXXXX-XXXXX”
relatedParagraph=“XXXXX-XXXXX”>
<w:r>receive a network route from a network controller</w:r>
</w:smartXml>
<w:r>. For example, the SDN controller can be configured to provide this
message. </w:r>
</w:p>

In this example, the first custom tag includes a property tag (<w:smartXmlPr>) with attributes, and the second custom tag includes attributes within the tag itself. In some aspects, an attribute of the first tag may be different and more complicated such as Javascript object notation (JSON) that describes a complex object and the JSON object can be encoded via a base64 value into a single attribute. This may simplify serialization and deserialization based on the type of application. The first custom tag includes a phrase that identifies the original text of the phrase, and if the run content (e.g., <w:r> changes, the custom tag can flag an issue. In some cases, this can be used to promulgate a later change in a claim to fix a typographical error for example. The custom tag can also include a phrase identifier that maps to the original phrase in the claim, and can include other information such as related paragraphs that include the content. Non-limiting examples of usage of the phrase in a patent application include, for example, a description of a flowchart, a node/tree structure, a description in a block diagram, a summary of the application, an abstract, a claim (e.g., as part of an apparatus claim), or a multiple-dependency style of claims for literal support in some jurisdictions.
In some cases, the method can also insert global information into the document itself. For example, an openXML document accepts a custom XML part that can be used to link content controls another other material (e.g., a mail merge, etc.) of the document. For example, the method can include a custom XML part that may be loaded with relevant static data such as the claims, paragraph information, etc. When the document is returned to the method, the method can perform several analyses to identify relevant changes such as deleted paragraphs, revised claims, etc. The custom XML part applies to a global state of the document and the custom tags apply to instances or the rendered content. That is, the custom tags apply to content inline and identify, for example, how a specific portion of text corresponds to a portion of a claim.
FIG. 9 illustrates a function of an application 900 for normalizing claim terms with various content within a drawing in accordance with some aspects of the disclosure. In particular, FIG. 9 illustrates an application 900 (e.g., a web application, a native desktop application, etc.) executing software instructions to create a user interface having a drawing region 902 and a term region 904. The drawing region 902 includes a plurality of objects and includes reference labels. For purposes of illustration, reference labels beginning with X (e.g. measurement system X10) is referring to a proposed illustration to illustrate a drawing being used within the application 900, and reference labels beginning with numerals (e.g., drawing region 902) are referring to features of the application 900.
In some aspects, the application can analyze the drawings to extract text such as the reference labels (e.g., X20, feedback circuit X30). In some cases, some text may only be reference labels, such as X32, which corresponds to a feedback path, and X20. This is a particularly common feature in mechanical and circuit drawings that use symbols and shapes to identify meanings. In the event both can be extracted, as illustrated in the term region 904, the application can separate the drawing text from the reference label (e.g. using a regular expression). In other aspects, the text may be underlined and the application can extract underlined text in some cases. However, even if text is identified, the text within the drawing does not necessarily correspond to the claims, which are typically more generic or require a specific word to trigger a suitable interpretation. In some cases, the terms can simply be different by accident (e.g., measuring circuit and measurement system).
Similarly, the application or a server (or both) can merge noun chunks to create a compound noun (e.g., a first device, at least one memory, scheduling information, etc.). Based on the identified claim text, the application may perform a whole match or a partial match to determine a logical similarity. For example, the application could compute the Levenstein distance of the claim text and the drawing text to identify a similarity of the two words. In another aspect, the applicant may send the terms to the server, which may execute an NLP server, and compute a similarity of the words or use semantic similarity (e.g., word2vec) to identify differences in the whole word or different words. For example, a similarity comparison of a measuring circuit and a measurement system may be identified and the application can automatically relate language in the drawing to language in the claim text.
For terms that do not have any linked text, the application may perform a search to identify a related line based on identifying a boundary 906 and the application may search for lines (e.g., straight lines, Bezier curves, etc.) that start or end within the boundary region. In this illustrative example, a line 908 includes an endpoint within boundary 906, which indicates to the application that the line may be associated with some other text. Based on the identification of the line 908, the application can identify an endpoint of the line 908, and then identify shapes that the line 908 is proximate to, intersects, or contacts. For example, the application may generate a bounding region 910 for each shape and may execute a raycasting algorithm to determine if the endpoint of the line 908 is within the bounding region 910. If the line falls within this bounding region 910, the application can associate the reference label with any subject matter. However, in the illustrative example, the amplifier is a corresponding circuit shape and does not include any text. In this example, the reference label can be linked to regions that include text.
In some aspects, the application may also identify shapes within shapes to identify a parent-child relationship, if that relationship has no already been formed. For example, the measurement system X10 can include detector X11, coupler X12, and component X13. The application may identify the relationship between detector X11, coupler X12, and component X13 as children of the measurement system.
Another method of identifying relationships includes identifying a line that connects a shape to another shape. For example, the line 912 can connect the amplifier X20 to the feedback circuit X30. Similar to the above, the line can be analyzed to determine if the point is within a boundary region (e.g., boundary region 910). In some cases, because the endpoints are reflected as float values (e.g., decimals), the values may not be precise, and implementing a boundary region can ensure that connected components are identified. Based on the above-described techniques, the drawings and the claims can be synthesized using the application 900. In one case, the application attempts to synthesize information based on value equality, such as the claim term feedback circuit corresponding to the text in the drawing, and NLP processing. In some cases, the empty cells in the drawing region 902 can be populated based on the unused language associated with the corresponding text. If drawing text is assigned to claim text, then the drawing text and claim text will be used to populate a dropdown list. Relationships can cross-correlate and, in response to correlating two different terms, the drawing region 902 can dynamically merge rows based on creating the relationship between the two terms.
In other cases, a user may enter the various terms through the user interface and manually align the content. Although this may be a tedious process, the manual entry of text that corresponds to a reference label can assist in creating various mechanisms to reduce text input such as a shortcut. For example, a document generated by the application may be able to inject a shortcut into the document and the word processing application may dynamically replace these shortcuts while editing that document.
FIG. 10 illustrates a function of an application 1000 using phrases to visually prepare a description associated with an apparatus claim in accordance some aspects of the disclosure. In particular, the application includes a drawing region 1002 and a claim panel 1004. The claim panel 1004 may demarcate the claims to indicate different phrases, such as functional phrases, descriptive phrases, and so forth. The color of the phrase in the claim panel 1004 indicates whether the claim term is assigned to a structure. For example, FIG. 9 illustrates that a user drags the phrase 1006 along path 1008 to place the phrase 1006 over a related structure in the drawing region 1002 (e.g., the detector X11). At this point, the user can drop the phrase 1006 into the component in the drawing region to assign the phrase 1006 to the component.
In some cases, the application 1000 may display phrases assigned to the component in a popup window 1010 to provide feedback to the user. Feedback is important because it provides a mechanism for the user to understand the state. In some cases, the phrases may be modified to indicate a link to the corresponding component, such as a label corresponding to the component in the drawing. In another aspect, a user may hover a cursor (mouseover event) over a phrase in the claim panel 1004 and the application may highlight the component that the phrase is assigned to in the drawing region 1002.
FIG. 11 illustrates another function of an application 1100 that uses intuitive input to visually prepare, organize, and draft an application using apparatus claims in accordance with some aspects. In some cases, the application includes a plurality of objects such as nodes in a tree view component 1102. A tree view component is a tree or hierarchical data control that visually arranges content based on a parent/child relationship. In some cases, the tree view component includes a root component that encompasses the whole. For example, a tree view component can represent an entire specification or can represent a single drawing.
The user interface illustrated in FIG. 10 is one example of a method to link phrases of an apparatus claims, and the user interface in FIGS. 9 and 10 can be used to create the graph (or hierarchical data) used to populate the tree view component 1102. In other aspects, the tree view component 1102 may be populated using only the claims and a subject/context analysis.
In some cases, when populating the data structure (e.g., graph) for the tree view component 1102, the application may insert metadata nodes that identify a logical concept and abstract different parts of the description. For example, the tree view component 1102 includes metadata nodes 1104 that logically represent different sections of the apparatus drawing, such as the feedback circuit X30 and the measurement system X10. As illustrated in FIG. 11 , the tree view component 1102 can display a sentence 1106 that is generated from the phrase and a context or subject. For example, the tree view component 1102 can provide the context and subject relationships.
In this user interface, the user may be able to restructure the description based on drag and drop operations. The drag and drop allow the hierarchical organization and a logical presentation of sentences, as well as a simplify the review of content that will be inserted into the specification. Patent specifications can be significantly long and wieldy documents, and a tree view component can assist in scoping the view to relevant material into manageable portions and enable faster, simpler, and quicker organization. In some cases, the user interface can include multiple drawings and allow the user to move the figures with respect to each other. In the event a figure is moved, the corresponding text is updated, including reference labels and references in other sections to those reference labels.
Metadata nodes can also be custom-created, which can be beneficial for training new drafters. For example, a reviewer of the patent specification can create metadata nodes that visually illustrate feedback and provide context. This feature can be beneficial for bifurcated drafting, such as an attorney may draft the claims of the specification and and a structural outline, and then another third-party drafting service writes the remaining specification based on the attorney outline.
The tree view component can also include a linebreak node 1110 with a pilcrow mark indicating that a new paragraph in the patent specification will be inserted at the end of a particular node. In some cases, although the linebreak node 1110 is smaller, it is not associated with any text and can be customized to provide a clear visual illustration of how the patent application is flow when converted to conventional writing.
FIG. 11 provides a functionally different drafting mechanism that uses logical and hierarchy to organize concepts. As a result, a patent specification drafter is able to navigate and understand the organization and flow without reading paragraphs of content to understand the position in the patent specification. The drag and drop operation enables rapid and accurate modifications while reducing errors and reducing stress.
In some cases, the nodes may also be edited. For example, the content in the nodes can be a content editable block element. In other aspects, a customizable editor may be implemented to allow modification of content around the conjugated phrase to provide, for example, a more smooth transition or an explanation. However, the conjugated phrase may be immutable to maintain the link between the claims and the specification.
Other aspects of the application include embedding relevant metadata into the generated patent specification. For example, the metadata nodes can be inserted into the OpenXML that identify an application state, and when the document is returned to the application 1100 (e.g., after an inventor edits the application in a different application such as a word processing application), the document state can at least be partially restored to allow a drafter to continue editing the patent specification.
Although a variety of examples and other information was used to explain aspects within the scope of the appended claims, no limitation of the claims should be implied based on particular features or arrangements in such examples, as one of ordinary skill would be able to use these examples to derive a wide variety of implementations. Further and although some subject matter may have been described in language specific to examples of structural features and/or method steps, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to these described features or acts. For example, such functionality can be distributed differently or performed in components other than those identified herein. Rather, the described features and steps are disclosed as examples of components of systems and methods within the scope of the appended claims. Moreover, claim language reciting “at least one of” a set indicates that one member of the set or multiple members of the set satisfy the claim.
FIG. 12 illustrates an example computer system 1200 for executing client or server operations, in accordance with some examples. For example, the example computer system 1200 may execute a client application, a server-side application for performing the instant disclosure, or an NLP engine.
The example computer system 1200 includes a processor 1205, a memory 1210, a graphical device 1215, a network device 1220, interface 1225, and a storage device 1230 that communicate and operate via a connection 1235. The connection 1235 can be a physical connection via a bus, or a direct connection into processor 1205, such as in a chipset architecture. The connection 1235 can also be a virtual connection, networked connection, or logical connection.
The processor 1205 reads machine instructions (e.g., reduced instruction set (RISC), complex instruction set (CISC), etc.) that are loaded into the memory 1210 via a bootstrapping process and executes an operating system for executing applications within frameworks provided by the operating system. That is, the processor 1205 can include any general-purpose processor and a hardware service or software service, which are stored in memory 1210, and configured to control processor 1205 as well as a special-purpose processor where software instructions are incorporated into the actual processor design. The processor 1205 may essentially be a completely self-contained computing system, containing multiple cores or processors, a bus, memory controller, cache, etc. A multi-core processor may be symmetric or asymmetric.
For example, the processor 1205 may execute an application that executes an application provided by a graphical framework such as Winform, WPF, Windows User Interface (WinUl), or a cross-platform user interface such as Xamarin or QT. In other examples, the processor 1205 may execute an application that is written for a sandbox environment such as a web browser.
The processor 1205 controls the memory 1210 to store instructions, user data, operating system content, and other content that cannot be stored within the processor 1205 internally (e.g., within the various caches). The processor 1205 may also control a graphical device 1215 (e.g., a graphical processor) that outputs graphical content to a display 1240. In some examples, the graphical device 1215 may be integrated within the processor 1205. In yet another example, the display 1240 may be integral with the computer system 1200 (e.g., a laptop, a tablet, a phone, etc.). In some examples, the graphical device 1215 may be integral with the processor 1205 and form an accelerated processing unit (APU).
The graphical device 1215 may be optimized to perform floating point operations such as graphical computations, and may be configured to execute other operations in place of the processor 1205. For example, controlled by instructions to perform mathematical operations optimized for floating point math. For example, the processor 1205 may allocate instructions to the graphical device 1215 for operations that are optimized for the graphical device 1215. For instance, the graphical device 1215 may execute operations related to artificial intelligence (AI), NLP, and vector math. The results may be returned to the processor 1205. In another example, the application executing in the processor 1205 may provide instructions to cause the processor 1205 to request the graphical device 1215 to perform the operations. In other examples, the graphical device 1215 may return the processing results to another computer system (i.e., distributed computing).
The processor 1205 may also control a network device 1220 for transmits and receives data using a plurality of wireless channels 1245 and at least one communication standard (e.g., Wi-Fi (i.e., 1202.11ax, 1202.11e, etc.), Bluetooth®, various standards provided by the 3rd Generation Partnership Project (e.g., 3G, 4G, 5G), or a satellite communication network (e.g., Starlink®). The network device 1220 may wirelessly connect to a network 1250 to connect to servers 1255 or other service providers. The network device 1220 may also be connected to the network 1250 via a physical (i.e., circuit) connection. The network device 1220 may also directly connect to local electronic device 1260 using a point-to-point (P2P) or a short-range radio connection.
The processor 1205 may also control an interface 1225 that connects with an external device 1270 for bidirectional or unidirectional communication. The interface 1225 is any suitable interface that forms a circuit connection and can be implemented by any suitable interface (e.g., universal serial bus (USB), Thunderbolt, and so forth). The external device 1270 can receive data from interface 1225 to process the data or perform functions for different applications executing in the processor 1205. For example, the external device 1270 may be another display device, a musical instrument, a computer interface device (e.g., a keyboard, a mouse, etc.), an audio device (e.g., an analog-to-digital converter (ADC), a digital-to-analog converter (DAC)), a storage device for storing content, an authentication device, an external network interface (e.g., a 5G hotspot), a printer, and so forth.
The storage device 1230 can be a non-volatile memory device and can be a hard disk or other types of computer-readable media which can store data that are accessible by a computer, such as flash memory, solid state memory devices, an electro-mechanical data storage such as a hard disk drive (HDD), optical storage medium such as digital versatile disks, cartridges, random access memories (RAMs), read only memory (ROM), and/or some combination of these devices. In some embodiments the computer-readable storage devices, mediums, and memories can include a cable or wireless signal containing a bitstream and the like. However, when mentioned, non-transitory computer-readable storage media expressly exclude media such as energy, carrier signals, electromagnetic waves, and signals per se.
The storage device 1230 can include software services, servers, services, etc., that, when the code that defines such software is executed by the processor 1205, it causes the system to perform a function. In some embodiments, a hardware service that performs a particular function can include the software component stored in a computer-readable medium in connection with the necessary hardware components, such as processor 1205, connection 1235, external device 1270, etc., to carry out the function.
FIG. 13 shows an example of computing system 1300, which can be for example any computing device making up any network node such as the client 302, webserver 304, or NLP server 306, or any component thereof in which the components of the system are in communication with each other using connection 1305. Connection 1305 can be a physical connection via a bus, or a direct connection into processor 1310, such as in a chipset architecture. Connection 1305 can also be a virtual connection, networked connection, or logical connection.
In some embodiments computing system 1300 is a distributed system in which the functions described in this disclosure can be distributed within a datacenter, multiple datacenters, a peer network, etc. In some embodiments, one or more of the described system components represents many such components each performing some or all of the function for which the component is described. In some embodiments, the components can be physical or virtual devices.
Example computing system 1300 includes at least one processing unit (CPU or processor) 1310 and connection 1305 that couples various system components including system memory 1315, such as ROM 1320 and RAM 1325 to processor 1310. Computing system 1300 can include a cache of high-speed memory 1312 connected directly with, in close proximity to, or integrated as part of processor 1310.
Processor 1310 can include any general-purpose processor and a hardware service or software service, such as services 1332, 1334, and 1336 stored in storage device 1330, configured to control processor 1310 as well as a special-purpose processor where software instructions are incorporated into the actual processor design. Processor 1310 may essentially be a completely self-contained computing system, containing multiple cores or processors, a bus, memory controller, cache, etc. A multi-core processor may be symmetric or asymmetric.
To enable user interaction, computing system 1300 includes an input device 1345, which can represent any number of input mechanisms, such as a microphone for speech, a touch-sensitive screen for gesture or graphical input, keyboard, mouse, motion input, speech, etc. Computing system 1300 can also include output device 1335, which can be one or more of a number of output mechanisms known to those of skill in the art. In some instances, multimodal systems can enable a user to provide multiple types of input/output to communicate with computing system 1300. Computing system 1300 can include communications interface 1340, which can generally govern and manage the user input and system output. There is no restriction on operating on any particular hardware arrangement and therefore the basic features here may easily be substituted for improved hardware or firmware arrangements as they are developed.
Storage device 1330 can be a non-volatile memory device and can be a hard disk or other types of computer readable media which can store data that are accessible by a computer, such as magnetic cassettes, flash memory cards, solid state memory devices, digital versatile disks, cartridges, RAMs, ROMs, and/or some combination of these devices.
The storage device 1330 can include software services, servers, services, etc., that, when the code that defines such software is executed by the processor 1310, causes the system to perform a function. In some embodiments, a hardware service that performs a particular function can include the software component stored in a computer-readable medium in connection with the necessary hardware components, such as processor 1310, connection 1305, output device 1335, etc., to carry out the function.
Devices implementing methods according to these disclosures can comprise hardware, firmware and/or software, and can take any of a variety of form factors. Typical examples of such form factors include servers, laptops, smart phones, small form factor personal computers, personal digital assistants, and so on. Functionality described herein also can be embodied in peripherals or add-in cards. Such functionality can also be implemented on a circuit board among different chips or different processes executing in a single device, by way of further example.
For clarity of explanation, in some instances, the present technology may be presented as including individual functional blocks including functional blocks comprising devices, device components, steps or routines in a method embodied in software, or combinations of hardware and software.
Any of the steps, operations, functions, or processes described herein may be performed or implemented by a combination of hardware and software services or services, alone or in combination with other devices. In some embodiments, a service can be software that resides in memory of a client device and/or one or more servers of a content management system and perform one or more functions when a processor executes the software associated with the service. In some embodiments, a service is a program, or a collection of programs that carry out a specific function. In some embodiments, a service can be considered a server. The memory can be a non-transitory computer-readable medium.
In some embodiments the computer-readable storage devices, mediums, and memories can include a cable or wireless signal containing a bit stream and the like. However, when mentioned, non-transitory computer-readable storage media expressly exclude media such as energy, carrier signals, electromagnetic waves, and signals per se.
Methods according to the above-described examples can be implemented using computer-executable instructions that are stored or otherwise available from computer readable media. Such instructions can comprise, for example, instructions and data which cause or otherwise configure a general-purpose computer, special purpose computer, or special purpose processing device to perform a certain function or group of functions. Portions of computer resources used can be accessible over a network. The computer executable instructions may be, for example, binaries, intermediate format instructions such as assembly language, firmware, or source code. Examples of computer-readable media that may be used to store instructions, information used, and/or information created during methods according to described examples include magnetic or optical disks, solid state memory devices, flash memory, USB devices provided with non-volatile memory, networked storage devices, and so on.
Devices implementing methods according to these disclosures can comprise hardware, firmware and/or software, and can take any of a variety of form factors. Typical examples of such form factors include servers, laptops, smartphones, small form factor personal computers, personal digital assistants, and so on. Functionality described herein also can be embodied in peripherals or add-in cards. Such functionality can also be implemented on a circuit board among different chips or different processes executing in a single device, by way of further example.
The instructions, media for conveying such instructions, computing resources for executing them, and other structures for supporting such computing resources are means for providing the functions described in these disclosures.
Although a variety of examples and other information was used to explain aspects within the scope of the appended claims, no limitation of the claims should be implied based on particular features or arrangements in such examples, as one of ordinary skill would be able to use these examples to derive a wide variety of implementations. Further and although some subject matter may have been described in language specific to examples of structural features and/or method steps, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to these described features or acts. For example, such functionality can be distributed differently or performed in components other than those identified herein. Rather, the described features and steps are disclosed as examples of components of systems and methods within the scope of the appended claims.
In some examples, the system can be implemented in a virtualized and/or container system. For example, the system can be implemented in a single or multiple Docker containers on a Docker Host. As an example, various aspects of the system can be separated into different containers to isolate functions (e.g., application, storage, etc.) across a single Docker host or multiple Docker hosts. In another example, the system can be implemented in a scalable container system (e.g., a Kubernetes cluster) that automatically provisions containers, networking, load balancing, security, and scaling of the system.
Illustrative examples of the disclosure include:
Aspect 1. A method for preparing a patent application based on claims, comprising: displaying a user interface for writing a patent application, the user interface including a plurality of objects that can be converted into content for the patent application; displaying a claim based on phrases that are separated based on a phrase variant, the phrase variant including at least one of an adjective phrase and a verb phrase; determining that a first phrase of the claim is dragged in the user interface and dropped into an object of the plurality of objects; creating and displaying a first object within the user interface based on the first phrase; and converting the plurality of objects in the user interface into the patent application including content based on the plurality of objects within the user interface.
Aspect 2. The method of Aspect 1, wherein the plurality of objects are nodes within a tree view component.
Aspect 3. The method of any of Aspects 1 to 2, wherein the converting the plurality of objects comprises: constructing a sentence based on the first phrase, a subject of the first phrase, and a context associated with the first phrase.
Aspect 4. The method of any of Aspects 1 to 3, further comprising: identifying a description in a different document or document section that corresponds to a claim term in the first phrase; and injecting the description into the sentence based on the description.
Aspect 5. The method of any of Aspects 1 to 4, wherein the description comprises one of a reference label or a plain English description of the claim term.
Aspect 6. The method of any of Aspects 1 to 5, further comprising: displaying a user interface that illustrates relevant content in the document section or the different document; and identifying relationships between at least two of a claim term, a reference label of a drawing, and a drawing description.
Aspect 7. The method of any of Aspects 1 to 6, wherein the first phrase is immutable in the user interface.
Aspect 8. The method of any of Aspects 1 to 7, further comprising: displaying a user interface to edit the sentence.
Aspect 9. The method of any of Aspects 1 to 8, further comprising: constructing a graph including a plurality of nodes associated with at least a portion of phrases from a set of claims based on a context and a subject for each phrase of the portion of phrases, wherein the set of claims that includes the claim, and wherein each phrase correspond to a node in the graph.
Aspect 10. The method of any of Aspects 1 to 9, further comprising: inserting at least one metadata node into the graph based on a context of child content, wherein the at least one metadata node defines a collapsible parent node that provides a context associated with child nodes.
Aspect 11. The method of any of Aspects 1 to 10, further comprising: inserting metadata into a document of the patent application that identifies at least one object of the plurality of objects in the user interface.
Aspect 12. The method of any of Aspects 1 to 11, further comprising: reading the document of the patent application and embedded into content associated with the document; and restoring a state of the plurality of objects based on the metadata.
Aspect 13: A computing system for generating a patent application based on apparatus claims includes a storage (implemented in circuitry) configured to store instructions and a processor. The processor configured to execute the instructions and cause the processor to: display a user interface for writing a patent application, the user interface including a plurality of objects that can be converted into content for the patent application; display a claim based on phrases that are separated based on a phrase variant, the phrase variant including at least one of an adjective phrase and a verb phrase; determining that a first phrase of the claim is dragged in the user interface and dropped into an object of the plurality of objects; create and displaying a first object within the user interface based on the first phrase; and convert the plurality of objects in the user interface into the patent application including content based on the plurality of objects within the user interface.
Aspect 14: The computing system of Aspect 13, wherein the plurality of objects are nodes within a tree view component.
Aspect 15: The computing system of any of Aspects 13 to 14, wherein the processor is configured to execute the instructions and cause the processor to: construct a sentence based on the first phrase, a subject of the first phrase, and a context associated with the first phrase.
Aspect 16: The computing system of any of Aspects 13 to 15, wherein the processor is configured to execute the instructions and cause the processor to: identify a description in a different document or document section that corresponds to a claim term in the first phrase; and inject the description into the sentence based on the description.
Aspect 17: The computing system of any of Aspects 13 to 16, wherein the description comprises one of a reference label or a plain English description of the claim term.
Aspect 18: The computing system of any of Aspects 13 to 17, wherein the processor is configured to execute the instructions and cause the processor to: display a user interface that illustrates relevant content in the document section or the different document; and identify relationships between at least two of a claim term, a reference label of a drawing, and a drawing description.
Aspect 19: The computing system of any of Aspects 13 to 18, wherein the first phrase is immutable in the user interface.
Aspect 20: The computing system of any of Aspects 13 to 19, wherein the processor is configured to execute the instructions and cause the processor to: display a user interface to edit the sentence.
Aspect 21: The computing system of any of Aspects 13 to 20, wherein the processor is configured to execute the instructions and cause the processor to: construct a graph including a plurality of nodes associated with at least a portion of phrases from a set of claims based on a context and a subject for each phrase of the portion of phrases, wherein the set of claims that includes the claim, and wherein each phrase correspond to a node in the graph.
Aspect 22: The computing system of any of Aspects 13 to 21, wherein the processor is configured to execute the instructions and cause the processor to: insert at least one metadata node into the graph based on a context of child content, wherein the at least one metadata node defines a collapsible parent node that provides a context associated with child nodes.
Aspect 23: The computing system of any of Aspects 13 to 22, wherein the processor is configured to execute the instructions and cause the processor to: insert metadata into a document of the patent application that identifies at least one object of the plurality of objects in the user interface.
Aspect 24: The computing system of any of Aspects 13 to 23, wherein the processor is configured to execute the instructions and cause the processor to: read the document of the patent application and embedded into content associated with the document; and restore a state of the plurality of objects based on the metadata.
Aspect 25: A computer readable medium comprising instructions using a computer system. The computer includes a memory (e.g., implemented in circuitry) and a processor (or multiple processors) coupled to the memory. The processor (or processors) is configured to execute the computer readable medium and cause the processor to: display a user interface for writing a patent application, the user interface including a plurality of objects that can be converted into content for the patent application; display a claim based on phrases that are separated based on a phrase variant, the phrase variant including at least one of an adjective phrase and a verb phrase; determining that a first phrase of the claim is dragged in the user interface and dropped into an object of the plurality of objects; create and displaying a first object within the user interface based on the first phrase; and convert the plurality of objects in the user interface into the patent application including content based on the plurality of objects within the user interface.
Aspect 26: The computer readable medium of Aspect 25, wherein the plurality of objects are nodes within a tree view component.
Aspect 27: The computer readable medium of any of Aspects 25 to 26, wherein the processor is configured to execute the computer readable medium and cause the processor to: construct a sentence based on the first phrase, a subject of the first phrase, and a context associated with the first phrase.
Aspect 28: The computer readable medium of any of Aspects 25 to 27, wherein the processor is configured to execute the computer readable medium and cause the processor to: identify a description in a different document or document section that corresponds to a claim term in the first phrase; and inject the description into the sentence based on the description.
Aspect 29: The computer readable medium of any of Aspects 25 to 28, wherein the description comprises one of a reference label or a plain English description of the claim term.
Aspect 30: The computer readable medium of any of Aspects 25 to 29, wherein the processor is configured to execute the computer readable medium and cause the processor to: display a user interface that illustrates relevant content in the document section or the different document; and identify relationships between at least two of a claim term, a reference label of a drawing, and a drawing description.
Aspect 31: The computer readable medium of any of Aspects 25 to 30, wherein the first phrase is immutable in the user interface.
Aspect 32: The computer readable medium of any of Aspects 25 to 31, wherein the processor is configured to execute the computer readable medium and cause the processor to: display a user interface to edit the sentence.
Aspect 33: The computer readable medium of any of Aspects 25 to 32, wherein the processor is configured to execute the computer readable medium and cause the processor to: construct a graph including a plurality of nodes associated with at least a portion of phrases from a set of claims based on a context and a subject for each phrase of the portion of phrases, wherein the set of claims that includes the claim, and wherein each phrase correspond to a node in the graph.
Aspect 34: The computer readable medium of any of Aspects 25 to 33, wherein the processor is configured to execute the computer readable medium and cause the processor to: insert at least one metadata node into the graph based on a context of child content, wherein the at least one metadata node defines a collapsible parent node that provides a context associated with child nodes.
Aspect 35: The computer readable medium of any of Aspects 25 to 34, wherein the processor is configured to execute the computer readable medium and cause the processor to: insert metadata into a document of the patent application that identifies at least one object of the plurality of objects in the user interface.
Aspect 36: The computer readable medium of any of Aspects 25 to 35, wherein the processor is configured to execute the computer readable medium and cause the processor to: read the document of the patent application and embedded into content associated with the document; and restore a state of the plurality of objects based on the metadata.

Claims

1. A method for preparing a patent application based on claims, comprising:

displaying a user interface for writing a patent application, the user interface including a plurality of objects that can be converted into content for the patent application;

displaying a claim based on phrases that are separated based on a phrase variant, the phrase variant including at least one of an adjective phrase and a verb phrase;

determining that a first phrase of the claim is dragged in the user interface and dropped into an object of the plurality of objects;

creating and displaying a first object within the user interface based on the first phrase; and

converting the plurality of objects in the user interface into the patent application including content based on the plurality of objects within the user interface.

2. The method of claim 1, wherein the plurality of objects are nodes within a tree view component.

3. The method of claim 2, wherein the converting the plurality of objects comprises:

constructing a sentence based on the first phrase, a subject of the first phrase, and a context associated with the first phrase.

4. The method of claim 3, further comprising:

identifying a description in a different document or document section that corresponds to a claim term in the first phrase; and

injecting the description into the sentence based on the description.

5. The method of claim 4, wherein the description comprises one of a reference label or a plain English description of the claim term.

6. The method of claim 4, further comprising:

displaying a user interface that illustrates relevant content in the document section or the different document; and

identifying relationships between at least two of a claim term, a reference label of a drawing, and a drawing description.

7. The method of claim 3, further comprising:

displaying a user interface to edit the sentence.

8. The method of claim 6, wherein the first phrase is immutable in the user interface.

9. The method of claim 1, further comprising:

constructing a graph including a plurality of nodes associated with at least a portion of phrases from a set of claims based on a context and a subject for each phrase of the portion of phrases, wherein the set of claims that includes the claim, and wherein each phrase correspond to a node in the graph.

10. The method of claim 9, further comprising:

inserting at least one metadata node into the graph based on a context of child content, wherein the at least one metadata node defines a collapsible parent node that provides a context associated with child nodes.

11. The method of claim 1, further comprising:

inserting metadata into a document of the patent application that identifies at least one object of the plurality of objects in the user interface.

12. The method of claim 11, further comprising:

reading the document of the patent application and embedded into content associated with the document; and

restoring a state of the plurality of objects based on the metadata.

13. A computing system for generating a patent application based on apparatus claims, comprising:

a storage configured to store instructions;

a processor configured to execute the instructions and cause the processor to:

display a user interface for writing a patent application, the user interface including a plurality of objects that can be converted into content for the patent application;

display a claim based on phrases that are separated based on a phrase variant, the phrase variant including at least one of an adjective phrase and a verb phrase;

create and displaying a first object within the user interface based on the first phrase; and

convert the plurality of objects in the user interface into the patent application including content based on the plurality of objects within the user interface.

14. The computing system of claim 13, wherein the plurality of objects are nodes within a tree view component.

15. The computing system of claim 14, wherein the processor is configured to execute the instructions and cause the processor to:

construct a sentence based on the first phrase, a subject of the first phrase, and a context associated with the first phrase.

16. The computing system of claim 15, wherein the processor is configured to execute the instructions and cause the processor to:

identify a description in a different document or document section that corresponds to a claim term in the first phrase; and

inject the description into the sentence based on the description.

17. The computing system of claim 16, wherein the description comprises one of a reference label or a plain English description of the claim term.

18. The computing system of claim 16, wherein the processor is configured to execute the instructions and cause the processor to:

display a user interface that illustrates relevant content in the document section or the different document; and

identify relationships between at least two of a claim term, a reference label of a drawing, and a drawing description.

19. The computing system of claim 18, wherein the first phrase is immutable in the user interface.

20. A non-transitory computer readable medium comprising instructions, the instructions, when executed by a computing system, cause the computing system to: