US20230222286A1 - Dynamically generating documents using natural language processing and dynamic user interface - Google Patents
Dynamically generating documents using natural language processing and dynamic user interface Download PDFInfo
- Publication number
- US20230222286A1 US20230222286A1 US18/119,115 US202318119115A US2023222286A1 US 20230222286 A1 US20230222286 A1 US 20230222286A1 US 202318119115 A US202318119115 A US 202318119115A US 2023222286 A1 US2023222286 A1 US 2023222286A1
- Authority
- US
- United States
- Prior art keywords
- nlp
- tokens
- text
- segment
- segments
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000003058 natural language processing Methods 0.000 title description 138
- 238000004458 analytical method Methods 0.000 claims abstract description 43
- 238000000034 method Methods 0.000 claims description 141
- 230000003993 interaction Effects 0.000 claims description 4
- 230000000875 corresponding effect Effects 0.000 description 41
- 230000006870 function Effects 0.000 description 24
- 238000005516 engineering process Methods 0.000 description 23
- 230000009471 action Effects 0.000 description 21
- 230000015654 memory Effects 0.000 description 15
- 230000008569 process Effects 0.000 description 15
- 230000001419 dependent effect Effects 0.000 description 13
- 238000010586 diagram Methods 0.000 description 12
- 230000004044 response Effects 0.000 description 12
- 230000000153 supplemental effect Effects 0.000 description 11
- 239000000284 extract Substances 0.000 description 10
- 238000012545 processing Methods 0.000 description 10
- 230000000007 visual effect Effects 0.000 description 9
- 230000008901 benefit Effects 0.000 description 8
- 238000004891 communication Methods 0.000 description 8
- 230000006872 improvement Effects 0.000 description 6
- 230000008859 change Effects 0.000 description 5
- 244000035744 Hura crepitans Species 0.000 description 4
- 239000008186 active pharmaceutical agent Substances 0.000 description 4
- 230000009286 beneficial effect Effects 0.000 description 4
- 238000012508 change request Methods 0.000 description 4
- 150000001875 compounds Chemical class 0.000 description 4
- 238000010801 machine learning Methods 0.000 description 3
- 239000002547 new drug Substances 0.000 description 3
- 230000008520 organization Effects 0.000 description 3
- 230000003068 static effect Effects 0.000 description 3
- 230000002194 synthesizing effect Effects 0.000 description 3
- 230000002457 bidirectional effect Effects 0.000 description 2
- 230000005540 biological transmission Effects 0.000 description 2
- 238000007667 floating Methods 0.000 description 2
- 238000004519 manufacturing process Methods 0.000 description 2
- 230000003287 optical effect Effects 0.000 description 2
- 238000012163 sequencing technique Methods 0.000 description 2
- 241000894007 species Species 0.000 description 2
- NIXOWILDQLNWCW-UHFFFAOYSA-N acrylic acid group Chemical group C(C=C)(=O)O NIXOWILDQLNWCW-UHFFFAOYSA-N 0.000 description 1
- 230000002730 additional effect Effects 0.000 description 1
- 238000013473 artificial intelligence Methods 0.000 description 1
- 230000015572 biosynthetic process Effects 0.000 description 1
- 230000001149 cognitive effect Effects 0.000 description 1
- 230000001276 controlling effect Effects 0.000 description 1
- 238000012937 correction Methods 0.000 description 1
- 238000013500 data storage Methods 0.000 description 1
- 238000003066 decision tree Methods 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 238000001647 drug administration Methods 0.000 description 1
- 230000007246 mechanism Effects 0.000 description 1
- 239000003607 modifier Substances 0.000 description 1
- 230000002093 peripheral effect Effects 0.000 description 1
- APTZNLHMIGJTEW-UHFFFAOYSA-N pyraflufen-ethyl Chemical compound C1=C(Cl)C(OCC(=O)OCC)=CC(C=2C(=C(OC(F)F)N(C)N=2)Cl)=C1F APTZNLHMIGJTEW-UHFFFAOYSA-N 0.000 description 1
- 230000008707 rearrangement Effects 0.000 description 1
- 238000012552 review Methods 0.000 description 1
- 239000007787 solid Substances 0.000 description 1
- 238000003786 synthesis reaction Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F40/00—Handling natural language data
- G06F40/10—Text processing
- G06F40/166—Editing, e.g. inserting or deleting
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F40/00—Handling natural language data
- G06F40/10—Text processing
- G06F40/12—Use of codes for handling textual entities
- G06F40/131—Fragmentation of text files, e.g. creating reusable text-blocks; Linking to fragments, e.g. using XInclude; Namespaces
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F40/00—Handling natural language data
- G06F40/20—Natural language analysis
- G06F40/253—Grammatical analysis; Style critique
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F40/00—Handling natural language data
- G06F40/20—Natural language analysis
- G06F40/279—Recognition of textual entities
- G06F40/284—Lexical analysis, e.g. tokenisation or collocates
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F40/00—Handling natural language data
- G06F40/20—Natural language analysis
- G06F40/279—Recognition of textual entities
- G06F40/289—Phrasal analysis, e.g. finite state techniques or chunking
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06Q—INFORMATION AND COMMUNICATION TECHNOLOGY [ICT] SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES; SYSTEMS OR METHODS SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES, NOT OTHERWISE PROVIDED FOR
- G06Q10/00—Administration; Management
- G06Q10/10—Office automation; Time management
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06Q—INFORMATION AND COMMUNICATION TECHNOLOGY [ICT] SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES; SYSTEMS OR METHODS SPECIALLY ADAPTED FOR ADMINISTRATIVE, COMMERCIAL, FINANCIAL, MANAGERIAL OR SUPERVISORY PURPOSES, NOT OTHERWISE PROVIDED FOR
- G06Q50/00—Information and communication technology [ICT] specially adapted for implementation of business processes of specific business sectors, e.g. utilities or tourism
- G06Q50/10—Services
- G06Q50/18—Legal services
- G06Q50/184—Intellectual property management
Definitions
- the present technology pertains to a method and apparatus for generating documents using natural language processing and a dynamic user interface.
- Formal documents that are authored for administrative agencies are required to have specific structure to comport with the administrative agency's requirements.
- the requirements include procedural-based requirements (e.g., margins, font size, etc.) and statutory-based requirements (content).
- FIGS. 1 and 2 illustrate existing systems for generating patent applications.
- FIG. 1 illustrates a server-based process to generate the formal document
- FIG. 2 illustrates an application-based generation process to generate the patent specification.
- 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.
- a system 100 comprises a client 110 that connects to a webserver 120 for generating the patent specification.
- the client 110 transmits a document at step 135 that includes a set of method claims to the webserver 120 .
- the webserver 120 extracts the method claims from the document at step 140 .
- the webserver 120 transmits text that corresponds to the method claims to the 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 (or 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.
- NLP engines also assign what is referred to as a fine part of speech, which further clarifies the purpose of that word.
- 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.
- 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.
- 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).
- 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.
- 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.”
- 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.
- 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 .
- 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.
- system 100 or system 200 may also compose additional claims from the method claims.
- 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.
- 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.
- 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 NLP and a dynamic user interface
- FIG. 4 is a flowchart of a method for segmenting text into tokens and claim segments
- FIG. 5 is a flowchart of a method for sequencing claim segments to generate a patent specification
- FIG. 6 illustrates an example user interface for arranging claim segments to generate a patent specification and drawings
- FIG. 7 illustrates an example user interface for arranging claim segments using a claim panel that simultaneously displays claim segments and claims based on a feedback scheme
- FIG. 8 illustrates an example node that allows complex manipulation of claim segments
- FIGS. 9 A, 9 B, and 9 C illustrate an example node that allows complex relationships of claim segments
- FIG. 10 illustrates a user interface that allows a user to build a specification using point and click operations in conjunction with a client-specific module
- FIG. 11 is a flowchart of a method for generating a patent specification based on a related application that is identified using NLP;
- FIG. 12 illustrates an example user interface for generating a specification based on a related application that is identified using NLP
- FIG. 13 illustrates an example computer system for executing client or server operation.
- NLP natural language processing
- 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.
- a dependent claim may add subject matter or may further define previous actions.
- a passive phrase in a dependent claim further defines subject matter to which it refers.
- an active phrase may be further 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 system 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 improving the machine-user interface, which provides further inputs into a natural language processing server and yields a more robust output.
- the present technology utilizes an input collection of statements.
- the statements can be elements of claims, while in the case of a contract the statements can be a description of major deal terms.
- these statements can be sentences reciting key points to be described.
- the present technology can analyze the statements and can organize them into an initial order based on relationships and dependencies perceived based on the tokens provided from the NLP server.
- This initial organization can be in the form of a flowchart or an outline.
- the present technology recognizes that, in the process of writing a complex document, thoughts need to be rearranged, additional thoughts may be added, and thoughts may be refined. As such the present technology provides an interface by which the initial order can be reorganized based on the judgment of a human author.
- 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.
- the present technology can ultimately provide a more usable initial output to an author of a document.
- 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.
- the present technology is also able to accommodate more complex relationships between phrases.
- the present technology can accommodate and describe conditional logic, or descriptions nested in other descriptions.
- the present technology provides various other improvements, some of which are specific to drafting of patent applications.
- the present technology encourages input of detailed and numerous dependent claims so that the NLP server can provide the foundation for a detailed patent application.
- the present technology can allow a user to suppress portions of a claim from appearing in a claim section of a document or from appearing in the drawings accompanying a patent application.
- FIG. 3 illustrates a sequence diagram of an example system 300 for dynamically generating standardized documents using NLP and a dynamic user interface.
- 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.
- the system 300 provides an improved NLP analysis method that is illustrated in FIGS. 3 and 4 .
- an application that is executing within the system 300 may include a dynamic user interface that is illustrated in FIGS. 5 to 10 to allow the user to input method claims, sequence the steps of the claims together with an intuitive user interface, and intelligently compose portions of a patent specification.
- the dynamic user interface allows the user to identify structures associated with actions within the claims, which can then be used to more intelligently compose claims and draft the specification based on input method claims.
- the system 300 comprises a client 302 , a server 304 , and a NLP server 306 .
- the server 304 and the NLP server 306 can be different server processes executing on the same hardware or configured virtual machine.
- the NLP engine may be based on a local NLP engine such as natural language toolkit (NLTK), Stanford CoreNLP, etc.
- the NLP server 306 may also be a third-party server such as Google Natural Language, Microsoft Cognitive Services, or Amazon Comprehend.
- 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 forward to the server 304 executing on port 6000 .
- URI uniform resource identifier
- the functionality provided by the server 304 may be performed based on an application executing on the client 302 (e.g., a Native React application, etc.) that include local libraries and is able to directly access the file system of the client 302 .
- an application executing on the client 302 e.g., a Native React application, etc.
- the client 302 receives an application from the server 304 at step 308 .
- 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., Native React, Electron JS, Blazor WebWindow, etc.).
- COM component object model
- the application can be web application (e.g., a Microsoft 365® add-in) that is side loaded into a local application (e.g., Microsoft Word) or a web application (e.g., Microsoft 365®) and uses an API to perform functions.
- a web application e.g., a Microsoft 365® add-in
- a local application e.g., Microsoft Word
- a web application e.g., Microsoft 365®
- the client 302 may execute the application at step 310 .
- the application may be executed within a browser's sandbox.
- the application may also be an add-in and executes within another application such as a React-based add-in that is executed within Microsoft Word® and is able to use various APIs to interact with the document and the application.
- 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.
- the application transmits the document including at least one claim to the server.
- FIG. 3 may be modified based on the execution environment.
- 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 .
- 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 .
- the claim generally is separated by line breaks and may include whitespace (e.g., spaces, tabs, line breaks, etc.) to illustrate relationships of subject matter in the claims.
- whitespace e.g., spaces, tabs, line breaks, etc.
- the margins, indenting, and other paragraph properties can also be used to identify relationships in the claims.
- identification information of the claim is also extracted and transmitted to the NLP server at step 316 .
- 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.).
- the server 304 generates token IDs, analyzes the NLP tokens, and creates new text at step 322 .
- the server 304 generates a token identifier for each token based on the identification information and token identification information.
- the server 304 generates a unique token identifier for each token based on the claim number of the token, the line number (based on the line breaks), and a position of the token within that line.
- the token IDs generated by the server 304 allow supplemental NLP analysis of different segments to improve quality of the NLP.
- the NLP analysis of the line of text may materially be affected based on common terms that are commonly used in patent claims.
- the term “wherein” may significantly affect the NLP analysis and cause the NLP to misidentify the root word.
- the root word of a phrase or sentence is not dependent on any other tokens.
- terms such as “comprising” have specific legal definitions and may also affect the quality of the NLP analysis.
- the server may analyze the tokens and determine that a line of a claim should be segmented into different claim segments and then reanalyzed.
- the claim segments are a consecutive list (i.e., an array) or NLP tokens that can be converted into individual sentences by the system 300 and generally form discrete concepts.
- the claim segments are generally classified into an active phrase, a passive phrase, and a linking phrase.
- An active phrase includes a root word that is a gerund verb.
- a segment that forms the phrase “transmitting information” comprises a token “transmitting” that has a dependency label of root and a second “information” that has a dependency label of clausal subject.
- the root verbs will generally be gerund verbs.
- the system 300 could receive present tense verbs and segment the claims in a substantially identical manner.
- there may be an adpositional phrase (e.g., “after receiving the content,” “in response to receiving the content, etc.) that modifies the root verb.
- the active phrase generally includes a direct object linked to the gerund verb and does not include a noun having a dependency label of nominal subject.
- a passive phrase includes a subject that that further defines a concept in another active phrase and generally includes both a nominal subject and a clausal subject.
- the root word may be a present tense or past tense verb.
- the verb can also be in active form.
- a segment that forms the passive phrase “the information includes a power transmission level” comprises a root word of “includes,” which a present tense verb.
- the information is a singular noun that has a dependency label of nominal subject and “a power transmission level” is a clausal subject.
- a linking phrase does not include content and provides context that links two claim segments.
- the linking phrase “the processing of the data comprises” further indicates that content after the linking phrase is linked to and modifies “processing the data.”
- the server 304 creates portions of text by excluding some of the common terms that affect the NLP analysis and transmits the portion of text to the NLP server 306 at step 324 .
- the text transmitted at step 324 may also include identifying information to facilitate synthesis of the NLP tokens.
- the NLP server 306 processes the text into NLP tokens and transmits a second set of tokens to the server 304 with the identification information at step 328 .
- the identification information transmitted to the NLP server 306 at step 324 may be different than identification information transmitted at step 316 .
- text transmitted at step 324 may be in the form of a key-value pair with the key corresponding to the token ID of the first token in the text.
- the server 304 synthesizes the first set of tokens and the second set of tokens into a complete set of tokens in step 320 .
- the complete set of tokens corresponds to the entirety of the claim and includes the common terms.
- the server 304 transmits the complete set of tokens to the client 302 (i.e., the application executing on the client 302 ) at step 332 .
- the client application which will be further described below with respect to FIG. 5 , allows the NLP tokens to be rearranged in a flowchart user interface based on user input.
- the steps that should be illustrated in a flowchart are not necessarily explicit in a claim.
- a claim is a condition-action sequence (e.g., if something exists, perform a function)
- the claim implicitly recites two actions: the determining of the condition and the action that is performed based on the condition. Therefore, in some cases, it is beneficial to allow a user to input additional actions that should be incorporated into a flowchart and its corresponding description.
- the application may allow the user to input additional language. That is, the application enables the user to input supplemental text that is separate from the text of the claims at step 334 .
- the application executing on the client 302 may transmit the supplemental text to the server 304 at step 336 .
- the server 304 transmits the text to the NLP server 306 at step 338 . In this case, the server does not provide identifying information because the server 304 will not necessarily need to resynthesize the NLP tokens.
- the NLP server 306 processes the text into NLP tokens at step 340 and transmits the tokens to the server at step 342 .
- the server 304 transmits the tokens to the client 302 at step 344 .
- the client 302 selects at least one template that is used to configure a patent specification.
- step 346 is only illustrated as an example and can occur prior to claim analysis and tokenization described above or at other stages of the present technology.
- the client 302 transmits a request for the template to the server 304 at step 348 .
- the server 304 replies with the at least one template at step 350 .
- the template includes static information that may be updated based on the user's manipulation of the client application.
- a template can include standard boilerplate, a blank drawing that is inserted to be a placeholder, a flowchart description style, a client specific drawing that is relevant to many of that particular client's patent applications, and so forth.
- the template may insert the content into multiple sections of the patent specification.
- a template that is related to blank diagram that serves as a placeholder may only insert a blank description into a drawing description section and a description section.
- a client specific system overview may include different regions related to background, technical field, summary, and description.
- the templates may include a corresponding section that identifies entities associated with the claims.
- the entities may be hardware components that the user can link to via a claim segment, which may also be used to compose new claims based on the method claims input into the system 300 .
- the user operates the application on the client 302 to generate specification data.
- a flowchart user interface is presented to the user and allows the user to organize claim segments in a manner that will be used to visually describe the flowchart, which will be further described below with respect to FIGS. 6 to 10 .
- the user is able to select different templates, perform client specific functions, and so forth to generate the specification data.
- the specification data may include different data structures that are used to generate the specification document and may include, for example, user authored claims, application composed claims, a list of templates and data associated with the templates, flowchart data for generating descriptions of the flowchart, descriptions of the flowchart, static data (e.g., docket number, inventor names, client information, etc.) and so forth.
- the specification data 354 is transmitted to the server 304 at step 354 because, in this example, the client application is executing within the browser sandbox and is unable to access system resources. Accordingly, the server 304 receives the specification data, generates a document based on the specification data, and generates drawings based on the specification data. The server 304 then transmits the document and drawing to the client 302 at step 358 .
- the application may be executing within document processing application (i.e., Microsoft Word®, Libre Office, etc.) and may generate the document on the client 302 itself using an API.
- an improved NLP analysis method that identifies common terms that causes NLP errors.
- the quality of the NLP analysis is improved and the NLP tokens can be easily dissected into different claim segments that will form complete sentences in the generated patent specification.
- the disclosure can also be applicable to content that relates to a sequence of operations.
- the disclosure can be applied to a flow diagram illustrating communication between devices, software processes, services, or any other type of communication.
- the instant disclosure can also be applied to legal and/or formal documents for identifying a sequence, an order, a succession, conditional logic, decision trees, and so forth.
- FIG. 4 illustrates an example method 400 for segmenting the text into NLP tokens and claim segments that are used by a client application for creating a patent specification.
- the descriptions below relate to aspects that can be integral to a user application or separate from the user application (e.g., implemented on a server).
- the method 400 is described separately from other aspects that relate to the machine-user interface.
- the 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 the 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.
- the method 400 includes transmitting text associated with patent claims to a server for NLP analysis at step 402 .
- the processor 1305 illustrated in FIG. 13 may transmit text associated with patent claims to a server for NLP analysis.
- the patent claims comprise an independent claim and at least one dependent claim that form a set of claims. While it is possible to use a single independent claim, a set of claims generally includes at least one dependent claim.
- the method 400 includes receiving NLP tokens from the server based on the NLP analysis at step 404 .
- the processor 1305 illustrated in FIG. 13 may receive NLP tokens from the server based on the NLP analysis.
- the method 400 includes generating a token identifier for each NLP token at step 406 .
- the processor 1305 illustrated in FIG. 13 may generate a token identifier for each NLP token.
- the token identifier includes a claim number, a line number, and a token number within the line.
- the claim number, line number, and token number are each encoded into the token identifier using different base numbers or Gödel numbering.
- the token number within the line indicates an order of the token within the line.
- the method 400 includes identifying common terms in the NLP tokens that affect the NLP analysis at step 408 .
- the processor 1305 illustrated in FIG. 13 may identify common terms in the NLP tokens that affect the NLP analysis.
- the common terms comprise at least one of comprising, comprises, and a phrase to indicate a definition.
- the common terms comprises patent terms having a legal definition or provide a context for a claim segment and further explain the content of the claim.
- the method 400 includes, in response to identifying the common terms, generating segments of text based on the common terms and transmitting the segments of text to the server for a second NLP analysis at step 410 .
- the processor 1305 illustrated in FIG. 13 may, in response to identifying the common terms, generate segments of text based on the common terms and transmit the segments of text to the server for a second NLP analysis.
- the method 400 includes receiving a second set of NLP tokens from the server based on the second NLP analysis at step 412 .
- the processor 1305 illustrated in FIG. 13 may receive a second set of NLP tokens from the server based on the second NLP analysis.
- the method 400 includes synthesizing the NLP tokens and the second set of NLP tokens into a complete set of NLP tokens corresponding to the text associated with the patent claims at step 414 .
- the processor 1305 illustrated in FIG. 13 may synthesize the NLP tokens and the second set of NLP tokens into a complete set of NLP tokens corresponding to the text associated with the patent claims.
- the passive phrase includes a present tense verb and a nominal subject.
- the active phrases comprise a gerund verb that corresponds to a root word of the claim segment based on the NLP analysis.
- the passive phrase further defines a gerund verb or an object in another claim segment.
- the generating of the claim segments comprises identifying content that links different claims and identifying linking phrases that link different claim segments.
- each claim segment corresponds to an active phrase or a passive phrase.
- the complete set of NLP tokens includes claim segments, each claim segment comprising a plurality of NLP tokens.
- the common terms are excluded from any of the claim segments.
- the synthesizing of the tokens at step 414 comprises identifying a relationship between different claim segments based on the linking phrases.
- the processor 1305 illustrated in FIG. 13 may identify a relationship between different claim segments based on the linking phrases.
- a linking phrase does not include content, but simply provides context that links two segments.
- a preamble of a claim may include “the processing of the data comprises,” which further indicates that content after preamble is a linked to and modifies “processing the data.”
- the method 400 includes extracting whitespace for each line of the patent claims at step 416 .
- the processor 1305 illustrated in FIG. 13 may extract whitespace for each line of the patent claims.
- a claim is required to be a single sentence, but a claim is generally broken into individual lines using a line break to provide structure to the claim and separate different clauses.
- Whitespace includes spaces, tabs, line breaks that may be used to provide visual formatting to the claim.
- the underlying text may be separated into several different XML elements and whitespace may be represented by properties of the XML, elements.
- a paragraph element is represented in OpenXML (i.e., a word .docx file) as a ⁇ w:p> element with the “w” identifying the namespace and the “p” identifying a paragraph element.
- the paragraph element can include child XML elements such as a paragraph properties element (i.e., a ⁇ w:pPr> element) that provides whitespace such as, the indent of the first line, the left margin, a tab element, a hanging indent, etc.
- the method 400 includes identifying relationships between the claim segments based on the whitespace, a claim number associated with the claim segment, and a claim dependency at step 418 .
- the processor 1305 illustrated in FIG. 13 may identify relationships between the claim segments based on the whitespace, a claim number associated with the claim segment, and a claim dependency.
- claim lines (or recitations) may include whitespace to further indicate that the recitation is related to the prior subject matter in the claim.
- the method 400 includes determining an order of a portion of the claim segments based on the relationships of the claim segments, the order corresponding to an order of a flowchart that is presented to a user, at step 420 .
- the processor 1305 illustrated in FIG. 13 may determine an order of a portion of the claim segments based on the relationships of the claim segments, the order corresponding to an order of a flowchart that is presented to a user.
- the user provides input into the flowchart to generate a portion of the specification data.
- the method 400 includes receiving supplemental text that is input separately from the claims at step 422 .
- the processor 1305 illustrated in FIG. 13 may receive supplemental text that is input separately from the claims.
- the user may enter text into a component to create a user-defined segment for the flowchart user interface as described below.
- the method 400 includes transmitting the supplemental text to the server at step 424 .
- the processor 1305 illustrated in FIG. 13 may transmit the supplemental text to the server.
- the method 400 includes receiving a third set of NLP tokens from the server corresponding to the supplemental text at step 426 .
- the processor 1305 illustrated in FIG. 13 may receive a third set of NLP tokens from the server corresponding to the supplemental text.
- the method 400 includes receiving specification data generated based on user manipulation of the claim segments at step 428 .
- the processor 1305 illustrated in FIG. 13 may receive specification data generated based on user manipulation of the claim segments.
- the specification data is generated based on user input into a client application to rearrange the initial ordering of the claim limitations that were originally determined based on the NLP analysis and logical analysis described above.
- a method associated with the creating the specification data is illustrated in FIG. 5 and examples of the user interface and corresponding features are illustrated in FIGS. 6 to 10 and further described below.
- the specification data comprises flowchart data that is generated at the client application based on user manipulation.
- the specification data identifies a list of templates and data related to the templates (e.g., Figure number) as illustrated in FIGS. 10 and 12 .
- the specification data includes different data that is generated by the client 302 and is used by the server 304 to generate the specification.
- the method 400 includes generating a patent specification that comports with a plurality of procedural requirements based on the specification data at step 430 .
- the processor 1305 illustrated in FIG. 13 may generate a patent specification that comports with a plurality of procedural requirements based on the specification data.
- the patent specification can also include a set of drawings.
- the generating of the specification at step 430 may include determining that the specification data includes custom content for a first template in a list of templates.
- the processor 1305 illustrated in FIG. 13 may determine that the specification data includes custom content for a first template in the list of templates.
- the generating of the specification at step 430 further comprises extracting first content from a document corresponding to the first template.
- the generating of the specification at step 430 comprises generating text in a description section of the patent specification based on at least one claim.
- the processor 1305 illustrated in FIG. 13 may generate text in a description section of the patent specification based on at least one claim.
- the description in this case corresponds to the flowchart description of a drawing and specifically links the description to the flowchart with a reference numeral.
- the generating the specification at step 430 further includes determining whether the specification data indicates that a claim segment is linked to a structure that performs an action corresponding to the claim segment.
- the method further includes generating text corresponding to the claim segment that indicates that the structure performing the action of the claim segment.
- the processor 1305 illustrated in FIG. 13 may determine whether the specification data indicates that a claim segment is linked to a structure that performs an action corresponding to the claim segment and may generate text in the flowchart description that indicates the structure performing the action of the claim segment.
- the action of the text has a different verb tense than the action in the claim segment and the text includes a reference numeral of the structure that identifies the structure in a drawing.
- the specification is generated based on a user input into the user interfaces (e.g., the control 652 in FIG. 6 ) that links a hardware diagram to a claim segment in the flowchart user interface.
- the description when generating the description related to the flowchart, the description identifies the step in the flowchart and provides explicit support to a hardware structure that also performs this step.
- the generating the specification at step 430 further includes synthesizing the first content and the custom content into merged content for inserting the merged content into the generated patent specification.
- the processor 1305 illustrated in FIG. 13 may synthesize the first content and the custom content into merged content. For instance, based on previous input identifying a specific structure in the client application, the corresponding action in the flowchart user interface can be inserted into text associated with the hardware. That is, the link used in the control, which is illustrated as control 652 in FIG. 6 , can simultaneously generate text for a flowchart and text associated with the hardware figure.
- a transmitter X10 is selected to perform “transmitting power level information”
- the description associated with the transmitter X10 can be modified to indicate that the transmitter X10 transmits the power level information.
- this input can also be used to modify the descriptions of the flowchart, thereby allowing a single user interface to change different content in different sections of the patent specification.
- processor 1305 can receive an input that will indicate at that at least one claim from the input claims should be excluded from a claim section of the patent specification. This results in a claim being be used to generate text for the description, but is expressly excluded from the claims in the specification generated at step 430 .
- This can be a beneficial feature whereby an input claim set can articulate all concepts that a user desires to be processed by NLP server 130 and included in the patent document, while focusing the claim set with the most useful claims in the claim set.
- the generating of the patent specification at step 430 comprises generating a preliminary amendment based on the specification data.
- the processor 1305 illustrated in FIG. 13 may generate a preliminary amendment based on the specification data.
- additional claims can be used generate the specification, but can be removed via preliminary amendment to prevent incurring excess claim fees.
- the method 400 includes transmitting the patent specification to a client application that generates the specification data at step 432 . Further, the method 400 can also transmit a set of drawings to the client. For example, the processor 1305 illustrated in FIG. 13 may transmit the patent specification to a client application that generates the specification data. In some cases, the method 400 may be executing locally on a client machine and the client machine would therefore create the document or insert the content of the patent specification into an existing document that is open in a word processing application.
- the present technology provides an interface to receive inputs to rearrange the initial ordering of the claim limitations that were originally determined by NLP server and to include supplemental text in addition to the language in the input claims.
- FIG. 5 illustrates an example method 500 for sequencing claim segments to generate a patent specification using examples of various aspects of a dynamic user interface illustrated in FIGS. 6 to 10 .
- the descriptions below relate to a client application that is executing and outputting a flowchart user interface to allow the user to visually draft the patent specification.
- example method 500 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 500 . In other examples, different components of an example device or system that implements the method 500 may perform functions at substantially the same time or in a specific sequence.
- the method includes receiving NLP tokens from an NLP analysis of patent claims at step 502 .
- the processor 1305 illustrated in FIG. 13 may receive NLP tokens from an NLP analysis of patent claims.
- the patent claims comprise an independent claim and at least one dependent claim that form a set of claims.
- the method 500 includes generating claim segments from the NLP tokens at step 504 .
- the processor 1305 illustrated in FIG. 13 may generate claim segments from the NLP tokens.
- each claim segment corresponds to an active phrase or a passive phrase.
- the passive phrase further defines a gerund verb or an object in another claim segment.
- the active phrase comprises a gerund verb that corresponds to a root word of the claim segment based on the NLP analysis.
- the method 500 includes selecting a portion of claim segments to display at step 506 .
- the processor 1305 illustrated in FIG. 13 may select a portion of claim segments to display.
- the method 500 includes displaying a flowchart including the portion of the claim segments arranged in a first order at step 508 .
- the processor 1305 illustrated in FIG. 13 may display a flowchart including the portion of the claim segments in the first order.
- An example of a flowchart displaying an order of claim segments is illustrated in FIGS. 6 and 7 .
- the method 500 comprises displaying a claim area that illustrates the set of claims and claim segments corresponding to the set of claims.
- the processor 1305 illustrated in FIG. 13 may display a claim area 702 .
- An example claim area 702 is depicted in FIG. 7 and provides visual feedback to facilitate user operation.
- the method 500 includes receiving an input to change the first order of the claim segments into a second order that is different from the first order at step 510 .
- the processor 1305 illustrated in FIG. 13 may receive an input to change the first order of the claim segments into the second order that is different from the first order.
- the user interface allows the user to drag and drop claim segments in the flowchart to form complex relationships.
- the user input can also be other operations such as a click operation that in a conditional branch that identifies the order of claim segments.
- the input comprises dragging the second claim segment into the flowchart, and, after the second claim segment is dragged into the flowchart, a first graphical demarcation is applied to the second claim segment in the claim area.
- the input comprises dragging the third claim segment into the flowchart, and, after the third claim segment is dragged into the flowchart, the first graphical demarcation is applied to the third claim segment in the claim area.
- the demarcations is the flowchart user interface provide visual information regarding a state of the claim segment. This visual information allows the user to understand the organization of the flowchart to understand how the flowchart itself will be used to draft the patent specification.
- FIG. 7 illustrates a first graphical demarcation (indicated by the border) applied to claim segments 706 , 708 , and 714 and indicates that each claim segment is displayed in the flowchart user interface (i.e., the executing application and not the patent application or corresponding drawings).
- FIG. 7 illustrates a second graphical demarcation applied to a claim segment 704 in the claim area indicates that the claim segment 704 comprises active language and is not displayed in the flowchart.
- FIG. 7 illustrates a third graphical demarcation applied to claim segments 710 and 716 in the claim area indicates that each segment comprises passive language and is not displayed in the flowchart.
- the method 500 includes displaying the claim segments in the flowchart in the second order at step 512 .
- the processor 1305 illustrated in FIG. 13 may display the claim segments in the flowchart in the second order.
- the method 500 includes receiving an input to link another drawing with the current flowchart at step 514 .
- the processor 1305 illustrated in FIG. 13 may receive an input to link another drawing with the current flowchart.
- FIG. 6 below illustrates a control 654 that allows selection of another drawing which will permit cross reference between the flow chart and the another drawing when the patent specification is later created.
- the method 500 includes identifying a structure in the linked drawing.
- the processor 1305 illustrated in FIG. 13 may identify a structure in the linked drawing.
- a template file associated with the drawing may identify a plurality of structures that are selectable in the user interface.
- the method 500 includes updating controls associated with the claim segments at step 518 .
- the processor 1305 illustrated in FIG. 13 may update controls associated with the claim segments.
- the structures identified in the template file may populate the controls located in the nodes to allow selecting of a structure that performs the action corresponding to the claim segment.
- the method 500 includes receiving an input in a control associated with a claim segment at step 520 .
- the processor 1305 illustrated in FIG. 13 may receive an input in a control associated with a claim segment.
- the claim segment corresponding to the control is then associated with performing the action.
- the text of the patent specification is generated based on the specification data, the text will explicitly link the action associated with the claim segment with the structure.
- FIG. 6 illustrates controls 652 that allows linking a structure to a claim segment that a user can select different structures based on the drawing selected in control 654 .
- the method 500 includes receiving a second input to indicate that language of a second claim segment partially defines a first claim segment that is displayed within the flowchart at step 522 .
- the processor 1305 illustrated in FIG. 13 may receive a second input to indicate that the language of a second claim segment partially defines a first claim segment that is displayed within the flowchart.
- FIG. 8 illustrates that claim segment 812 and claim segment 814 can be dragged into a node 800 to further define claim segment 802 of the node 800 .
- the method 500 includes displaying a first sub-flowchart within the first claim segment in the flowchart at step 524 .
- the processor 1305 illustrated in FIG. 13 may display a first sub-flowchart within the first claim segment in the flowchart.
- a first drawing is generated from the specification data that corresponds to the flowchart and a second drawing is generated from the specification data that corresponds to the first sub-flowchart.
- the first sub-flowchart further defines the action associated with the first claim segment.
- FIG. 8 illustrates a sub-flowchart that further defines claim segment 802 .
- the method 500 includes receiving a third input to indicate that the language of a third claim segment partially defines the first claim segment displayed within the flowchart at step 526 .
- the processor 1305 illustrated in FIG. 13 may receive a third input to indicate that the language of a third claim segment partially defines the first claim segment displayed within the flowchart.
- the method 500 includes displaying a second sub-flowchart within the first claim segment in the flowchart at step 528 .
- the processor 1305 illustrated in FIG. 13 may display a second sub-flowchart within the first claim segment in the flowchart.
- a first drawing is generated from the specification data that corresponds to the flowchart
- a second drawing is generated from the specification data that corresponds to the first sub-flowchart
- a third drawing is generated from the specification data that corresponds to the second sub-flowchart.
- the second sub-flowchart also further defines the action associated with the first claim segment.
- the first sub-flowchart and the second sub-flowchart may be different species and may be mutually exclusive and multiple drawings may be generated based on the input into the flowchart user interface.
- FIG. 8 illustrates a tabbed interface for allowing different sub-flowcharts to be associated with a single claim segment 802 .
- the method includes receiving an input to select at least one claim from the set of claims at step 530 .
- the processor 1305 illustrated in FIG. 13 may receive an input to select at least one claim from the set of claims.
- at least one claim is excluded from a claim section of the patent specification. As noted above, this results in a claim being be used to generate text for the description, but is expressly excluded from the claims in the specification.
- the method 500 includes determining whether an identifier for the patent specification corresponds to a first entity at step 532 .
- the processor 1305 illustrated in FIG. 13 may determine whether an identifier for the patent specification corresponds to a first entity.
- the identifier is used to execute a client-specific module 1014 to perform common events that are particular to that client. For example, a first client may require multiple timing diagrams, a second client may require a circuit diagram having a similar layout, and a third client may require an engine illustration that requires different labels.
- the method 500 includes, when the identifier corresponds to the first entity, executing a module exclusively associated with the first entity at step 534 .
- the processor 1305 illustrated in FIG. 13 may, when the identifier corresponds to the first entity, execute a module exclusively associated with the first entity.
- the method 500 includes, in response to user input into the module, generating client specific data based on the module.
- the processor 1305 illustrated in FIG. 13 may, in response to user input into the module, generate a portion of the specification data based on the module, the portion of the specification data be used to generate a drawing specific to the first entity.
- the client specific data is used to generate a drawing and a corresponding description specific to the first entity at step 536 .
- the method 500 includes generating specification data used to create a patent specification.
- the patent specification includes a description of the flowchart based on the second order at step 538 .
- the specification data may include the client specific data generated at step 536 .
- the processor 1305 illustrated in FIG. 13 may generate specification data used to create a patent specification, the patent specification including a description of the flowchart based on the second order.
- the specification data includes all data necessary for generating a specification.
- the specification data may identify at least one template that is used to generate a description and drawings.
- the specification data may also include text generated at the client application that can be injected into the at least one template.
- the drawing may include a flowchart and at least one sub-flowchart that further defines nodes within the flowchart.
- multiple flowcharts may be generated based on using a bypass node, which is described below in connection with FIGS. 9 A to 9 C .
- the generating of the specification data comprises composing a device claim based on the independent claim.
- the device claim includes the text indicating that the structure performs the action corresponding to the first claim segment.
- the specification data includes data related to a preliminary amendment that is created to cancel at least one claim from the set of claims.
- the specification data comprises settings data related to options for controlling the generation of the patent specification.
- the settings data may comprise any variation of the specification such as using “ Figure” in lieu of “FIG,” or any other stylistic preference.
- the setting data may include a flag indicating two spaces between sentences.
- the settings data is generally based on preferences. However, the settings data may also include content related to generating the various descriptions of the flowcharts.
- the flowchart may be described in a breadth first or a depth first manner.
- the settings data initially set in the application based on another template file that forms the underlying document for a particular client and includes data such as header text for the various headers in the specification, fonts, styles, margins, etc.
- the specification data is used by an application or a server to generate a specification and drawings.
- the method 500 may include additional steps not explicitly identified above.
- the method 500 may include identifying a first occurrence of a noun object (i.e., an n-gram) within the claim segments based on the order of the claim segments.
- the method 500 may insert language to indicate to the user to add additional description regarding this term.
- FIG. 6 illustrates an example user interface 600 for arranging claim segments to generate a patent specification and drawings.
- the application is executing in the browser environment.
- the application could be a stand-alone application that natively executes in the operating system or an application add-in (e.g., a Microsoft Word® add-in).
- the rendered view from the browser displays the user interface 600 that corresponds to a flowchart user interface.
- the user interface comprises a grid having a plurality of nodes (i.e., processes and other operations within the flowchart) and edges (i.e., arrows) between the nodes to illustrate a flowchart.
- node 602 , node 604 , node 606 , node 608 , node 610 , and node 612 are displayed in the grid.
- the user interface 600 may include start and end nodes.
- Each node illustrated in FIG. 6 is associated with at least one claim segment. Specifically, claim segment 614 is displayed via node 602 , claim segment 616 is displayed via node 604 , claim segment 618 is displayed via node 606 , claim segment 620 is displayed via node 608 , claim segment 622 is displayed via node 610 , and claim segment 624 is displayed via segment 612 .
- the nodes serve as visual containers for the claim segments, enable complex user inputs, and allow complex associations of the claim segments to be simultaneously formed and displayed.
- Each node displayed in FIG. 6 is associated with at least one drop zone for receiving a claim segment as an input and change an order of the flowchart illustrated in the user interface 600 .
- each node includes a drop zone below the node and a drop zone adjacent to the node.
- node 602 is associated with drop zone 626 and drop zone 628
- node 604 is associated with drop zone 630 and drop zone 632
- node 606 is associated with drop zone 634 and drop zone 636
- node 608 is associated with drop zone 638 and 640
- node 610 is associated with drop zone 642 and drop zone 644
- node 612 is associated with drop zone 646 and 648 .
- the drop zones simultaneously provide a visual order to the flowchart and also enable dragging and dropping of segments to reorder the flowchart.
- drop zone 626 and drop zone 628 are associated with node 602 .
- the drop zone 628 is sequentially links the node 602 to node 604 by virtue of the arrow (i.e., edge) located within the drop zone 628 .
- dropping another claim segment into drop zone 628 informs the application that the dropped segment is should be positioned between nodes 602 and 604 .
- the drop zones allow a claim segment to be dragged and dropped into the corresponding drop zone, which inserts the claim segment at the corresponding location and allows the user to manipulate the claim segments to visually construct a flowchart using claim segments.
- FIG. 6 illustrates claim segment 618 as a node preceding claim segment 620 .
- FIG. 6 also illustrates that claim segment 622 is displayed as a branch of claim segment 618 .
- This branch is the result of claim user interface 600 receiving a drag and drop of segment 622 into drop zone 634 .
- the method illustrated in the user interface 600 can proceed to either claim segment 620 or claim segment 622 .
- the user interface 600 has created an additional column in the user interface 600 for displaying the claim segment 622 .
- a drop event could still be received in drop zone 634 to position another claim segment between claim segment 618 and claim segment 622 .
- a claim segment can be received into drop zone 636 to cause the claim segment to be positioned between claim segment 618 and claim segment 620 .
- the user interface 600 also allows the complex display of the various claim segments.
- a passive claim segment 650 may be displayed within node 602 to visually illustrate that the passive claim segment 650 further defines subject matter within claim segment 614 .
- claim segment 650 is dragged and dropped into claim segment 614 .
- dropping an active claim segment into claim segment 614 will create an embedded sub-flowchart within the node 602 .
- the node 602 may also illustrate a control 652 for selecting a device that performs the action in claim segment 614 .
- the user interface 600 also includes a control 654 that allows a corresponding figure to be selected. Using the control 654 , the user is able to select the figure (e.g., Figure A in this example) that includes a list of structures (e.g., XX 210 selected in control 652 , XX220 selected in node 606 , etc.) that can populate the control 652 .
- the claim segment 614 can be linked to structures in different drawings in connection with generating the patent specification.
- the user interface 600 displays a flowchart user interface that allows the user to intuitively drag and drop various claim segments in a simple manner. As such, the user is able to quickly and accurately order the claim segments, which also changes the underlying data structure and affects how the description of the flowchart will be written by the application.
- the control 652 and control 654 allow the user to select a hardware figure and corresponding structure, which will be used to generate the specification. In other examples, by selecting the structure via the control 652 and control 654 , a claim can be composed to include that the selected structures perform the corresponding action.
- Nodes within conditional branches may also include an additional control for identifying a return node and creating a return arrow 658 that illustrates the flow of the method.
- node 622 is the final node of the branch and therefore includes a return control 656 to indicate the next node within another branch.
- the node 622 has been changed to return the flow of the illustrated method to label X60 corresponding to node 612 .
- FIG. 7 illustrates an example illustration of a user interface 700 for arranging claim segments and includes a claim panel 702 that displays claim segments embedded within the claims based on a feedback scheme.
- FIG. 7 illustrates three claims (A, B, and C).
- Claim A includes claim segment 704 , claim segment 706 , claim segment 708 , and claim segment 710 .
- claim A incudes a common word 712 that is not allocated to any claim segments and any trailing or leading punctuation or whitespace is excluded from the claim segments.
- Claim B includes claim segment 714 and claim C includes claim segment 716 .
- the user interface 700 allows the user to drag a claim segment from the claim panel 702 and drop a claim segment as described above with reference to FIG. 6 .
- claim segment 714 was previously dragged to precede claim segment 706 in the flowchart user interface.
- claim segment 704 is not displayed because it precedes claim segment 714 within user interface 700 and can be viewed by scrolling.
- dashed lines illustrated in FIG. 7 illustrate claim segment 706 , claim segment 708 , and claim segment 714 and their respective positions in the user interface 700 and the claim panel 702 .
- the claim segment 706 , claim segment 708 , and claim segment 714 may also include a label (e.g., a reference numeral) that is used to label each active claim segment in the user interface 700 and the claim panel 702 .
- a label e.g., a reference numeral
- claim segment 706 is labeled with YY3 and claim segment 714 is labeled with YY1.
- Claim segment 718 which precedes claim segment 714 in the user interface 700 , is not illustrated in the claim panel 702 and may either be provided from another claim that is not illustrated in claim panel 702 or may be separately input using, for example, a supplemental segment component for allowing the user to manually create claim segments.
- claim segment 720 and claim segment 722 are not illustrated in the claim panel 702 and may be associated with claims not illustrated in claim panel 702 (i.e., the claims can be viewed if the claim panel 702 is scrolled downward) or may be separately input and are not found within the claims.
- the claim segments illustrated in the claim panel 702 may be color coded to provide visual feedback.
- the claim segment when a claim segment is allocated (i.e., assigned a position) within the user interface 700 , the claim segment may be coded with a first color.
- claim segment 704 , claim segment 706 , claim segment 708 , and claim segment 714 are allocated within the user interface 700 (with claim segment 704 not being viewable based on scrolling the user interface 700 ).
- the various claim segments can be added, moved, and removed from the flowchart. When a corresponding claim segment is deleted from the flowchart (using the delete icon), the claim segment is referred to as unallocated.
- Claim segment 710 and claim segment 716 which are displayed in the claim panel 702 , are not allocated and are color coded to provide additional feedback.
- claim segment 710 is coded with a second color to indicate that claim segment 710 is an active phrase and is not allocated within the user interface 700 .
- Claim segment 716 is coded with a third color to indicate that claim segment 716 is a passive phrase and is also not within the user interface 700 .
- Claim segment 710 and claim segment 716 also do not include a reference label because they are not allocated within the user interface 700 .
- the claim segments may include a delete icon that allows the claim segment to be unallocated from the user interface 700 .
- the user interface 700 would recalculate the flowchart illustrated in the user interface 700 and change the feedback provided by the corresponding claim segment in the claim panel 702 .
- the nodes may each contain a grouping option that allows nodes to be combined into groups or combined with a previous paragraph when the specification is drafted.
- a grouping option 724 for claim segment 720 and a grouping option 726 are illustrated and remaining nodes are not illustrated with this option for convenience.
- the specification generation groups these claim segments and drafts the specification based on the grouping. That is, the claim segments 720 and 722 may be described in a single paragraph for simplicity.
- the claim segments in the user interface 700 may be configured to be excluded from the final set of claims.
- the reference label in the claim segment 722 may be selected to indicate that this subject matter can be excluded from the final claims.
- the reference label is replaced by an option 728 that is unchecked to indicate that the claim associated with the claim segment 722 is to be omitted from the final claims.
- the option 728 is further selected, the claim corresponding to the claim segment 722 would be included.
- the option 728 may also be used to suppress a node from being created in a corresponding a flowchart drawing (i.e., a drawing document including the flowchart).
- the claim panel 702 provides a visual feedback scheme that is used in conjunction with the user interface 700 to allow the user to easily manipulate the various claim segments to visually draft the specification using a drag and drop user interface.
- additional user interface options are illustrated that further allow finer control of the specification and allowing the user to include content generated from the input claims while simultaneously excluding these claims from the finalized claims.
- the user is able to provide a detailed set of preliminary claims to effectively draft all necessary details, then selectively remove claims from the claims section in the generated patent specification.
- a separate component can be provided to allow claims to be composed into different statutory classes using the claim segments and various templates.
- the user would be able to select a final set of claims based on the set of preliminary claims and the composed claims.
- the application could manage the claim content using the user interface to ensure correct claim numbering, correct claim dependency, and so forth.
- FIG. 8 illustrates an example node 800 that allow complex manipulation of claim segments to create complex descriptions in the patent specification.
- the node 800 can be associated with claim segment 802 , which has been allocated reference label YY1 and includes a delete icon 804 and a control 806 for selecting a structure to perform the action associated with claim segment 802 .
- the node 800 can include a tab interface 810 to allow other active claim segments that further define claim segment 802 .
- claim segment 812 and claim segment 814 further define a first embodiment illustrated in the first tab 816 . That is, a claim segment 812 further defines claim segment 802 by recited an action that is encompassed within claim segment 802 .
- the first embodiment illustrated in tab 816 can include drop zone 818 , drop zone 820 , drop zone 822 , drop zone 824 , and drop zone 826 to allow other claim segments to be dropped into the first tab 816 .
- the node 800 may contain a separate sub-flowchart interface fully embedded within a claim segment.
- each segment within the node can also include a separate flowchart interface, allowing unlimited recursion of flowcharts.
- the tab interface 810 can also include multiple tabs such as second tab 828 and third tab 830 in this example.
- the claim segment 812 is dragged and dropped into the claim segment 802 (or node 800 ).
- another segment (not shown) is dragged into the claim segment 802 (or node 800 ).
- the second tab 828 and third tab 830 allow different claim segments to be inserted, thereby allowing multiple embodiments that are mutually exclusive to be provided. Moreover, when generating the specification, the different embodiments illustrated in the first tab 816 , second tab 828 , and third tab 830 will be described separately in the patent specification, thereby allowing the system to generate a more accurate specification and require less human editing and revision.
- FIGS. 9 A, 9 B, and 9 C illustrate an example node 900 that allows different alternatives.
- FIGS. 9 A, 9 B, and 9 C illustrate a bypass segment that allows optional actions to be defined in the user interface.
- the node 900 includes a tab interface including a first tab 902 , second tab 904 , and a third tab 906 for illustration purposes.
- the first tab 902 comprises an arrow 908 that corresponds to an edge in graph theory and simply indicates that no further actions occur at node 900 . That is, in the first tab 902 , the node 900 is bypassed in the execution of the flowchart.
- the node 900 displays the second tab 904 illustrated in FIG. 9 B .
- the second tab 904 is associated with a claim segment 910 , and indicates an optional node that can be executed in the flowchart.
- the third tab comprises a flowchart user interface 912 that is embedded and allows additional claim segments to be inserted and manipulated based on dragging and dropping into the claim segments and drop zones as noted above.
- the application may be configured to generate different flowcharts using the bypass segment in node 900 .
- the application may also be configured to generate sub-flowcharts linked to the main flowchart similar to FIG. 8 .
- FIGS. 8 , 9 A, 9 B, and 9 C illustrate that the nodes allow optional segments and optional sub-flowcharts to be defined to thereby allow more complex associations with the claim segments to be defined.
- the user interface is able to represent an entire set of method claims regardless of the complexity of the method claims.
- the system may also generate a separate drawing for each sub-flowchart or may generate additional flowcharts illustrating all variations of the flowcharts.
- the above examples illustrate simple flowcharts for clarity and conciseness.
- the user interfaces illustrated above can be embedded into nodes, thereby allowing unlimited complexity if required.
- at best one conditional branch is illustrated, but conditions can be linked (i.e., a switch operation) to allow unlimited complexity in the flowchart.
- the above user interfaces are referred to as directed acrylic graph (DAG) because the flow of the user interface does not allow a previous node to be revisited.
- DAG directed acrylic graph
- the instant disclosure is not limited to DAG and can be bidirectional, allowing previous nodes to be revisited (i.e., a loop).
- FIG. 10 illustrates a user interface 1000 that allows a user to provide input into the user interface 1000 to build a specification using point and click operations in conjunction with a client-specific module.
- the user interface 1000 illustrates a header region 1002 , a template region 1004 , and a specification region 1006 .
- the header region 1002 is related to a “wizard” or “stepper” component that allows the user to select different stages to control the creation of the patent specification.
- the header region 1002 dynamically adds and removes steps based on inputs received in interfaces prior to the presentation of user interface 1000 , inputs after the presentation of user interface 1000 , and inputs into the user interface 1000 .
- the user selects different templates that are used to generate the specification from the template region 1004 .
- the specification region 1006 generates a specification section corresponding to a template selected in the template region 1004 and provides some detail, such as the illustrated figure number (e.g., Figure A).
- the specification sections illustrated in the specification region 1006 generally are associated with illustrations, the specification sections can also include text-only regions such as a boilerplate related to a legal interpretation of a term.
- the text-only region can include text that is devised based on the administrative agency's guidance with respect to a particular legal issue (e.g., subject matter eligibility) or administrative issue that comports with the agency's guidance.
- the different specification sections can easily be rearranged in the specification region 1006 to allow the user to essentially point and click to create a specification.
- the example user interface includes a specification template 1008 related to a first method claim (claim A) and a specification template 1010 related to a second claim (claim C).
- the user is able to select either specification template 1008 and/or specification template 1010 , which then allows the user interface 1000 to add a module 1012 corresponding to that claim.
- the user selects the specification template 1008 , which causes the header region 1002 to dynamically insert a module 1012 for generating content associated with that claim.
- the module may be a flowchart user interface.
- claim B is not detected as a method claim and, therefore, the template region 1004 excludes any potential drawing related to a flowchart for claim B.
- the system may generate a flowchart based on a device or system claim using NLP.
- FIG. 10 also illustrates a client-specific module 1014 , which was added based on an identification of the client.
- the client is a legal entity (e.g., a corporation) or a person that would benefit from the operation of a module 1014 that is specific to their needs. That is, the application determines whether the patent specification to be generated corresponds to a specific client that has a client module for generating specification data. If the patent specification corresponds to the specific client, the client-specific module 1014 is inserted into the component for execution before or after the user interface 1000 .
- the client-specific module 1014 provides a user interface to creating specification data that is specific to that client.
- a client may have specific content that needs to be recreated and the client-specific module 1014 provides a user interface for generating the same.
- a first client may require multiple timing diagrams
- a second client may require a circuit diagram having a similar layout
- a third client may require an engine illustration that requires different labels.
- the client-specific module 1014 may generate specification data for creating a drawing and specification content.
- the client-specific module 1014 is tuned specifically for each client to provide better and more accurate specifications.
- FIG. 11 illustrates a flowchart of a method 1100 for generating a specification based on related application that is identified using NLP.
- the example method 1100 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 1100 . In other examples, different components of an example device or system that implements the method 1100 may perform functions at substantially the same time or in a specific sequence.
- the method 1100 includes transmitting text associated with patent claims to a server for NLP analysis, the patent claims comprising an independent claim and at least one dependent claim that form a set of claims at step 1102 .
- the processor 1305 illustrated in FIG. 13 may transmit text associated with patent claims to a server for NLP analysis, the patent claims comprising an independent claim and at least one dependent claim that form a set of claims.
- the method 1100 includes receiving NLP tokens from the server based on the NLP analysis and a list of objects that are identified in the text based on the NLP analysis at step 1104 .
- the processor 1305 illustrated in FIG. 13 may receive NLP tokens from the server based on the NLP analysis and a list of objects that are identified in the text based on the NLP analysis.
- the list of objects are n-grams (i.e., compound words) that are extracted from the claims.
- the method 1100 includes identifying generic labels in the list of objects that distinguish similar objects from each other at step 1106 .
- the processor 1305 illustrated in FIG. 13 may identify generic labels in the list of objects that distinguish similar objects from each other.
- the generic label may be an ordinal number (first, second, etc.), a past tense adjectival modifier (e.g., selected, displayed, etc.), and so forth.
- the method 1100 includes, for each similar object, removing the generic labels to create a single object corresponding to each similar object at step 1108 .
- the processor 1305 illustrated in FIG. 13 may, for each similar object, remove the generic labels to create a single object corresponding to each similar object.
- the method 1100 includes generating a term frequency (TF) for a set of first objects based on the list of objects at step 1110 .
- the processor 1305 illustrated in FIG. 13 may generate a term frequency (TF) for a set of first objects based on the list of objects. That is, the generic label is stripped from the n-gram to distill the n-grams to their most basic form and count the most frequent n-grams.
- the method 1100 includes searching a patent application repository based on the TF of the set of first objects at step 1112 .
- the processor 1305 illustrated in FIG. 13 may search a patent application repository based on the TF of the set of first objects.
- the searching of the patent application repository is based on a comparison of claims.
- the method 1100 comprises comparing the TF of the set of first objects with a second list of objects, the second list of objects being associated with a second patent application in the patent application repository and being generated based on a TF of objects identified by claims in the second patent application.
- the processor 1305 illustrated in FIG. 13 may compare the TF of the set of first objects with a second list of objects, the second list of objects be associated with a second patent application in the patent application repository and be generated based on a TF of objects identified by claims in the second patent application.
- searching at step 1112 may comprise determining whether to include the second patent application in the list of patent applications based on the comparison of the TF of the set of first objects and the second list of objects.
- the processor 1305 illustrated in FIG. 13 may determine whether to include the second patent application in the list of patent applications based on the comparison of the TF of the set of first objects and the second list of objects.
- the searching at step 1112 may comprise receiving at least one additional search parameter that is input by a user.
- the processor 1305 illustrated in FIG. 13 may receive at least one additional search parameter that is input by a user.
- the searching of the patent application repository is further based on the at least one additional search parameter.
- the searching at step 1112 may further comprise comparing the TF of the set of first objects with a third list of objects, associated with a second patent application, the third list of objects being generated based on an term frequency-inverse document frequency (TF-IDF).
- the processor 1305 illustrated in FIG. 13 may compare the TF of the set of first objects with a third list of objects, associated with a second patent application, the third list of objects be generated based on an TF-IDF.
- the determining of whether to include the second patent application in the list of patent applications is further based on the comparison of the TF of the set of first objects and the TF-IDF. Because the specification may have a high frequency of common generic structures, it may be preferable to generate the TF-IDF for the second patent application, thereby allowing a better comparison of claims to the specification.
- the method 1100 includes receiving a list of patent applications corresponding to the TF based on the search of the patent application repository at step 1114 .
- the processor 1305 illustrated in FIG. 13 may receive a list of patent applications corresponding to the TF based on the search of the patent application repository.
- the method 1100 includes receiving specification data generated based on user manipulation of a plurality of claim segments associated with the NLP tokens, the specification data including selection data related to a first patent application, at step 1116 .
- the processor 1305 illustrated in FIG. 13 may receive specification data generated based on user manipulation of claim segments as described above with reference to FIG. 5 .
- the specification data also may include selection data related to another patent application, which is selectively incorporated based on user input.
- the method 1100 includes identifying a document associated with the first patent application and extracting specification content from the document based on the selection data at step 1118 .
- the processor 1305 illustrated in FIG. 13 may identify a document associated with the first patent application and extract specification content from the document based on the selection data.
- the identifying at step 1118 comprises identifying a start of first content related to a figure number identified by the selection data.
- the processor 1305 illustrated in FIG. 13 may identify a start of first content related to a figure number identified by the selection data.
- the identifying at step 1118 further comprises identifying a start of second content related to a second figure number that follows the figure number identified by the selection data.
- the processor 1305 illustrated in FIG. 13 may identify a start of second content related to a second figure number that follows the figure number identified by the selection data.
- the identifying at step 1118 comprises extracting the specification content that is located between the first content and the second content.
- the processor 1305 illustrated in FIG. 13 may extract the specification content that is located between the first content and the second content.
- the identifying at step 1118 comprises searching reference numerals in the specification content based on an original figure number assigned to drawing content in the first patent application.
- the processor 1305 illustrated in FIG. 13 may search reference numerals in the specification content based on an original figure number assigned to draw content in the first patent application.
- the identifying at step 1118 comprises replacing the reference numerals based on the figure number assigned to the specification content.
- the processor 1305 illustrated in FIG. 13 may replace the reference numerals based on the figure number assigned to the specification content.
- the identifying at step 1118 comprises identifying a summary description corresponding to the figure number in a section of the first patent application related to drawing descriptions.
- the processor 1305 illustrated in FIG. 13 may identify a summary description corresponding to the figure number in a section of the first patent application related to drawing descriptions.
- the identifying at step 1118 comprises extracting the summary description.
- the processor 1305 illustrated in FIG. 13 may extract the summary description.
- the method 1100 includes editing the specification content based on a figure number assigned to the specification content at step 1120 .
- the processor 1305 illustrated in FIG. 13 may edit the specification content based on a figure number assigned to the specification content.
- the method 1100 includes generating a patent specification based on the specification data and including the specification content, the patent specification comporting with a plurality of procedural requirements, at step 1122 .
- the processor 1305 illustrated in FIG. 13 may generate a patent specification based on the specification data and include the specification content, the patent specification comport with a plurality of procedural requirements.
- the method 1100 includes identifying a drawing associated with the first patent application and extracting drawing content from the drawing based on the selection data at step 1124 .
- the processor 1305 illustrated in FIG. 13 may identify a drawing associated with the first patent application and extract drawing content from the drawing based on the selection data.
- the disclosure can also be applicable to content that relates to content reuse through searching using different techniques.
- the disclosure can be applied to a legal document (e.g., a contract, an agreement, etc.) and/or a formal document (e.g., a petition, a plan, a proposal, a request for proposal (RFP), change request, invoice, etc.) comporting with at least one procedure, statute, or requirement.
- a legal document e.g., a contract, an agreement, etc.
- a formal document e.g., a petition, a plan, a proposal, a request for proposal (RFP), change request, invoice, etc.
- the method 1100 includes editing the drawing content based on the figure number at step 1126 .
- the processor 1305 illustrated in FIG. 13 may edit the drawing content based on the figure number.
- the editing of the drawing content at step 1126 comprises searching text labels based on an original figure number assigned to the drawing content in the first patent application.
- the processor 1305 illustrated in FIG. 13 may search text labels based on an original figure number assigned to the drawing content in the first patent application.
- the method 1100 comprises replacing a portion of the text labels based on the figure number assigned to the specification content.
- the processor 1305 illustrated in FIG. 13 may replace a portion of the text labels based on the figure number assigned to the specification content.
- the editing of the drawing content at step 1126 comprises generating patent drawings based on the specification data and including the drawing content at step 1128 .
- the processor 1305 illustrated in FIG. 13 may generate patent drawings based on the specification data and include the drawing content.
- FIG. 12 illustrates an example user interface 1200 that may implement a portion of the features described in FIG. 11 .
- FIG. 12 illustrates a “wizard” or “stepper” component similar to FIG. 10 including a header 1202 and a specification region 1206 .
- the user interface 1200 further includes a search results panel 1208 that illustrates a first application 1210 , a second application 1212 , and a third application 1214 , which are identified based on a result of the TF search described above.
- Each application displayed in the search results panel 1208 includes various static information such as serial number, docket number, a summary, and a description.
- the description may be scrollable or may allow the user to selectively display a portion of the description. Using the user interface for each application, the user is able to quickly review each drawing and may identify related content that is similar to the current application that is being drafted.
- the user interface 1200 allows the user to select a drawing and selectively incorporate the same into the specification region 1206 .
- the system generates specification data identifying the subject matter from the first application 1210 and second application 1212 to incorporate in the current application. Because current documents and drawings are stored in an XML format, the system is able to extract the selected content from the original source, modify the selected content based on the user input, and insert the modified content. However, in some examples, the drawing may not be stored in an XML format. In that case, the system may convert the drawing into a bitmap and then insert the bitmap drawing into the new drawing.
- search system searches for related applications using NLP analysis of the claims and NLP analysis of the previously filed patent application.
- search system uses the disclosed search system, the user is able to selectively incorporate content from related applications and the search system updates the selected content to facilitate editing and incorporating additional or different subject matter.
- FIG. 13 illustrates an example computer system 1300 for executing client or server operations.
- the example computer system 1300 may execute a client application, a server side application for performing the instant disclosure, or an NLP engine.
- the example computer system 1300 includes a processor 1305 , a memory 1310 , a graphical device 1315 , a network device 1320 , interface 1325 , and a storage device 1330 that communicate and operate via a connection 1335 .
- the connection 1335 can be a physical connection via a bus, or a direct connection into processor 1305 , such as in a chipset architecture.
- the connection 1335 can also be a virtual connection, networked connection, or logical connection.
- the processor 1305 reads machine instructions (e.g., reduced instruction set (RISC), complex instruction set (CISC), etc.) that are loaded into the memory 1310 via a bootstrapping process and executes an operating system for executing applications within frameworks provided by the operating system. That is, the processor 1305 can include any general-purpose processor and a hardware service or software service, which are stored in memory 1310 , and configured to control processor 1305 as well as a special-purpose processor where software instructions are incorporated into the actual processor design.
- the processor 1305 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.
- the processor 1305 may execute an application that executes an application provided by a graphical framework such as Winform, WPF, Windows User Interface (WinUI), or a cross platform user interface such as Xamarin or QT.
- a graphical framework such as Winform, WPF, Windows User Interface (WinUI), or a cross platform user interface such as Xamarin or QT.
- the processor 1305 may execute an application that is written for a sandbox environment such as a web browser.
- the processor 1305 controls the memory 1310 to store instructions, user data, operating system content, and other content that cannot be stored within the processor 1305 internally (e.g., within the various caches).
- the processor 1305 may also control a graphical device 1315 (e.g., a graphical processor) that outputs graphical content to a display 1340 .
- the graphical device 1315 may be integral within the processor 1305 .
- the display 1340 may be integral with the computer system 1300 (e.g., a laptop, a tablet, a phone, etc.).
- the graphical device 1315 may be integral with the processor 1305 and form an accelerated processing unit (APU).
- APU accelerated processing unit
- the graphical device 1315 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 1305 .
- controlled by instructions to perform mathematical operations optimized for floating point math For example, the processor 1305 may allocate instructions to the graphical device 1315 for operations that are optimized for the graphical device 1315 .
- the graphical device 1315 may execute operations related to artificial intelligence (AI), natural language processing (NLP), and vector math.
- AI artificial intelligence
- NLP natural language processing
- vector math vector math
- the results may be returned to the processor 1305 .
- the application executing in the processor 1305 may provide instructions to cause the processor 1305 to request the graphical device 1315 to perform the operations.
- the graphical device 1315 may return the processing results to another computer system (i.e., distributed computing).
- the processor 1305 may also control a network device 1320 for transmits and receives data using a plurality of wireless channels 1345 and at least one communication standard (e.g., Wi-Fi (i.e., 802.11ax, 802.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 1320 may wirelessly connect to a network 1350 to connect to servers 1355 or other service providers.
- the network device 1320 may also be connected to the network 1350 via a physical (i.e., circuit) connection.
- the network device 1320 may also directly connect to local electronic device 1360 using a point-to-point (P2P) or a short range radio connection.
- P2P point-to-point
- the processor 1305 may also control an interface 1325 that connects with an external device 1370 for bidirectional or unidirectional communication.
- the interface 1325 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).
- USB universal serial bus
- Thunderbolt Thunderbolt
- the external device 1365 is able to receive data from the interface 1325 to process the data or perform functions for different applications executing in the processor 1305 .
- the external device 1365 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.
- ADC analog-to-digital converter
- DAC digital-to-analog converter
- the 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 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.
- 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.
- the computer-readable storage devices, mediums, and memories can include a cable or wireless signal containing a bit stream and the like.
- non-transitory computer-readable storage media expressly exclude media such as energy, carrier signals, electromagnetic waves, and signals per se.
- the storage device 1330 can include software services, servers, services, etc., that when the code that defines such software is executed by the processor 1305 , it causes the system to perform a function.
- 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 1305 , connection 1335 , external device 1370 , etc., to carry out the function.
- an initial input could be a figure having labels.
- the drafting system would identify each label and query an author for a description of the labeled portion and its interaction or relationship with another labeled portion. These descriptions of the labeled portions and their interactions or relationships with other labeled portions can be fed into the natural language processing server. Thereafter the natural language processing server can output structured statements in an initial sequence for additional refinement and rearranging by the user as described above.
- the present technology can receive any collection of statements having a basic relationship between the statements and can extract parts of speech from these statements and provide an initial organization for the statements. Thereafter the present technology can receive further inputs to rearrange and modify and add to the statements and ultimately provide an initial draft of a document.
- the present technology provides advantages over existing technologies through improvements in the machine-user interface improvements and inputs to natural language processing server improvements income terms of complexity of initial inputs and subsequent inputs which all can result in a better initial draft provided by the national language processing server and available from existing technologies.
- 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.
- the disclosed system can be used to arrange a contract or an agreement based on text input.
- the disclosed system can be used a new drug application at the FDA, a change request for a manufacturing process, a non-disclosure agreement, a technical paper that presents a flowchart or sequence diagram.
- the disclosed system can be used to arrange a contract or another type agreement based on text input (e.g., a non-disclosure agreement, an employment agreement, a contract, etc.).
- An agreement related to a contract may need to specify obligations and consequences of achieving of failing to achieve those obligations.
- the instant disclosure could receive a text-based input and generate a flowchart, which would then be converted into legal text based on various templates.
- the disclosed system can be used a new drug application at the U.S. Food & Drug Administration (FDA), a change request for a manufacturing process, or a proposal.
- the disclosed system may implement a named entity recognition (NER) module to identify chemical compounds and use the identified chemical compounds to create a user interface that would allow the user to control components to create description for the new drug application.
- NER named entity recognition
- an NER module can be trained based on patent claims to identify common words and identify points to segment claims and identify logical breaks in claims.
- An NER module may also be used to analyze language and generate a sequence diagram illustrating communication between different devices such as FIG. 3 of the instant disclosure. The user would be provided an interface similar to the disclosure above to allow correction of the communication sequence and then further create a description of the communication sequence.
- the disclosure can also be applicable to content that relates to content reuse through searching using different techniques.
- the disclosure can be applied to a legal document (e.g., a contract, an agreement, etc.) and/or a formal document (e.g., a petition, a plan, a proposal, a request for proposal (RFP), change request, invoice, etc.) comporting with at least one procedure, statute, or requirement.
- a legal document e.g., a contract, an agreement, etc.
- a formal document e.g., a petition, a plan, a proposal, a request for proposal (RFP), change request, invoice, etc.
- 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.
- a service can be software that resides in memory of a client device and/or one or more servers and perform one or more functions when a processor executes the software associated with the service.
- a service is a program, or a collection of programs that carry out a specific function.
- a service can be considered a server.
- the memory can be a non-transitory computer-readable medium.
- the computer-readable storage devices, mediums, and memories can include a cable or wireless signal containing a bit stream and the like.
- non-transitory computer-readable storage media expressly exclude media such as energy, carrier signals, electromagnetic waves, and signals per se.
- 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, 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 laptops, smart phones, small form factor personal computers, personal digital assistants, rackmount devices, standalone devices, 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.
- example method illustrated herein depict 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. In other examples, different components of an example device or system that implements the methods illustrated herein may perform functions at substantially the same time or in a specific sequence.
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Health & Medical Sciences (AREA)
- Artificial Intelligence (AREA)
- Audiology, Speech & Language Pathology (AREA)
- Computational Linguistics (AREA)
- General Health & Medical Sciences (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Machine Translation (AREA)
Abstract
An NLP analysis method based on identification of common terms is disclosed. The improved NLP analysis can separate different parts of a patent claim into discrete claim segments based on the common terms. A user interface that corresponds to a flowchart allows the user to drag and drop the claim segments to form complex relationships, which is used to generate a patent specification.
Description
- This application is a continuation of and claims the benefit of U.S. application Ser. No. 17/014,403, filed on Sep. 8, 2020, entitled DYNAMICALLY GENERATING DOCUMENTS USING NATURAL LANGUAGE PROCESSING AND DYNAMIC USER INTERFACE, which is expressly incorporated by reference herein in its entirety.
- The present technology pertains to a method and apparatus for generating documents using natural language processing and a dynamic user interface.
- Formal documents that are authored for administrative agencies are required to have specific structure to comport with the administrative agency's requirements. The requirements include procedural-based requirements (e.g., margins, font size, etc.) and statutory-based requirements (content).
-
FIGS. 1 and 2 illustrate existing systems for generating patent applications. In particular,FIG. 1 illustrates a server-based process to generate the formal document andFIG. 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 , asystem 100 comprises aclient 110 that connects to awebserver 120 for generating the patent specification. In thesystem 100, theclient 110 transmits a document atstep 135 that includes a set of method claims to thewebserver 120. Having received the document with method claims, thewebserver 120 extracts the method claims from the document atstep 140. After extracting the claim, thewebserver 120 transmits text that corresponds to the method claims to the NLP server atstep 145 - The
NLP server 130 receives the text and processes the text into NLP tokens atstep 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 (or 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 Course Id RootId Text Tag Fine Tag Dependency Label 0 1 I Noun Personal Pronoun Nominal Subject 1 1 love Verb Non-3rd person Root present verb 2 1 fries Noun Plural Noun Direct Object - The
NLP server 130 transmits the tokens to thewebserver 120 atstep 155, which converts the tokens into a patent specification atstep 160. Thewebserver 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, thewebserver 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, thewebserver 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, thewebserver 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, thewebserver 120 transmits the patent specification with the flowchart description and additional boilerplate back to theclient 110 atstep 165. Thewebserver 120 may also transmit any created flowchart drawings or generic drawings atstep 165. -
FIG. 2 illustrates asystem 200 that is similar to thesystem 100, but has a different architecture. In particular, thesystem 200 comprises anapplication 210, which may be executing on a client computer, which communicates with theNLP server 230. - The
application 210 extracts the text of the method claims and transmits the text to theNLP server 230 atstep 240. TheNLP server 230 processes the text into NLP tokens atstep 250 and returns the text as NLP tokens atstep 260 to theapplication 210. In response to receiving the NLP tokens, theapplication 210 may generate the specification or part of the specification at step 270. Theapplication 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 orsystem 200 may also compose additional claims from the method claims. In more detail, thesystem 100 orsystem 200 converts a method claim, which has gerund verbs, into a device or system claim, which has present tense verbs. However, in each case, thesystem 100 orsystem 200 will only provide generic structure (e.g., a processor, a memory, a display). Thesystem 100 orsystem 200 may also generate “means” claims by changing the preamble and adding “means for” before the root gerund verb. - 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 NLP and a dynamic user interface; -
FIG. 4 is a flowchart of a method for segmenting text into tokens and claim segments; -
FIG. 5 is a flowchart of a method for sequencing claim segments to generate a patent specification; -
FIG. 6 illustrates an example user interface for arranging claim segments to generate a patent specification and drawings; -
FIG. 7 illustrates an example user interface for arranging claim segments using a claim panel that simultaneously displays claim segments and claims based on a feedback scheme; -
FIG. 8 illustrates an example node that allows complex manipulation of claim segments; -
FIGS. 9A, 9B, and 9C illustrate an example node that allows complex relationships of claim segments; -
FIG. 10 illustrates a user interface that allows a user to build a specification using point and click operations in conjunction with a client-specific module; -
FIG. 11 is a flowchart of a method for generating a patent specification based on a related application that is identified using NLP; -
FIG. 12 illustrates an example user interface for generating a specification based on a related application that is identified using NLP; and -
FIG. 13 illustrates an example computer system for executing client or server operation. - 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.
- For example, 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 further 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 system 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 improving the machine-user interface, which provides further inputs into a natural language processing server and yields a more robust output. For example, in some embodiments the present technology utilizes an input collection of statements. In the case of a patent application the statements can be elements of claims, while in the case of a contract the statements can be a description of major deal terms. In the case of a technical paper these statements can be sentences reciting key points to be described.
- The present technology can analyze the statements and can organize them into an initial order based on relationships and dependencies perceived based on the tokens provided from the NLP server. This initial organization can be in the form of a flowchart or an outline. However the present technology recognizes that, in the process of writing a complex document, thoughts need to be rearranged, additional thoughts may be added, and thoughts may be refined. As such the present technology provides an interface by which the initial order can be reorganized based on the judgment of a human author.
- In some embodiments, 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.
- By improving the machine-user interface, the present technology can ultimately provide a more usable initial output to an author of a document. 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.
- Through improvements in the machine-user interface, the present technology is also able to accommodate more complex relationships between phrases. For example the present technology can accommodate and describe conditional logic, or descriptions nested in other descriptions.
- In addition the present technology provides various other improvements, some of which are specific to drafting of patent applications. For example the present technology encourages input of detailed and numerous dependent claims so that the NLP server can provide the foundation for a detailed patent application. However recognizing that there are some restraints on the number of claims that an author may wish to include in a patent application, and recognizing that not all topics recited in claim are useful for inclusion in a figure, the present technology can allow a user to suppress portions of a claim from appearing in a claim section of a document or from appearing in the drawings accompanying a patent application.
- These and other improvements to tools that use algorithms or NLP to create documents are described herein.
-
FIG. 3 illustrates a sequence diagram of anexample 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 that is illustrated inFIGS. 3 and 4 . Further, an application that is executing within thesystem 300 may include a dynamic user interface that is illustrated inFIGS. 5 to 10 to allow the user to input method claims, sequence the steps of the claims together with an intuitive user interface, and intelligently compose portions of a patent specification. Further, the dynamic user interface allows the user to identify structures associated with actions within the claims, which can then be used to more intelligently compose claims and draft the specification based on input method claims. - The
system 300 comprises aclient 302, aserver 304, and aNLP server 306. In some examples, theserver 304 and theNLP server 306 can be different server processes executing on the same hardware or configured virtual machine. In the event that theNLP server 306 is hosted locally on the same server as theserver 304, the NLP engine may be based on a local NLP engine such as natural language toolkit (NLTK), Stanford CoreNLP, etc. However, theNLP 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 orNLP 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 forward to theserver 304 executing on port 6000. In another example, the functionality provided by theserver 304 may be performed based on an application executing on the client 302 (e.g., a Native React application, etc.) that include local libraries and is able to directly access the file system of theclient 302. - In this example, the
client 302 receives an application from theserver 304 atstep 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., Native React, Electron JS, Blazor WebWindow, etc.). In some examples, the application can be web application (e.g., a Microsoft 365® add-in) that is side loaded into a local application (e.g., Microsoft Word) or a web application (e.g., Microsoft 365®) and uses an API to perform functions. - The
client 302 may execute the application atstep 310. As noted above, the application may be executed within a browser's sandbox. However, the application may also be an add-in and executes within another application such as a React-based add-in that is executed within Microsoft Word® and is able to use various APIs to interact with the document and the application. In the example illustrated inFIG. 3 , thesystem 300 is presumed to execute in a browser sandbox, and any descriptions inFIG. 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, atstep 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 theNLP server 306. - After receiving the document, the
server 304 extracts text from the claims at step 314 and transmits text from the claims atstep 316 to theNLP 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 of subject matter in the claims. The margins, indenting, 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 atstep 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 atstep 316. TheNLP server 306 processes the text into NLP tokens at step 318 and transmits the tokens and token identification information to the server atstep 320. TheNLP 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 generates token IDs, analyzes the NLP tokens, and creates new text at step 322. In particular, theserver 304 generates a token identifier for each token based on the identification information and token identification information. Thus, theserver 304 generates a unique token identifier for each token based on the claim number of the token, the line number (based on the line breaks), and a position of the token within that line. As will be described below, the token IDs generated by theserver 304 allow supplemental NLP analysis of different segments to improve quality of the NLP. - The NLP analysis of the line of text may materially be affected based on common terms that are commonly used in patent claims. For example, the term “wherein” may significantly affect the NLP analysis and cause the NLP to misidentify the root word. As noted above, the root word of a phrase or sentence is not dependent on any other tokens. Further, terms such as “comprising” have specific legal definitions and may also affect the quality of the NLP analysis. Thus, at step 322, the server may analyze the tokens and determine that a line of a claim should be segmented into different claim segments and then reanalyzed. The claim segments are a consecutive list (i.e., an array) or NLP tokens that can be converted into individual sentences by the
system 300 and generally form discrete concepts. - The claim segments are generally classified into an active phrase, a passive phrase, and a linking phrase. An active phrase includes a root word that is a gerund verb. As an example, a segment that forms the phrase “transmitting information” comprises a token “transmitting” that has a dependency label of root and a second “information” that has a dependency label of clausal subject. In this example, because the
system 300 receives method claims, the root verbs will generally be gerund verbs. However, thesystem 300 could receive present tense verbs and segment the claims in a substantially identical manner. In some examples, there may be an adpositional phrase (e.g., “after receiving the content,” “in response to receiving the content, etc.) that modifies the root verb. However, the core meaning of the segment still corresponds to the active gerund verb and the root token can be deduced based on an analysis of the NLP tokens. The active phrase generally includes a direct object linked to the gerund verb and does not include a noun having a dependency label of nominal subject. - A passive phrase includes a subject that that further defines a concept in another active phrase and generally includes both a nominal subject and a clausal subject. In this case, the root word may be a present tense or past tense verb. However, the verb can also be in active form. For example, a segment that forms the passive phrase “the information includes a power transmission level” comprises a root word of “includes,” which a present tense verb. However, “the information” is a singular noun that has a dependency label of nominal subject and “a power transmission level” is a clausal subject.
- A linking phrase does not include content and provides context that links two claim segments. As an example, the linking phrase “the processing of the data comprises” further indicates that content after the linking phrase is linked to and modifies “processing the data.”
- Accordingly, the
server 304 creates portions of text by excluding some of the common terms that affect the NLP analysis and transmits the portion of text to theNLP server 306 atstep 324. The text transmitted atstep 324 may also include identifying information to facilitate synthesis of the NLP tokens. Atstep 326, theNLP server 306 processes the text into NLP tokens and transmits a second set of tokens to theserver 304 with the identification information atstep 328. The identification information transmitted to theNLP server 306 atstep 324 may be different than identification information transmitted atstep 316. For example, text transmitted atstep 324 may be in the form of a key-value pair with the key corresponding to the token ID of the first token in the text. - At step 330, using the identification information, the
server 304 synthesizes the first set of tokens and the second set of tokens into a complete set of tokens instep 320. The complete set of tokens corresponds to the entirety of the claim and includes the common terms. With the NLP tokens synthesized, theserver 304 transmits the complete set of tokens to the client 302 (i.e., the application executing on the client 302) atstep 332. - The client application, which will be further described below with respect to
FIG. 5 , allows the NLP tokens to be rearranged in a flowchart user interface based on user input. However, in some cases, the steps that should be illustrated in a flowchart are not necessarily explicit in a claim. For example, if a claim is a condition-action sequence (e.g., if something exists, perform a function), the claim implicitly recites two actions: the determining of the condition and the action that is performed based on the condition. Therefore, in some cases, it is beneficial to allow a user to input additional actions that should be incorporated into a flowchart and its corresponding description. - Accordingly, to allow the user to add additional content (i.e., nodes) to the flowchart user interface, the application may allow the user to input additional language. That is, the application enables the user to input supplemental text that is separate from the text of the claims at step 334. In response, the application executing on the
client 302 may transmit the supplemental text to theserver 304 atstep 336. Theserver 304 transmits the text to theNLP server 306 atstep 338. In this case, the server does not provide identifying information because theserver 304 will not necessarily need to resynthesize the NLP tokens. TheNLP server 306 processes the text into NLP tokens atstep 340 and transmits the tokens to the server atstep 342. Theserver 304 transmits the tokens to theclient 302 atstep 344. - At step 346, the
client 302 selects at least one template that is used to configure a patent specification. However, step 346 is only illustrated as an example and can occur prior to claim analysis and tokenization described above or at other stages of the present technology. In response to the user's selection of at least one template at step 346, theclient 302 transmits a request for the template to theserver 304 atstep 348. Theserver 304 replies with the at least one template atstep 350. The template includes static information that may be updated based on the user's manipulation of the client application. For example, a template can include standard boilerplate, a blank drawing that is inserted to be a placeholder, a flowchart description style, a client specific drawing that is relevant to many of that particular client's patent applications, and so forth. - In some examples, the template may insert the content into multiple sections of the patent specification. As an example, a template that is related to blank diagram that serves as a placeholder (i.e., for preserving of reference numbers and other labels) may only insert a blank description into a drawing description section and a description section. However, a client specific system overview may include different regions related to background, technical field, summary, and description. Further, the templates may include a corresponding section that identifies entities associated with the claims. As will be described in further detail below, the entities may be hardware components that the user can link to via a claim segment, which may also be used to compose new claims based on the method claims input into the
system 300. - At
step 352, the user operates the application on theclient 302 to generate specification data. As an example, a flowchart user interface is presented to the user and allows the user to organize claim segments in a manner that will be used to visually describe the flowchart, which will be further described below with respect toFIGS. 6 to 10 . Further, as noted above with respect to step 346, the user is able to select different templates, perform client specific functions, and so forth to generate the specification data. The specification data may include different data structures that are used to generate the specification document and may include, for example, user authored claims, application composed claims, a list of templates and data associated with the templates, flowchart data for generating descriptions of the flowchart, descriptions of the flowchart, static data (e.g., docket number, inventor names, client information, etc.) and so forth. - The
specification data 354 is transmitted to theserver 304 atstep 354 because, in this example, the client application is executing within the browser sandbox and is unable to access system resources. Accordingly, theserver 304 receives the specification data, generates a document based on the specification data, and generates drawings based on the specification data. Theserver 304 then transmits the document and drawing to theclient 302 atstep 358. In other examples, the application may be executing within document processing application (i.e., Microsoft Word®, Libre Office, etc.) and may generate the document on theclient 302 itself using an API. - In the example illustrated in
FIG. 3 , an improved NLP analysis method is described that identifies common terms that causes NLP errors. By further segmenting the text based on the common terms and performing a subsequent NLP analysis, the quality of the NLP analysis is improved and the NLP tokens can be easily dissected into different claim segments that will form complete sentences in the generated patent specification. - Although the above and below disclosure relates to a patent application, the disclosure can also be applicable to content that relates to a sequence of operations. For instance, the disclosure can be applied to a flow diagram illustrating communication between devices, software processes, services, or any other type of communication. The instant disclosure can also be applied to legal and/or formal documents for identifying a sequence, an order, a succession, conditional logic, decision trees, and so forth.
-
FIG. 4 illustrates anexample method 400 for segmenting the text into NLP tokens and claim segments that are used by a client application for creating a patent specification. The descriptions below relate to aspects that can be integral to a user application or separate from the user application (e.g., implemented on a server). For the sake of clarity, themethod 400 is described separately from other aspects that relate to the machine-user interface. Although theexample 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 themethod 400. In other examples, different components of an example device or system that implements themethod 400 may perform functions at substantially the same time or in a specific sequence. - According to some examples, the
method 400 includes transmitting text associated with patent claims to a server for NLP analysis atstep 402. For example, theprocessor 1305 illustrated inFIG. 13 may transmit text associated with patent claims to a server for NLP analysis. In this example, the patent claims comprise an independent claim and at least one dependent claim that form a set of claims. While it is possible to use a single independent claim, a set of claims generally includes at least one dependent claim. - According to some examples, the
method 400 includes receiving NLP tokens from the server based on the NLP analysis atstep 404. For example, theprocessor 1305 illustrated inFIG. 13 may receive NLP tokens from the server based on the NLP analysis. - According to some examples, the
method 400 includes generating a token identifier for each NLP token atstep 406. For example, theprocessor 1305 illustrated inFIG. 13 may generate a token identifier for each NLP token. In an example, the token identifier includes a claim number, a line number, and a token number within the line. In particular, the claim number, line number, and token number are each encoded into the token identifier using different base numbers or Gödel numbering. The token number within the line indicates an order of the token within the line. - According to some examples, the
method 400 includes identifying common terms in the NLP tokens that affect the NLP analysis atstep 408. For example, theprocessor 1305 illustrated inFIG. 13 may identify common terms in the NLP tokens that affect the NLP analysis. In an example, the common terms comprise at least one of comprising, comprises, and a phrase to indicate a definition. In another example, the common terms comprises patent terms having a legal definition or provide a context for a claim segment and further explain the content of the claim. - According to some examples, the
method 400 includes, in response to identifying the common terms, generating segments of text based on the common terms and transmitting the segments of text to the server for a second NLP analysis atstep 410. For example, theprocessor 1305 illustrated inFIG. 13 may, in response to identifying the common terms, generate segments of text based on the common terms and transmit the segments of text to the server for a second NLP analysis. - According to some examples, the
method 400 includes receiving a second set of NLP tokens from the server based on the second NLP analysis atstep 412. For example, theprocessor 1305 illustrated inFIG. 13 may receive a second set of NLP tokens from the server based on the second NLP analysis. - According to some examples, the
method 400 includes synthesizing the NLP tokens and the second set of NLP tokens into a complete set of NLP tokens corresponding to the text associated with the patent claims atstep 414. For example, theprocessor 1305 illustrated inFIG. 13 may synthesize the NLP tokens and the second set of NLP tokens into a complete set of NLP tokens corresponding to the text associated with the patent claims. In an example, the passive phrase includes a present tense verb and a nominal subject. In another example, the active phrases comprise a gerund verb that corresponds to a root word of the claim segment based on the NLP analysis. In another example, the passive phrase further defines a gerund verb or an object in another claim segment. In a fourth example, the generating of the claim segments comprises identifying content that links different claims and identifying linking phrases that link different claim segments. In a fifth example, each claim segment corresponds to an active phrase or a passive phrase. In a sixth example, the complete set of NLP tokens includes claim segments, each claim segment comprising a plurality of NLP tokens. In a seventh example, the common terms are excluded from any of the claim segments. - In another example, the synthesizing of the tokens at
step 414 comprises identifying a relationship between different claim segments based on the linking phrases. For example, theprocessor 1305 illustrated inFIG. 13 may identify a relationship between different claim segments based on the linking phrases. A linking phrase does not include content, but simply provides context that links two segments. For example, a preamble of a claim may include “the processing of the data comprises,” which further indicates that content after preamble is a linked to and modifies “processing the data.” - According to some examples, the
method 400 includes extracting whitespace for each line of the patent claims atstep 416. For example, theprocessor 1305 illustrated inFIG. 13 may extract whitespace for each line of the patent claims. Based on procedural requirements, a claim is required to be a single sentence, but a claim is generally broken into individual lines using a line break to provide structure to the claim and separate different clauses. Whitespace includes spaces, tabs, line breaks that may be used to provide visual formatting to the claim. In terms of document file formats, the underlying text may be separated into several different XML elements and whitespace may be represented by properties of the XML, elements. As an example, a paragraph element is represented in OpenXML (i.e., a word .docx file) as a <w:p> element with the “w” identifying the namespace and the “p” identifying a paragraph element. The paragraph element can include child XML elements such as a paragraph properties element (i.e., a <w:pPr> element) that provides whitespace such as, the indent of the first line, the left margin, a tab element, a hanging indent, etc. - According to some examples, the
method 400 includes identifying relationships between the claim segments based on the whitespace, a claim number associated with the claim segment, and a claim dependency atstep 418. For example, theprocessor 1305 illustrated inFIG. 13 may identify relationships between the claim segments based on the whitespace, a claim number associated with the claim segment, and a claim dependency. Further, claim lines (or recitations) may include whitespace to further indicate that the recitation is related to the prior subject matter in the claim. - According to some examples, the
method 400 includes determining an order of a portion of the claim segments based on the relationships of the claim segments, the order corresponding to an order of a flowchart that is presented to a user, atstep 420. For example, theprocessor 1305 illustrated inFIG. 13 may determine an order of a portion of the claim segments based on the relationships of the claim segments, the order corresponding to an order of a flowchart that is presented to a user. - In an example, the user provides input into the flowchart to generate a portion of the specification data. According to some examples, the
method 400 includes receiving supplemental text that is input separately from the claims atstep 422. For example, theprocessor 1305 illustrated inFIG. 13 may receive supplemental text that is input separately from the claims. For example, the user may enter text into a component to create a user-defined segment for the flowchart user interface as described below. - According to some examples, the
method 400 includes transmitting the supplemental text to the server at step 424. For example, theprocessor 1305 illustrated inFIG. 13 may transmit the supplemental text to the server. - According to some examples, the
method 400 includes receiving a third set of NLP tokens from the server corresponding to the supplemental text atstep 426. For example, theprocessor 1305 illustrated inFIG. 13 may receive a third set of NLP tokens from the server corresponding to the supplemental text. - According to some examples, the
method 400 includes receiving specification data generated based on user manipulation of the claim segments atstep 428. For example, theprocessor 1305 illustrated inFIG. 13 may receive specification data generated based on user manipulation of the claim segments. The specification data is generated based on user input into a client application to rearrange the initial ordering of the claim limitations that were originally determined based on the NLP analysis and logical analysis described above. A method associated with the creating the specification data is illustrated inFIG. 5 and examples of the user interface and corresponding features are illustrated inFIGS. 6 to 10 and further described below. - In an example, the specification data comprises flowchart data that is generated at the client application based on user manipulation. In some examples, the specification data identifies a list of templates and data related to the templates (e.g., Figure number) as illustrated in
FIGS. 10 and 12 . The specification data includes different data that is generated by theclient 302 and is used by theserver 304 to generate the specification. - According to some examples, the
method 400 includes generating a patent specification that comports with a plurality of procedural requirements based on the specification data atstep 430. For example, theprocessor 1305 illustrated inFIG. 13 may generate a patent specification that comports with a plurality of procedural requirements based on the specification data. The patent specification can also include a set of drawings. - In an example, the generating of the specification at
step 430 may include determining that the specification data includes custom content for a first template in a list of templates. For example, theprocessor 1305 illustrated inFIG. 13 may determine that the specification data includes custom content for a first template in the list of templates. In another example, the generating of the specification atstep 430 further comprises extracting first content from a document corresponding to the first template. - In another example, the generating of the specification at
step 430 comprises generating text in a description section of the patent specification based on at least one claim. For example, theprocessor 1305 illustrated inFIG. 13 may generate text in a description section of the patent specification based on at least one claim. The description in this case corresponds to the flowchart description of a drawing and specifically links the description to the flowchart with a reference numeral. - Further, the generating the specification at
step 430 further includes determining whether the specification data indicates that a claim segment is linked to a structure that performs an action corresponding to the claim segment. After determining a claim segment is linked, the method further includes generating text corresponding to the claim segment that indicates that the structure performing the action of the claim segment. For example, theprocessor 1305 illustrated inFIG. 13 may determine whether the specification data indicates that a claim segment is linked to a structure that performs an action corresponding to the claim segment and may generate text in the flowchart description that indicates the structure performing the action of the claim segment. The action of the text has a different verb tense than the action in the claim segment and the text includes a reference numeral of the structure that identifies the structure in a drawing. Thus, as illustrated inFIGS. 6 and 7 , the specification is generated based on a user input into the user interfaces (e.g., thecontrol 652 inFIG. 6 ) that links a hardware diagram to a claim segment in the flowchart user interface. In particular, when generating the description related to the flowchart, the description identifies the step in the flowchart and provides explicit support to a hardware structure that also performs this step. - The generating the specification at
step 430 further includes synthesizing the first content and the custom content into merged content for inserting the merged content into the generated patent specification. For example, theprocessor 1305 illustrated inFIG. 13 may synthesize the first content and the custom content into merged content. For instance, based on previous input identifying a specific structure in the client application, the corresponding action in the flowchart user interface can be inserted into text associated with the hardware. That is, the link used in the control, which is illustrated ascontrol 652 inFIG. 6 , can simultaneously generate text for a flowchart and text associated with the hardware figure. For example, if a transmitter X10 is selected to perform “transmitting power level information,” the description associated with the transmitter X10 can be modified to indicate that the transmitter X10 transmits the power level information. As noted above, this input can also be used to modify the descriptions of the flowchart, thereby allowing a single user interface to change different content in different sections of the patent specification. - However, in some embodiments,
processor 1305 can receive an input that will indicate at that at least one claim from the input claims should be excluded from a claim section of the patent specification. This results in a claim being be used to generate text for the description, but is expressly excluded from the claims in the specification generated atstep 430. This can be a beneficial feature whereby an input claim set can articulate all concepts that a user desires to be processed byNLP server 130 and included in the patent document, while focusing the claim set with the most useful claims in the claim set. - In another example, the generating of the patent specification at
step 430 comprises generating a preliminary amendment based on the specification data. For example, theprocessor 1305 illustrated inFIG. 13 may generate a preliminary amendment based on the specification data. Similar to the second example, additional claims can be used generate the specification, but can be removed via preliminary amendment to prevent incurring excess claim fees. - According to some examples, the
method 400 includes transmitting the patent specification to a client application that generates the specification data at step 432. Further, themethod 400 can also transmit a set of drawings to the client. For example, theprocessor 1305 illustrated inFIG. 13 may transmit the patent specification to a client application that generates the specification data. In some cases, themethod 400 may be executing locally on a client machine and the client machine would therefore create the document or insert the content of the patent specification into an existing document that is open in a word processing application. - While the above discloses improves NLP analysis, despite the general proficiency of the NLP server in understanding language structure, the NLP server is not always able to arrange claim segments in an optimal order for explaining an invention embodied in claims. In some instances, these limitations of the NLP server are rooted in the formal structure of claims, and that an aim of the drafters is for the claims to be only minimally descriptive of an invention (e.g., claims are intended to define a minimum novelty to result in a patentable claim that provides the broadest rights to which the applicant is entitled). In view of both these technological limitations and the limitations of the input provided to the NLP server, the present technology provides an interface to receive inputs to rearrange the initial ordering of the claim limitations that were originally determined by NLP server and to include supplemental text in addition to the language in the input claims.
-
FIG. 5 illustrates anexample method 500 for sequencing claim segments to generate a patent specification using examples of various aspects of a dynamic user interface illustrated inFIGS. 6 to 10 . For purposes of clarity, the descriptions below relate to a client application that is executing and outputting a flowchart user interface to allow the user to visually draft the patent specification. - Although the
example method 500 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 themethod 500. In other examples, different components of an example device or system that implements themethod 500 may perform functions at substantially the same time or in a specific sequence. - According to some examples, the method includes receiving NLP tokens from an NLP analysis of patent claims at
step 502. For example, theprocessor 1305 illustrated inFIG. 13 may receive NLP tokens from an NLP analysis of patent claims. In an example, the patent claims comprise an independent claim and at least one dependent claim that form a set of claims. - According to some examples, the
method 500 includes generating claim segments from the NLP tokens at step 504. For example, theprocessor 1305 illustrated inFIG. 13 may generate claim segments from the NLP tokens. In another example, each claim segment corresponds to an active phrase or a passive phrase. The passive phrase further defines a gerund verb or an object in another claim segment. In another example, the active phrase comprises a gerund verb that corresponds to a root word of the claim segment based on the NLP analysis. - According to some examples, the
method 500 includes selecting a portion of claim segments to display atstep 506. For example, theprocessor 1305 illustrated inFIG. 13 may select a portion of claim segments to display. - According to some examples, the
method 500 includes displaying a flowchart including the portion of the claim segments arranged in a first order atstep 508. For example, theprocessor 1305 illustrated inFIG. 13 may display a flowchart including the portion of the claim segments in the first order. An example of a flowchart displaying an order of claim segments is illustrated inFIGS. 6 and 7 . - In another example, the
method 500 comprises displaying a claim area that illustrates the set of claims and claim segments corresponding to the set of claims. For example, theprocessor 1305 illustrated inFIG. 13 may display aclaim area 702. Anexample claim area 702 is depicted inFIG. 7 and provides visual feedback to facilitate user operation. - According to some examples, the
method 500 includes receiving an input to change the first order of the claim segments into a second order that is different from the first order at step 510. For example, theprocessor 1305 illustrated inFIG. 13 may receive an input to change the first order of the claim segments into the second order that is different from the first order. As further described below with reference toFIGS. 6, 7, 8, 9A, 9B, and 9C , the user interface allows the user to drag and drop claim segments in the flowchart to form complex relationships. The user input can also be other operations such as a click operation that in a conditional branch that identifies the order of claim segments. - In an example, the input comprises dragging the second claim segment into the flowchart, and, after the second claim segment is dragged into the flowchart, a first graphical demarcation is applied to the second claim segment in the claim area. In another example, the input comprises dragging the third claim segment into the flowchart, and, after the third claim segment is dragged into the flowchart, the first graphical demarcation is applied to the third claim segment in the claim area.
- The demarcations is the flowchart user interface provide visual information regarding a state of the claim segment. This visual information allows the user to understand the organization of the flowchart to understand how the flowchart itself will be used to draft the patent specification.
- For example,
FIG. 7 illustrates a first graphical demarcation (indicated by the border) applied to claimsegments FIG. 7 illustrates a second graphical demarcation applied to aclaim segment 704 in the claim area indicates that theclaim segment 704 comprises active language and is not displayed in the flowchart. In another example,FIG. 7 illustrates a third graphical demarcation applied to claimsegments - According to some examples, the
method 500 includes displaying the claim segments in the flowchart in the second order at step 512. For example, after receiving an input effective to indicate a rearrangement of the claim segments, theprocessor 1305 illustrated inFIG. 13 may display the claim segments in the flowchart in the second order. - According to some examples, the
method 500 includes receiving an input to link another drawing with the current flowchart atstep 514. For example, theprocessor 1305 illustrated inFIG. 13 may receive an input to link another drawing with the current flowchart. For example,FIG. 6 below illustrates acontrol 654 that allows selection of another drawing which will permit cross reference between the flow chart and the another drawing when the patent specification is later created. - According to some examples, in response to the input at
step 514, themethod 500 includes identifying a structure in the linked drawing. For example, theprocessor 1305 illustrated inFIG. 13 may identify a structure in the linked drawing. For instance, a template file associated with the drawing may identify a plurality of structures that are selectable in the user interface. - According to some examples, the
method 500 includes updating controls associated with the claim segments atstep 518. For example, theprocessor 1305 illustrated inFIG. 13 may update controls associated with the claim segments. In an example, the structures identified in the template file may populate the controls located in the nodes to allow selecting of a structure that performs the action corresponding to the claim segment. - According to some examples, the
method 500 includes receiving an input in a control associated with a claim segment atstep 520. For example, theprocessor 1305 illustrated inFIG. 13 may receive an input in a control associated with a claim segment. In response to receiving the input, the claim segment corresponding to the control is then associated with performing the action. Accordingly, when the text of the patent specification is generated based on the specification data, the text will explicitly link the action associated with the claim segment with the structure. For example,FIG. 6 illustratescontrols 652 that allows linking a structure to a claim segment that a user can select different structures based on the drawing selected incontrol 654. - According to some examples, the
method 500 includes receiving a second input to indicate that language of a second claim segment partially defines a first claim segment that is displayed within the flowchart atstep 522. For example, theprocessor 1305 illustrated inFIG. 13 may receive a second input to indicate that the language of a second claim segment partially defines a first claim segment that is displayed within the flowchart. For example, as described below, FIG. 8 illustrates thatclaim segment 812 and claim segment 814 can be dragged into anode 800 to further defineclaim segment 802 of thenode 800. - According to some examples, the
method 500 includes displaying a first sub-flowchart within the first claim segment in the flowchart atstep 524. For example, theprocessor 1305 illustrated inFIG. 13 may display a first sub-flowchart within the first claim segment in the flowchart. In an example, a first drawing is generated from the specification data that corresponds to the flowchart and a second drawing is generated from the specification data that corresponds to the first sub-flowchart. In this first example, the first sub-flowchart further defines the action associated with the first claim segment. For example,FIG. 8 illustrates a sub-flowchart that further definesclaim segment 802. - According to some examples, the
method 500 includes receiving a third input to indicate that the language of a third claim segment partially defines the first claim segment displayed within the flowchart at step 526. For example, theprocessor 1305 illustrated inFIG. 13 may receive a third input to indicate that the language of a third claim segment partially defines the first claim segment displayed within the flowchart. - According to some examples, the
method 500 includes displaying a second sub-flowchart within the first claim segment in the flowchart atstep 528. For example, theprocessor 1305 illustrated inFIG. 13 may display a second sub-flowchart within the first claim segment in the flowchart. In an example, a first drawing is generated from the specification data that corresponds to the flowchart, a second drawing is generated from the specification data that corresponds to the first sub-flowchart, and a third drawing is generated from the specification data that corresponds to the second sub-flowchart. In this example, the second sub-flowchart also further defines the action associated with the first claim segment. Thus, the first sub-flowchart and the second sub-flowchart may be different species and may be mutually exclusive and multiple drawings may be generated based on the input into the flowchart user interface. As an example,FIG. 8 illustrates a tabbed interface for allowing different sub-flowcharts to be associated with asingle claim segment 802. - According to some examples, the method includes receiving an input to select at least one claim from the set of claims at
step 530. For example, theprocessor 1305 illustrated inFIG. 13 may receive an input to select at least one claim from the set of claims. In an example, at least one claim is excluded from a claim section of the patent specification. As noted above, this results in a claim being be used to generate text for the description, but is expressly excluded from the claims in the specification. - According to some examples, the
method 500 includes determining whether an identifier for the patent specification corresponds to a first entity atstep 532. For example, theprocessor 1305 illustrated inFIG. 13 may determine whether an identifier for the patent specification corresponds to a first entity. As will be described below with reference toFIG. 10 , the identifier is used to execute a client-specific module 1014 to perform common events that are particular to that client. For example, a first client may require multiple timing diagrams, a second client may require a circuit diagram having a similar layout, and a third client may require an engine illustration that requires different labels. - According to some examples, the
method 500 includes, when the identifier corresponds to the first entity, executing a module exclusively associated with the first entity at step 534. For example, theprocessor 1305 illustrated inFIG. 13 may, when the identifier corresponds to the first entity, execute a module exclusively associated with the first entity. - According to some examples, the
method 500 includes, in response to user input into the module, generating client specific data based on the module. For example, theprocessor 1305 illustrated inFIG. 13 may, in response to user input into the module, generate a portion of the specification data based on the module, the portion of the specification data be used to generate a drawing specific to the first entity. In one example, the client specific data is used to generate a drawing and a corresponding description specific to the first entity atstep 536. - According to some examples, the
method 500 includes generating specification data used to create a patent specification. The patent specification includes a description of the flowchart based on the second order at step 538. Further, the specification data may include the client specific data generated atstep 536. For example, theprocessor 1305 illustrated inFIG. 13 may generate specification data used to create a patent specification, the patent specification including a description of the flowchart based on the second order. The specification data includes all data necessary for generating a specification. For instance, the specification data may identify at least one template that is used to generate a description and drawings. The specification data may also include text generated at the client application that can be injected into the at least one template. As noted above, the drawing may include a flowchart and at least one sub-flowchart that further defines nodes within the flowchart. In another example, multiple flowcharts may be generated based on using a bypass node, which is described below in connection withFIGS. 9A to 9C . - In an example, the generating of the specification data comprises composing a device claim based on the independent claim. In another example, the device claim includes the text indicating that the structure performs the action corresponding to the first claim segment. In another example, the specification data includes data related to a preliminary amendment that is created to cancel at least one claim from the set of claims. In another example, the specification data comprises settings data related to options for controlling the generation of the patent specification. For example, the settings data may comprise any variation of the specification such as using “Figure” in lieu of “FIG,” or any other stylistic preference. For example, the setting data may include a flag indicating two spaces between sentences. In general, the settings data is generally based on preferences. However, the settings data may also include content related to generating the various descriptions of the flowcharts. For instance, the flowchart may be described in a breadth first or a depth first manner. In other examples, the settings data initially set in the application based on another template file that forms the underlying document for a particular client and includes data such as header text for the various headers in the specification, fonts, styles, margins, etc. As noted above, the specification data is used by an application or a server to generate a specification and drawings.
- In addition, the
method 500 may include additional steps not explicitly identified above. For instance, themethod 500 may include identifying a first occurrence of a noun object (i.e., an n-gram) within the claim segments based on the order of the claim segments. In this case, themethod 500 may insert language to indicate to the user to add additional description regarding this term. -
FIG. 6 illustrates anexample user interface 600 for arranging claim segments to generate a patent specification and drawings. In this example, the application is executing in the browser environment. However, the application could be a stand-alone application that natively executes in the operating system or an application add-in (e.g., a Microsoft Word® add-in). - As illustrated in
FIG. 6 , the rendered view from the browser displays theuser interface 600 that corresponds to a flowchart user interface. The user interface comprises a grid having a plurality of nodes (i.e., processes and other operations within the flowchart) and edges (i.e., arrows) between the nodes to illustrate a flowchart. In particular,node 602, node 604,node 606, node 608,node 610, and node 612 are displayed in the grid. Although not illustrated, theuser interface 600 may include start and end nodes. - Each node illustrated in
FIG. 6 is associated with at least one claim segment. Specifically, claim segment 614 is displayed vianode 602, claim segment 616 is displayed via node 604, claim segment 618 is displayed vianode 606,claim segment 620 is displayed via node 608,claim segment 622 is displayed vianode 610, and claim segment 624 is displayed via segment 612. In this example, the nodes serve as visual containers for the claim segments, enable complex user inputs, and allow complex associations of the claim segments to be simultaneously formed and displayed. - Each node displayed in
FIG. 6 is associated with at least one drop zone for receiving a claim segment as an input and change an order of the flowchart illustrated in theuser interface 600. In general, each node includes a drop zone below the node and a drop zone adjacent to the node. Specifically,node 602 is associated withdrop zone 626 anddrop zone 628, node 604 is associated withdrop zone 630 anddrop zone 632,node 606 is associated withdrop zone 634 anddrop zone 636, node 608 is associated withdrop zone node 610 is associated withdrop zone 642 anddrop zone 644, and node 612 is associated withdrop zone - The drop zones simultaneously provide a visual order to the flowchart and also enable dragging and dropping of segments to reorder the flowchart. As an example,
drop zone 626 anddrop zone 628 are associated withnode 602. Thedrop zone 628 is sequentially links thenode 602 to node 604 by virtue of the arrow (i.e., edge) located within thedrop zone 628. However, dropping another claim segment intodrop zone 628 informs the application that the dropped segment is should be positioned betweennodes 602 and 604. Thus, the drop zones allow a claim segment to be dragged and dropped into the corresponding drop zone, which inserts the claim segment at the corresponding location and allows the user to manipulate the claim segments to visually construct a flowchart using claim segments. -
FIG. 6 illustrates claim segment 618 as a node precedingclaim segment 620.FIG. 6 also illustrates thatclaim segment 622 is displayed as a branch of claim segment 618. This branch is the result ofclaim user interface 600 receiving a drag and drop ofsegment 622 intodrop zone 634. Thus, at claim segment 618, the method illustrated in theuser interface 600 can proceed to eitherclaim segment 620 orclaim segment 622. As illustrated inFIG. 6 , after this drop event, theuser interface 600 has created an additional column in theuser interface 600 for displaying theclaim segment 622. After this drop event has occurred, a drop event could still be received indrop zone 634 to position another claim segment between claim segment 618 andclaim segment 622. Similarly, a claim segment can be received intodrop zone 636 to cause the claim segment to be positioned between claim segment 618 andclaim segment 620. - The
user interface 600 also allows the complex display of the various claim segments. For example, a passive claim segment 650 may be displayed withinnode 602 to visually illustrate that the passive claim segment 650 further defines subject matter within claim segment 614. To position the passive claim segment 650, claim segment 650 is dragged and dropped into claim segment 614. However, as will be described below with reference toFIG. 8 , dropping an active claim segment into claim segment 614 will create an embedded sub-flowchart within thenode 602. - The
node 602 may also illustrate acontrol 652 for selecting a device that performs the action in claim segment 614. Theuser interface 600 also includes acontrol 654 that allows a corresponding figure to be selected. Using thecontrol 654, the user is able to select the figure (e.g., Figure A in this example) that includes a list of structures (e.g.,XX 210 selected incontrol 652, XX220 selected innode 606, etc.) that can populate thecontrol 652. By selecting thecontrol 652, the claim segment 614 can be linked to structures in different drawings in connection with generating the patent specification. - That is, the
user interface 600 displays a flowchart user interface that allows the user to intuitively drag and drop various claim segments in a simple manner. As such, the user is able to quickly and accurately order the claim segments, which also changes the underlying data structure and affects how the description of the flowchart will be written by the application. In addition, thecontrol 652 andcontrol 654 allow the user to select a hardware figure and corresponding structure, which will be used to generate the specification. In other examples, by selecting the structure via thecontrol 652 andcontrol 654, a claim can be composed to include that the selected structures perform the corresponding action. - Nodes within conditional branches may also include an additional control for identifying a return node and creating a
return arrow 658 that illustrates the flow of the method. InFIG. 6 ,node 622 is the final node of the branch and therefore includes areturn control 656 to indicate the next node within another branch. InFIG. 6 , thenode 622 has been changed to return the flow of the illustrated method to label X60 corresponding to node 612. -
FIG. 7 illustrates an example illustration of auser interface 700 for arranging claim segments and includes aclaim panel 702 that displays claim segments embedded within the claims based on a feedback scheme. - In particular,
FIG. 7 illustrates three claims (A, B, and C). Claim A includesclaim segment 704,claim segment 706,claim segment 708, andclaim segment 710. In addition, claim A incudes acommon word 712 that is not allocated to any claim segments and any trailing or leading punctuation or whitespace is excluded from the claim segments. Claim B includesclaim segment 714 and claim C includesclaim segment 716. - The
user interface 700 allows the user to drag a claim segment from theclaim panel 702 and drop a claim segment as described above with reference toFIG. 6 . In particular,claim segment 714 was previously dragged to precedeclaim segment 706 in the flowchart user interface. Although not illustrated,claim segment 704 is not displayed because it precedesclaim segment 714 withinuser interface 700 and can be viewed by scrolling. For clarity, the dashed lines illustrated inFIG. 7 illustrateclaim segment 706,claim segment 708, andclaim segment 714 and their respective positions in theuser interface 700 and theclaim panel 702. Theclaim segment 706,claim segment 708, andclaim segment 714 may also include a label (e.g., a reference numeral) that is used to label each active claim segment in theuser interface 700 and theclaim panel 702. For instance,claim segment 706 is labeled with YY3 andclaim segment 714 is labeled with YY1. -
Claim segment 718, which precedesclaim segment 714 in theuser interface 700, is not illustrated in theclaim panel 702 and may either be provided from another claim that is not illustrated inclaim panel 702 or may be separately input using, for example, a supplemental segment component for allowing the user to manually create claim segments. Similarly,claim segment 720 and claim segment 722 are not illustrated in theclaim panel 702 and may be associated with claims not illustrated in claim panel 702 (i.e., the claims can be viewed if theclaim panel 702 is scrolled downward) or may be separately input and are not found within the claims. - Further, the claim segments illustrated in the
claim panel 702 may be color coded to provide visual feedback. In the example illustrated inFIG. 7 , when a claim segment is allocated (i.e., assigned a position) within theuser interface 700, the claim segment may be coded with a first color. In particular,claim segment 704,claim segment 706,claim segment 708, andclaim segment 714 are allocated within the user interface 700 (withclaim segment 704 not being viewable based on scrolling the user interface 700). As noted throughout this disclosure, the various claim segments can be added, moved, and removed from the flowchart. When a corresponding claim segment is deleted from the flowchart (using the delete icon), the claim segment is referred to as unallocated. -
Claim segment 710 andclaim segment 716, which are displayed in theclaim panel 702, are not allocated and are color coded to provide additional feedback. In particular,claim segment 710 is coded with a second color to indicate thatclaim segment 710 is an active phrase and is not allocated within theuser interface 700.Claim segment 716 is coded with a third color to indicate thatclaim segment 716 is a passive phrase and is also not within theuser interface 700.Claim segment 710 andclaim segment 716 also do not include a reference label because they are not allocated within theuser interface 700. - Although not illustrated in
FIG. 7 , the claim segments (or nodes that provide visual containers for the claim segments) may include a delete icon that allows the claim segment to be unallocated from theuser interface 700. In response to input to delete a claim segment, theuser interface 700 would recalculate the flowchart illustrated in theuser interface 700 and change the feedback provided by the corresponding claim segment in theclaim panel 702. - In addition, the nodes may each contain a grouping option that allows nodes to be combined into groups or combined with a previous paragraph when the specification is drafted. In this example, a grouping option 724 for
claim segment 720 and a grouping option 726 are illustrated and remaining nodes are not illustrated with this option for convenience. When the grouping options 724 and 726 are selected, the specification generation groups these claim segments and drafts the specification based on the grouping. That is, theclaim segments 720 and 722 may be described in a single paragraph for simplicity. - Further, the claim segments in the
user interface 700 may be configured to be excluded from the final set of claims. In an example, the reference label in the claim segment 722 may be selected to indicate that this subject matter can be excluded from the final claims. In this example, when the reference label is selected, the reference label is replaced by an option 728 that is unchecked to indicate that the claim associated with the claim segment 722 is to be omitted from the final claims. When the option 728 is further selected, the claim corresponding to the claim segment 722 would be included. The option 728 may also be used to suppress a node from being created in a corresponding a flowchart drawing (i.e., a drawing document including the flowchart). - Thus, the
claim panel 702 provides a visual feedback scheme that is used in conjunction with theuser interface 700 to allow the user to easily manipulate the various claim segments to visually draft the specification using a drag and drop user interface. In addition, additional user interface options are illustrated that further allow finer control of the specification and allowing the user to include content generated from the input claims while simultaneously excluding these claims from the finalized claims. As a result, the user is able to provide a detailed set of preliminary claims to effectively draft all necessary details, then selectively remove claims from the claims section in the generated patent specification. - In another example, a separate component can be provided to allow claims to be composed into different statutory classes using the claim segments and various templates. In such a component, the user would be able to select a final set of claims based on the set of preliminary claims and the composed claims. The application could manage the claim content using the user interface to ensure correct claim numbering, correct claim dependency, and so forth.
-
FIG. 8 illustrates anexample node 800 that allow complex manipulation of claim segments to create complex descriptions in the patent specification. In particular, thenode 800 can be associated withclaim segment 802, which has been allocated reference label YY1 and includes adelete icon 804 and acontrol 806 for selecting a structure to perform the action associated withclaim segment 802. Further, thenode 800 can include atab interface 810 to allow other active claim segments that further defineclaim segment 802. In the example illustrated inFIG. 8 ,claim segment 812 and claim segment 814 further define a first embodiment illustrated in thefirst tab 816. That is, aclaim segment 812 further definesclaim segment 802 by recited an action that is encompassed withinclaim segment 802. - Further, the first embodiment illustrated in
tab 816 can includedrop zone 818,drop zone 820,drop zone 822,drop zone 824, anddrop zone 826 to allow other claim segments to be dropped into thefirst tab 816. Thus, thenode 800 may contain a separate sub-flowchart interface fully embedded within a claim segment. Moreover, each segment within the node can also include a separate flowchart interface, allowing unlimited recursion of flowcharts. - The
tab interface 810 can also include multiple tabs such assecond tab 828 andthird tab 830 in this example. To generate the first tab, theclaim segment 812 is dragged and dropped into the claim segment 802 (or node 800). Similarly, to generate the second tab, another segment (not shown) is dragged into the claim segment 802 (or node 800). - The
second tab 828 andthird tab 830 allow different claim segments to be inserted, thereby allowing multiple embodiments that are mutually exclusive to be provided. Moreover, when generating the specification, the different embodiments illustrated in thefirst tab 816,second tab 828, andthird tab 830 will be described separately in the patent specification, thereby allowing the system to generate a more accurate specification and require less human editing and revision. -
FIGS. 9A, 9B, and 9C illustrate anexample node 900 that allows different alternatives. In particular,FIGS. 9A, 9B, and 9C illustrate a bypass segment that allows optional actions to be defined in the user interface. - Specifically,
FIG. 9A , thenode 900 includes a tab interface including afirst tab 902,second tab 904, and athird tab 906 for illustration purposes. Thefirst tab 902 comprises an arrow 908 that corresponds to an edge in graph theory and simply indicates that no further actions occur atnode 900. That is, in thefirst tab 902, thenode 900 is bypassed in the execution of the flowchart. - However, if the user selects the
second tab 904, thenode 900 displays thesecond tab 904 illustrated inFIG. 9B . InFIG. 9B , thesecond tab 904 is associated with aclaim segment 910, and indicates an optional node that can be executed in the flowchart. - Further, if the user selects the
third tab 906, the node displays thethird tab 906 illustrated inFIG. 9C . The third tab comprises aflowchart user interface 912 that is embedded and allows additional claim segments to be inserted and manipulated based on dragging and dropping into the claim segments and drop zones as noted above. - That is, in the example illustrated in
FIGS. 9A, 9B, and 9C , the application may be configured to generate different flowcharts using the bypass segment innode 900. The application may also be configured to generate sub-flowcharts linked to the main flowchart similar toFIG. 8 . - The examples illustrated in
FIGS. 8, 9A, 9B, and 9C illustrate that the nodes allow optional segments and optional sub-flowcharts to be defined to thereby allow more complex associations with the claim segments to be defined. Based on the various nodes described above, the user interface is able to represent an entire set of method claims regardless of the complexity of the method claims. However, while the various examples can be illustrated in a single dynamic user interface, generating a single drawing with all detail may not be possible. Accordingly, in some examples, the system may also generate a separate drawing for each sub-flowchart or may generate additional flowcharts illustrating all variations of the flowcharts. - Further, the above examples illustrate simple flowcharts for clarity and conciseness. However, the user interfaces illustrated above can be embedded into nodes, thereby allowing unlimited complexity if required. Further, at best one conditional branch is illustrated, but conditions can be linked (i.e., a switch operation) to allow unlimited complexity in the flowchart. For simplicity, the above user interfaces are referred to as directed acrylic graph (DAG) because the flow of the user interface does not allow a previous node to be revisited. However, the instant disclosure is not limited to DAG and can be bidirectional, allowing previous nodes to be revisited (i.e., a loop).
-
FIG. 10 illustrates auser interface 1000 that allows a user to provide input into theuser interface 1000 to build a specification using point and click operations in conjunction with a client-specific module. In particular, theuser interface 1000 illustrates aheader region 1002, atemplate region 1004, and aspecification region 1006. Theheader region 1002 is related to a “wizard” or “stepper” component that allows the user to select different stages to control the creation of the patent specification. As will be described below, theheader region 1002 dynamically adds and removes steps based on inputs received in interfaces prior to the presentation ofuser interface 1000, inputs after the presentation ofuser interface 1000, and inputs into theuser interface 1000. - In the
user interface 1000, the user selects different templates that are used to generate the specification from thetemplate region 1004. In response, thespecification region 1006 generates a specification section corresponding to a template selected in thetemplate region 1004 and provides some detail, such as the illustrated figure number (e.g., Figure A). Although the specification sections illustrated in thespecification region 1006 generally are associated with illustrations, the specification sections can also include text-only regions such as a boilerplate related to a legal interpretation of a term. As an example, the text-only region can include text that is devised based on the administrative agency's guidance with respect to a particular legal issue (e.g., subject matter eligibility) or administrative issue that comports with the agency's guidance. - Further, the different specification sections can easily be rearranged in the
specification region 1006 to allow the user to essentially point and click to create a specification. - In
FIG. 10 , the example user interface includes aspecification template 1008 related to a first method claim (claim A) and aspecification template 1010 related to a second claim (claim C). The user is able to select eitherspecification template 1008 and/orspecification template 1010, which then allows theuser interface 1000 to add amodule 1012 corresponding to that claim. As illustrated inFIG. 10 , the user selects thespecification template 1008, which causes theheader region 1002 to dynamically insert amodule 1012 for generating content associated with that claim. As noted above, the module may be a flowchart user interface. Further, as illustrated inFIG. 10 , claim B is not detected as a method claim and, therefore, thetemplate region 1004 excludes any potential drawing related to a flowchart for claim B. However, in some examples, the system may generate a flowchart based on a device or system claim using NLP. -
FIG. 10 also illustrates a client-specific module 1014, which was added based on an identification of the client. In this example, the client is a legal entity (e.g., a corporation) or a person that would benefit from the operation of amodule 1014 that is specific to their needs. That is, the application determines whether the patent specification to be generated corresponds to a specific client that has a client module for generating specification data. If the patent specification corresponds to the specific client, the client-specific module 1014 is inserted into the component for execution before or after theuser interface 1000. - The client-
specific module 1014 provides a user interface to creating specification data that is specific to that client. A client may have specific content that needs to be recreated and the client-specific module 1014 provides a user interface for generating the same. For example, a first client may require multiple timing diagrams, a second client may require a circuit diagram having a similar layout, and a third client may require an engine illustration that requires different labels. Using the NLP tokens, claim segments, inputs described above, and other inputs unique to the client-specific module 1014, the client-specific module 1014 may generate specification data for creating a drawing and specification content. Thus, the client-specific module 1014 is tuned specifically for each client to provide better and more accurate specifications. -
FIG. 11 illustrates a flowchart of amethod 1100 for generating a specification based on related application that is identified using NLP. Although theexample method 1100 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 themethod 1100. In other examples, different components of an example device or system that implements themethod 1100 may perform functions at substantially the same time or in a specific sequence. - According to some examples, the
method 1100 includes transmitting text associated with patent claims to a server for NLP analysis, the patent claims comprising an independent claim and at least one dependent claim that form a set of claims atstep 1102. For example, theprocessor 1305 illustrated inFIG. 13 may transmit text associated with patent claims to a server for NLP analysis, the patent claims comprising an independent claim and at least one dependent claim that form a set of claims. - According to some examples, the
method 1100 includes receiving NLP tokens from the server based on the NLP analysis and a list of objects that are identified in the text based on the NLP analysis atstep 1104. For example, theprocessor 1305 illustrated inFIG. 13 may receive NLP tokens from the server based on the NLP analysis and a list of objects that are identified in the text based on the NLP analysis. In this case, the list of objects are n-grams (i.e., compound words) that are extracted from the claims. - According to some examples, the
method 1100 includes identifying generic labels in the list of objects that distinguish similar objects from each other atstep 1106. For example, theprocessor 1305 illustrated inFIG. 13 may identify generic labels in the list of objects that distinguish similar objects from each other. For example, the generic label may be an ordinal number (first, second, etc.), a past tense adjectival modifier (e.g., selected, displayed, etc.), and so forth. - According to some examples, the
method 1100 includes, for each similar object, removing the generic labels to create a single object corresponding to each similar object atstep 1108. For example, theprocessor 1305 illustrated inFIG. 13 may, for each similar object, remove the generic labels to create a single object corresponding to each similar object. - According to some examples, the
method 1100 includes generating a term frequency (TF) for a set of first objects based on the list of objects at step 1110. For example, theprocessor 1305 illustrated inFIG. 13 may generate a term frequency (TF) for a set of first objects based on the list of objects. That is, the generic label is stripped from the n-gram to distill the n-grams to their most basic form and count the most frequent n-grams. - According to some examples, the
method 1100 includes searching a patent application repository based on the TF of the set of first objects atstep 1112. For example, theprocessor 1305 illustrated inFIG. 13 may search a patent application repository based on the TF of the set of first objects. In an example, the searching of the patent application repository is based on a comparison of claims. - In an example of the searching at
step 1112, themethod 1100 comprises comparing the TF of the set of first objects with a second list of objects, the second list of objects being associated with a second patent application in the patent application repository and being generated based on a TF of objects identified by claims in the second patent application. For example, theprocessor 1305 illustrated inFIG. 13 may compare the TF of the set of first objects with a second list of objects, the second list of objects be associated with a second patent application in the patent application repository and be generated based on a TF of objects identified by claims in the second patent application. - Further, searching at
step 1112 may comprise determining whether to include the second patent application in the list of patent applications based on the comparison of the TF of the set of first objects and the second list of objects. For example, theprocessor 1305 illustrated inFIG. 13 may determine whether to include the second patent application in the list of patent applications based on the comparison of the TF of the set of first objects and the second list of objects. - In another example, the searching at
step 1112 may comprise receiving at least one additional search parameter that is input by a user. For example, theprocessor 1305 illustrated inFIG. 13 may receive at least one additional search parameter that is input by a user. In an example, the searching of the patent application repository is further based on the at least one additional search parameter. - In the second example, the searching at
step 1112 may further comprise comparing the TF of the set of first objects with a third list of objects, associated with a second patent application, the third list of objects being generated based on an term frequency-inverse document frequency (TF-IDF). For example, theprocessor 1305 illustrated inFIG. 13 may compare the TF of the set of first objects with a third list of objects, associated with a second patent application, the third list of objects be generated based on an TF-IDF. In an example, the determining of whether to include the second patent application in the list of patent applications is further based on the comparison of the TF of the set of first objects and the TF-IDF. Because the specification may have a high frequency of common generic structures, it may be preferable to generate the TF-IDF for the second patent application, thereby allowing a better comparison of claims to the specification. - According to some examples, the
method 1100 includes receiving a list of patent applications corresponding to the TF based on the search of the patent application repository atstep 1114. For example, theprocessor 1305 illustrated inFIG. 13 may receive a list of patent applications corresponding to the TF based on the search of the patent application repository. - According to some examples, the
method 1100 includes receiving specification data generated based on user manipulation of a plurality of claim segments associated with the NLP tokens, the specification data including selection data related to a first patent application, at step 1116. For example, theprocessor 1305 illustrated inFIG. 13 may receive specification data generated based on user manipulation of claim segments as described above with reference toFIG. 5 . However, in this example, the specification data also may include selection data related to another patent application, which is selectively incorporated based on user input. - According to some examples, the
method 1100 includes identifying a document associated with the first patent application and extracting specification content from the document based on the selection data atstep 1118. For example, theprocessor 1305 illustrated inFIG. 13 may identify a document associated with the first patent application and extract specification content from the document based on the selection data. - In another example, the identifying at
step 1118 comprises identifying a start of first content related to a figure number identified by the selection data. For example, theprocessor 1305 illustrated inFIG. 13 may identify a start of first content related to a figure number identified by the selection data. - Further, the identifying at
step 1118 further comprises identifying a start of second content related to a second figure number that follows the figure number identified by the selection data. For example, theprocessor 1305 illustrated inFIG. 13 may identify a start of second content related to a second figure number that follows the figure number identified by the selection data. - Further, the identifying at
step 1118 comprises extracting the specification content that is located between the first content and the second content. For example, theprocessor 1305 illustrated inFIG. 13 may extract the specification content that is located between the first content and the second content. - Further, the identifying at
step 1118 comprises searching reference numerals in the specification content based on an original figure number assigned to drawing content in the first patent application. For example, theprocessor 1305 illustrated inFIG. 13 may search reference numerals in the specification content based on an original figure number assigned to draw content in the first patent application. - Further, the identifying at
step 1118 comprises replacing the reference numerals based on the figure number assigned to the specification content. For example, theprocessor 1305 illustrated inFIG. 13 may replace the reference numerals based on the figure number assigned to the specification content. - Further, the identifying at
step 1118 comprises identifying a summary description corresponding to the figure number in a section of the first patent application related to drawing descriptions. For example, theprocessor 1305 illustrated inFIG. 13 may identify a summary description corresponding to the figure number in a section of the first patent application related to drawing descriptions. - Further, the identifying at
step 1118 comprises extracting the summary description. For example, theprocessor 1305 illustrated inFIG. 13 may extract the summary description. - According to some examples, the
method 1100 includes editing the specification content based on a figure number assigned to the specification content atstep 1120. For example, theprocessor 1305 illustrated inFIG. 13 may edit the specification content based on a figure number assigned to the specification content. - According to some examples, the
method 1100 includes generating a patent specification based on the specification data and including the specification content, the patent specification comporting with a plurality of procedural requirements, atstep 1122. For example, theprocessor 1305 illustrated inFIG. 13 may generate a patent specification based on the specification data and include the specification content, the patent specification comport with a plurality of procedural requirements. - According to some examples, the
method 1100 includes identifying a drawing associated with the first patent application and extracting drawing content from the drawing based on the selection data atstep 1124. For example, theprocessor 1305 illustrated inFIG. 13 may identify a drawing associated with the first patent application and extract drawing content from the drawing based on the selection data. However, the disclosure can also be applicable to content that relates to content reuse through searching using different techniques. For instance, the disclosure can be applied to a legal document (e.g., a contract, an agreement, etc.) and/or a formal document (e.g., a petition, a plan, a proposal, a request for proposal (RFP), change request, invoice, etc.) comporting with at least one procedure, statute, or requirement. - According to some examples, the
method 1100 includes editing the drawing content based on the figure number atstep 1126. For example, theprocessor 1305 illustrated inFIG. 13 may edit the drawing content based on the figure number. - In another example, the editing of the drawing content at
step 1126 comprises searching text labels based on an original figure number assigned to the drawing content in the first patent application. For example, theprocessor 1305 illustrated inFIG. 13 may search text labels based on an original figure number assigned to the drawing content in the first patent application. - Further, the
method 1100 comprises replacing a portion of the text labels based on the figure number assigned to the specification content. For example, theprocessor 1305 illustrated inFIG. 13 may replace a portion of the text labels based on the figure number assigned to the specification content. - According to some examples, the editing of the drawing content at
step 1126 comprises generating patent drawings based on the specification data and including the drawing content atstep 1128. For example, theprocessor 1305 illustrated inFIG. 13 may generate patent drawings based on the specification data and include the drawing content. -
FIG. 12 illustrates anexample user interface 1200 that may implement a portion of the features described inFIG. 11 .FIG. 12 illustrates a “wizard” or “stepper” component similar toFIG. 10 including aheader 1202 and aspecification region 1206. Theuser interface 1200 further includes asearch results panel 1208 that illustrates afirst application 1210, asecond application 1212, and athird application 1214, which are identified based on a result of the TF search described above. - Each application displayed in the
search results panel 1208 includes various static information such as serial number, docket number, a summary, and a description. The description may be scrollable or may allow the user to selectively display a portion of the description. Using the user interface for each application, the user is able to quickly review each drawing and may identify related content that is similar to the current application that is being drafted. - Similar to
FIG. 10 , theuser interface 1200 allows the user to select a drawing and selectively incorporate the same into thespecification region 1206. As illustrated inFIG. 12 , with respect toFIG. 11 , the system generates specification data identifying the subject matter from thefirst application 1210 andsecond application 1212 to incorporate in the current application. Because current documents and drawings are stored in an XML format, the system is able to extract the selected content from the original source, modify the selected content based on the user input, and insert the modified content. However, in some examples, the drawing may not be stored in an XML format. In that case, the system may convert the drawing into a bitmap and then insert the bitmap drawing into the new drawing. - The examples disclosed above allow more accurate and more complete patent specifications to be generated using a dynamic and intuitive user interface. Further, the examples disclosed above allow better tokenization of the claims. Further, unlike existing system, because the disclosed user interface can represent all method claims and variations of the method claims, complex specifications and more complex drawings can be created, which minimizes revision of the generated patent specification. In addition, prior systems have only contemplated generating a single flowchart for each set of method claims. However, the examples described above disclose that a set of method claims can be converted into multiple flowcharts and multiple descriptions. The patent specifications generated by the instant disclosure therefore are more complete, more accurate, and require minimal revision, thereby providing a benefit over existing systems. Finally, a search system is disclosed that searches for related applications using NLP analysis of the claims and NLP analysis of the previously filed patent application. Using the disclosed search system, the user is able to selectively incorporate content from related applications and the search system updates the selected content to facilitate editing and incorporating additional or different subject matter.
-
FIG. 13 illustrates anexample computer system 1300 for executing client or server operations. For example, theexample computer system 1300 may execute a client application, a server side application for performing the instant disclosure, or an NLP engine. - The
example computer system 1300 includes aprocessor 1305, amemory 1310, agraphical device 1315, anetwork device 1320,interface 1325, and a storage device 1330 that communicate and operate via aconnection 1335. Theconnection 1335 can be a physical connection via a bus, or a direct connection intoprocessor 1305, such as in a chipset architecture. Theconnection 1335 can also be a virtual connection, networked connection, or logical connection. - The
processor 1305 reads machine instructions (e.g., reduced instruction set (RISC), complex instruction set (CISC), etc.) that are loaded into thememory 1310 via a bootstrapping process and executes an operating system for executing applications within frameworks provided by the operating system. That is, theprocessor 1305 can include any general-purpose processor and a hardware service or software service, which are stored inmemory 1310, and configured to controlprocessor 1305 as well as a special-purpose processor where software instructions are incorporated into the actual processor design. Theprocessor 1305 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 1305 may execute an application that executes an application provided by a graphical framework such as Winform, WPF, Windows User Interface (WinUI), or a cross platform user interface such as Xamarin or QT. In other examples, theprocessor 1305 may execute an application that is written for a sandbox environment such as a web browser. - The
processor 1305 controls thememory 1310 to store instructions, user data, operating system content, and other content that cannot be stored within theprocessor 1305 internally (e.g., within the various caches). Theprocessor 1305 may also control a graphical device 1315 (e.g., a graphical processor) that outputs graphical content to adisplay 1340. In some example, thegraphical device 1315 may be integral within theprocessor 1305. In yet another example, thedisplay 1340 may be integral with the computer system 1300 (e.g., a laptop, a tablet, a phone, etc.). In some example, thegraphical device 1315 may be integral with theprocessor 1305 and form an accelerated processing unit (APU). - The
graphical device 1315 may be optimized to perform floating point operations such as graphical computations, and may be configured to execute other operations in place of theprocessor 1305. For example, controlled by instructions to perform mathematical operations optimized for floating point math. For example, theprocessor 1305 may allocate instructions to thegraphical device 1315 for operations that are optimized for thegraphical device 1315. For instance, thegraphical device 1315 may execute operations related to artificial intelligence (AI), natural language processing (NLP), and vector math. The results may be returned to theprocessor 1305. In another example, the application executing in theprocessor 1305 may provide instructions to cause theprocessor 1305 to request thegraphical device 1315 to perform the operations. In other examples, thegraphical device 1315 may return the processing results to another computer system (i.e., distributed computing). - The
processor 1305 may also control anetwork device 1320 for transmits and receives data using a plurality ofwireless channels 1345 and at least one communication standard (e.g., Wi-Fi (i.e., 802.11ax, 802.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®). Thenetwork device 1320 may wirelessly connect to anetwork 1350 to connect toservers 1355 or other service providers. Thenetwork device 1320 may also be connected to thenetwork 1350 via a physical (i.e., circuit) connection. Thenetwork device 1320 may also directly connect to localelectronic device 1360 using a point-to-point (P2P) or a short range radio connection. - The
processor 1305 may also control aninterface 1325 that connects with anexternal device 1370 for bidirectional or unidirectional communication. Theinterface 1325 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 1365 is able to receive data from theinterface 1325 to process the data or perform functions for different applications executing in theprocessor 1305. For example, the external device 1365 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 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 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 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.
- The storage device 1330 can include software services, servers, services, etc., that when the code that defines such software is executed by the
processor 1305, 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 asprocessor 1305,connection 1335,external device 1370, etc., to carry out the function. - While much of the above description is focused on receiving claim segments as an input into the natural language processing engine, other inputs are possible. For example, in some embodiments, an initial input could be a figure having labels. In such an embodiment, the drafting system would identify each label and query an author for a description of the labeled portion and its interaction or relationship with another labeled portion. These descriptions of the labeled portions and their interactions or relationships with other labeled portions can be fed into the natural language processing server. Thereafter the natural language processing server can output structured statements in an initial sequence for additional refinement and rearranging by the user as described above.
- While much of the above description referred to the presentation of claim segments in the form of a flowchart other mechanisms for the presentation of the claim segments (structured statements) are contemplated. For example a flowchart can be viewed as a stand-in for an outline. A flowchart as discussed above as an example embodiment mainly because it is also a required feature of a software patent application, but an outline format would be just as effective. And in outline format would be more intuitive for other types of documents. In an outline format individual statements can be levels of an outline, and just as described above the various levels of outline can be rearranged into independent concepts and nested concepts just as described above.
- As described above the present technology can receive any collection of statements having a basic relationship between the statements and can extract parts of speech from these statements and provide an initial organization for the statements. Thereafter the present technology can receive further inputs to rearrange and modify and add to the statements and ultimately provide an initial draft of a document. In this way the present technology provides advantages over existing technologies through improvements in the machine-user interface improvements and inputs to natural language processing server improvements income terms of complexity of initial inputs and subsequent inputs which all can result in a better initial draft provided by the national language processing server and available from existing technologies.
- 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 some examples, the disclosed system can be used to arrange a contract or an agreement based on text input. In other examples, the disclosed system can be used a new drug application at the FDA, a change request for a manufacturing process, a non-disclosure agreement, a technical paper that presents a flowchart or sequence diagram.
- The disclosed system can be used to arrange a contract or another type agreement based on text input (e.g., a non-disclosure agreement, an employment agreement, a contract, etc.). An agreement related to a contract may need to specify obligations and consequences of achieving of failing to achieve those obligations. The instant disclosure could receive a text-based input and generate a flowchart, which would then be converted into legal text based on various templates.
- In other examples, the disclosed system can be used a new drug application at the U.S. Food & Drug Administration (FDA), a change request for a manufacturing process, or a proposal. As an example, the disclosed system may implement a named entity recognition (NER) module to identify chemical compounds and use the identified chemical compounds to create a user interface that would allow the user to control components to create description for the new drug application.
- Additional concepts can be incorporated to further benefit the disclosed system. For instance, an NER module can be trained based on patent claims to identify common words and identify points to segment claims and identify logical breaks in claims. An NER module may also be used to analyze language and generate a sequence diagram illustrating communication between different devices such as
FIG. 3 of the instant disclosure. The user would be provided an interface similar to the disclosure above to allow correction of the communication sequence and then further create a description of the communication sequence. - However, the disclosure can also be applicable to content that relates to content reuse through searching using different techniques. For instance, the disclosure can be applied to a legal document (e.g., a contract, an agreement, etc.) and/or a formal document (e.g., a petition, a plan, a proposal, a request for proposal (RFP), change request, invoice, etc.) comporting with at least one procedure, statute, or requirement.
- 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 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, 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 laptops, smart phones, small form factor personal computers, personal digital assistants, rackmount devices, standalone devices, 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 the example method illustrated herein depict 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. In other examples, different components of an example device or system that implements the methods illustrated herein may perform functions at substantially the same time or in a specific sequence.
- 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.
Claims (20)
1. A method for generating a document, comprising:
receiving text comprising at least one independent claim;
analyzing the text using a natural language processor (NLP) to generate NLP tokens from the text;
identifying at least a portion of the NLP tokens for a subsequent analysis;
analyzing additional text corresponding to the portion of the NLP tokens to generate second NLP tokens;
merging the second NLP tokens into the NLP tokens; and
generating a patent specification, the patent specification including a description of a flowchart that is generated based on the NLP tokens.
2. The method of claim 1 , further comprising:
generating a unique identifier associated with at least a portion of the text, wherein merging the second NLP tokens into the NLP tokens is based on the unique identifier.
3. The method of claim 2 , wherein the unique identifier includes at least one of a claim number, a line identifier, and a token position on associated with the line identifier.
4. The method of claim 1 , further comprising:
analyzing whitespace associated with the text to form a relationship between at least two lines of text separated by a line break, wherein the patent specification is generated based on the relationship of the at least two lines.
5. The method of claim 1 , wherein the portion of the NLP tokens comprises a phrase that modifies a root object associated with a line of the text.
6. The method of claim 1 , further comprising:
generating claim segments for the at least one independent claim from the NLP tokens based on an analysis of the NLP tokens.
7. The method of claim 6 , further comprising:
displaying information corresponding to the claim segments.
8. The method of claim 7 , wherein a claim segment of the claims segments is linked to a structure that is associated with the at least one independent claim.
9. The method of claim 8 , wherein the patent specification includes at least one sentence including the structure and text generated based on the claim segment.
10. The method of claim 1 , further comprising:
displaying a user interface for interacting with the at least one of the text and the NLP tokens, wherein the patent specification is generated based on interactions within the user interface.
11. A non-transitory computer readable medium comprising instructions, the instructions, when executed by a computing system, cause the computing system to:
receive text comprising at least one independent claim;
analyze the text using a natural language processor (NLP) to generate NLP tokens from the text;
identify at least a portion of the NLP tokens for a subsequent analysis;
analyze additional text corresponding to the portion of the NLP tokens to generate second NLP tokens;
merge the second NLP tokens into the NLP tokens; and
generate a patent specification, the patent specification including a description of a flowchart that is generated based on the NLP tokens.
12. The computer readable medium of claim 11 , wherein the computer readable medium further comprises instructions that, when executed by the computing system, cause the computing system to:
generate a unique identifier associated with at least a portion of the text, wherein merging the second NLP tokens into the NLP tokens is based on the unique identifier.
13. The computer readable medium of claim 12 , wherein the unique identifier includes at least one of a claim number, a line identifier, and a token position on associated with the line identifier.
14. The computer readable medium of claim 11 , wherein the computer readable medium further comprises instructions that, when executed by the computing system, cause the computing system to:
analyze whitespace associated with the text to form a relationship between at least two lines of text separated by a line break, wherein the patent specification is generated based on the relationship of the at least two lines.
15. The computer readable medium of claim 11 , wherein the portion of the NLP tokens comprises a phrase that modifies a root object associated with a line of the text.
16. The computer readable medium of claim 11 , wherein the computer readable medium further comprises instructions that, when executed by the computing system, cause the computing system to:
generate claim segments for the at least one independent claim from the NLP tokens based on an analysis of the NLP tokens.
17. The computer readable medium of claim 16 , wherein the computer readable medium further comprises instructions that, when executed by the computing system, cause the computing system to:
display information corresponding to the claim segments.
18. The computer readable medium of claim 17 , wherein a claim segment of the claim segments is linked to a structure that is associated with the at least one independent claim.
19. The computer readable medium of claim 18 , wherein the patent specification includes at least one sentence including the structure and text generated based on the claim segment.
20. The computer readable medium of claim 11 , wherein the computer readable medium further comprises instructions that, when executed by the computing system, cause the computing system to:
display a user interface for interacting with the at least one of the text and the NLP tokens, wherein the patent specification is generated based on interactions within the user interface.
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US18/119,115 US20230222286A1 (en) | 2020-09-08 | 2023-03-08 | Dynamically generating documents using natural language processing and dynamic user interface |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US17/014,403 US11610051B2 (en) | 2020-09-08 | 2020-09-08 | Dynamically generating documents using natural language processing and dynamic user interface |
US18/119,115 US20230222286A1 (en) | 2020-09-08 | 2023-03-08 | Dynamically generating documents using natural language processing and dynamic user interface |
Related Parent Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US17/014,403 Continuation US11610051B2 (en) | 2020-09-08 | 2020-09-08 | Dynamically generating documents using natural language processing and dynamic user interface |
Publications (1)
Publication Number | Publication Date |
---|---|
US20230222286A1 true US20230222286A1 (en) | 2023-07-13 |
Family
ID=80470696
Family Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US17/014,403 Active 2040-10-29 US11610051B2 (en) | 2020-09-08 | 2020-09-08 | Dynamically generating documents using natural language processing and dynamic user interface |
US18/119,115 Pending US20230222286A1 (en) | 2020-09-08 | 2023-03-08 | Dynamically generating documents using natural language processing and dynamic user interface |
Family Applications Before (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US17/014,403 Active 2040-10-29 US11610051B2 (en) | 2020-09-08 | 2020-09-08 | Dynamically generating documents using natural language processing and dynamic user interface |
Country Status (1)
Country | Link |
---|---|
US (2) | US11610051B2 (en) |
Families Citing this family (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20220180051A1 (en) * | 2020-12-04 | 2022-06-09 | Patent Draftr, LLC | Text generation for patent applications using natural language modeling and programmable templating language |
CN116719514B (en) * | 2023-08-08 | 2023-10-20 | 安徽思高智能科技有限公司 | Automatic RPA code generation method and device based on BERT |
Family Cites Families (19)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US11468527B2 (en) * | 2000-02-29 | 2022-10-11 | PowerPatent Inc. | Patent drafting system |
US20070136321A1 (en) * | 2005-12-14 | 2007-06-14 | Harold Milton | System for preparing a patent application |
US20170098290A1 (en) * | 2005-12-14 | 2017-04-06 | Harold W. Milton, Jr. | System for preparing a patent application |
US20170097747A1 (en) * | 2005-12-14 | 2017-04-06 | Harold W. Milton, Jr. | System for preparing a patent application |
US20080178114A1 (en) * | 2007-01-18 | 2008-07-24 | Milton Harold W | Method for preparing a claim tree in the preparation of a patent application |
US8166386B2 (en) * | 2007-06-15 | 2012-04-24 | Chung-Yuh Chang | Method and system for producing patent specification |
US9098479B2 (en) * | 2008-02-15 | 2015-08-04 | Edyt Inc. | Methods and apparatus for improved navigation among controlled terms in one or more user documents |
US20130042170A1 (en) * | 2008-04-02 | 2013-02-14 | Mr. Harold W. Milton, JR. | Method of drafting a claim set |
US20130317994A1 (en) * | 2011-11-11 | 2013-11-28 | Bao Tran | Intellectual property generation system |
US20130198092A1 (en) * | 2012-02-01 | 2013-08-01 | Benedict R. Dugan | Computer-assisted patent application preparation |
US20170075877A1 (en) * | 2015-09-16 | 2017-03-16 | Marie-Therese LEPELTIER | Methods and systems of handling patent claims |
US20170344533A1 (en) * | 2016-05-31 | 2017-11-30 | Integral Search International Ltd. | Patent claims disassembling and analyzing method |
US10540443B2 (en) * | 2016-12-20 | 2020-01-21 | RELX Inc. | Systems and methods for determining references in patent claims |
US10747953B1 (en) * | 2017-07-05 | 2020-08-18 | Specifio, Inc. | Systems and methods for automatically creating a patent application based on a claim set such that the patent application follows a document plan inferred from an example document |
US10417341B2 (en) * | 2017-02-15 | 2019-09-17 | Specifio, Inc. | Systems and methods for using machine learning and rules-based algorithms to create a patent specification based on human-provided patent claims such that the patent specification is created without human intervention |
US10776566B2 (en) * | 2017-05-24 | 2020-09-15 | Nathan J. DeVries | System and method of document generation |
TWI709080B (en) * | 2017-06-14 | 2020-11-01 | 雲拓科技有限公司 | Claim structurally organizing device |
US20190057074A1 (en) * | 2017-08-16 | 2019-02-21 | Michael Carey | Patent automation system |
US20210012444A1 (en) * | 2019-07-09 | 2021-01-14 | Michael Carey | Automated patent preparation |
-
2020
- 2020-09-08 US US17/014,403 patent/US11610051B2/en active Active
-
2023
- 2023-03-08 US US18/119,115 patent/US20230222286A1/en active Pending
Also Published As
Publication number | Publication date |
---|---|
US20220075929A1 (en) | 2022-03-10 |
US11610051B2 (en) | 2023-03-21 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
Edhlund et al. | NVivo 12 essentials | |
US20230222286A1 (en) | Dynamically generating documents using natural language processing and dynamic user interface | |
KR101312867B1 (en) | Markup based extensibility for user interfaces | |
EP2691873B1 (en) | Techniques to create structured document templates using enhanced content controls | |
Edhlund et al. | Nvivo 11 essentials | |
KR102345005B1 (en) | Patent document creating device, method, computer program, computer-readable recording medium, server and system | |
US11526481B2 (en) | Incremental dynamic document index generation | |
US20140258832A1 (en) | Computer Implemented System and Method for Author Editing of XML Documents With Structured Element Protection | |
Haaf et al. | The dta “base format”: A tei subset for the compilation of a large reference corpus of printed text from multiple sources | |
Tacchetti | User's Guide for ELAN Linguistic Annotator | |
US20100269036A1 (en) | System and method for designing and generating online stationery | |
US20210012444A1 (en) | Automated patent preparation | |
Stahn et al. | Using TEI for textbook research | |
US20230289527A1 (en) | Convergence of document state and application state | |
US20220391597A1 (en) | Dynamically generating documents using natural language processing of apparatus claims | |
Edhlund et al. | NVivo 12 for Mac Essentials | |
KR20240055302A (en) | Document creating device, method, computer program, computer-readable recording medium, server and system having text auto-generating functionality using sentence template | |
KR20240055290A (en) | Document creating device, method, computer program, computer-readable recording medium, server and system having text auto-generating functionality using natural language generation model | |
Bothell | Microsoft® PowerPoint® | |
KR20240055313A (en) | Article creating device, method, computer program, computer-readable recording medium, server and system | |
KR20240055309A (en) | Paper creating device, method, computer program, computer-readable recording medium, server and system | |
KR20210013990A (en) | Apparatus, method, computer program, computer-readable storage device, server and system for drafting patent document | |
KR20210013989A (en) | Apparatus, method, computer program, computer-readable storage device, server and system for drafting patent document | |
Trager | International Text Layout & Typography: The Big And Future Picture | |
Murphy | Adobe InDesign CS4 Styles: How to Create Better, Faster Text and Layouts |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: ROWAN TELS CORP., WASHINGTON Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:BOOTH, SIMON;ISAACSON, TOM;AUSTIN, SHELTON;AND OTHERS;SIGNING DATES FROM 20220804 TO 20220815;REEL/FRAME:062923/0649 |
|
STPP | Information on status: patent application and granting procedure in general |
Free format text: DOCKETED NEW CASE - READY FOR EXAMINATION |