dekker-phd-thesis/.vscode/ltex.hiddenFalsePositives.en-GB.txt

{"rule":"A_NNS","sentence":"^\\QFrom these cities it declares a set Paths that contains all possible paths between the different cities.\\E$"}
{"rule":"CD_NN","sentence":"^\\Q\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q visualizes the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q after placing a queen on the d3 square of an eight by eight chessboard.\\E$"}
{"rule":"COMMA_PARENTHESIS_WHITESPACE","sentence":"^\\Qgls-api name=Application Programming Interface (API), description= A particular set of rules and specifications that a software program can follow to access and make use of the services and resources provided by another particular software program that implements that API ,\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Q[\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] there has been no \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q yet; [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of the last \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q was \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q; [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] the last \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q found a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q; [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] the last \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q found and proved an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q in its \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q; [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] the last \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q did not find a solution, but did not exhaust its \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Q[\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] to find an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q to the Dummies that satisfies the Dummies, [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] to find an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q to the Dummies that satisfies the Dummies and minimises the value of the expression \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, or [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] to similarly maximise the value of the expression \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Q[\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] to find an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q to the Dummies that satisfies the Dummies, [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] to find an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q to the Dummies that satisfies the Dummies and minimizes the value of the expression \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, or [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] to similarly maximise the value of the expression \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Q[\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] to find an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q to the Dummies that satisfies the Dummies, [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] to find an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q to the Dummies that satisfies the Dummies and minimizes the value of the expression \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, or [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] to similarly maximize the value of the expression \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Q\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q shows an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model for the open shop problem.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QA \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q formed with an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model is then rewritten into a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QA modeller can repeatedly add Dummies and Dummies to an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and, crucially, the additions to the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q can be retracted in reverse order through the use of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QA single \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, however, is negatively impacted by the change; an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for this \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is no longer found.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QA specific problem is captured by an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, the combination of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q with a complete \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q (i.e. a mapping from all Dummies to a value).\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QA specific problem is captured by an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, the combination of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q with a complete \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q (i.e. a mapping from all Dummies to values).\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QA universal approach to the incremental usage of Dummies, and \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, is to allow incremental changes to an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QAdditionally, the process to encode an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q into a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q all happens “behind the scenes”.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QAlthough \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q does not typically prescribe a way to find the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, it provides the modeller with a way to give “hints” to the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QAn \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is continuously updated with new data, such as newly available jobs to be scheduled or customer requests to be processed.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QAn \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model describing the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QAn \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model describing the \\E(?:Dummy|Ina|Jimmy-)[0-9]+$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QAn \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model describing the job shop problem, abstracting from \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q declarations.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QAn \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model describing the social golfer problem\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QAn \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model of the open shop problem\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QAn \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model can be rewritten by Saville Row into a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for a variety of Dummies, including \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, and \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q Dummies.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QAs an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, our goal is to find a schedule that minimises the finishing time of the last task.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QAs an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, our goal is to find a schedule that minimizes the finishing time of the last task.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Qavar name=auxiliary variable, description= A \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q not explicitly defined in a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, but rather introduced in the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Qbyte-code name=byte-code, description=A set of instructions designed to be efficiently executed by an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QConsider for example the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q operator on integers, which \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q represents as an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q call.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Qcvar name=control variable, description= A special form of an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q where the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q represent the result of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q ,\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QDifferent from the rules described, when an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q access or \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q expression is found in \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q context, it often makes sense to evaluate its sub-expression in \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q context as well.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QFirst, an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model is transformed into \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QFor an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, we can then create a simple \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q program that calls \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QFor example, a problem parameter can influence the number of Dummies in an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q ,\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QFor example, the following function returns an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q that is constrained to be the multiplication of \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q by the relational multiplication \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QFor many \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q Dummies this model is close to a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, since integer Dummies and an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q are common.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QFor many problems the use of \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q Dummies offers a very successful method to find an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q to a problem.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QFor problems that are in the form of a linear program, there are proven methods to find an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QFor such a problem, an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q with the highest quality ,\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QFor the selection of an element from an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q language uses an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q access syntax similar to most other computer languages.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QFor this comparison compare the time that is required to (repeatedly) rewrite an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and the time required by the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QHow is an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q transformed into a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q?\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QHowever, when it finds a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, it does not yet know if this \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QIf any \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q was found, it is declared an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QIf the Dummies happen to take integer values in the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, then we have found an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q to the mixed integer program.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QIf the expression is a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, then the expression is rewritten to an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QIn the frontend, a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model is combined with its data into an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QIn this section we extend our architecture with an incremental constraint modelling interface that allows the modeller to change an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Qincremental-rewriting name=incremental-rewriting, description=The \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q that is continuously changed,\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QInitially, the search is in stage one: it tries to find an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for the first \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QInstead, an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is created and a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is added to ensure that it takes the correct value.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QInstead, an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q must be created to represent the value of the sub-expression, and it must be constrained to take the value corresponding to the expression.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Qint-sol name=intermediate solution, description=A \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q in an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q that is not (yet) proven to be the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q,\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QIt can read Dummies from a file or via an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QIt can rewrite (and propagate) an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q multiple times, remembering information about the earlier iteration(s).\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QIt is an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QIt is defined in terms of formalized decision, Dummies of different kinds (e.g. Boolean, integers, or even sets), and Dummies, Boolean logic formulas which are forced to hold in any \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, and, in case of an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QIt is, again, possible to rewrite a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q with an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q as a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q problem.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QLike an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, the aim of \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is to find the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q to the problem.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QMany Dummies also support the modelling of Dummies, where a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is augmented with an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Qmodel name=constraint model, description= A formalization of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q or an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Qnanozinc name=NanoZinc, description=A language to represent the current state of an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q during \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q,\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QOnce given a complete \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of the Dummies, the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q forms an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QOnce given a complete \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of the Dummies, the forms an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Qopt-sol name=optimal solution, description=A \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q in an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for which it has been proven that no other \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q exist of higher quality,\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Qrewriting name=rewriting, description= The process of transforming a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q into an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is referred to as rewriting.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QSimilarly, an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is said to be partial when it maps only a subset of the Dummies and Dummies in a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q,\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QSince we then cannot decide during \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q if an element is present in the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, the elements are made of an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q type.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Qsol name=solution, description=A complete \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q such that all Dummies are satisfied,\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model for this problem contains an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q lookup \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, where the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is larger than the index set of \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model is unable to use a set of partitions and instead uses an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of sets.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q problem is analogous to an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q process of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q into a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q then consists of two steps: the translation of \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model transformations into \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, implemented by a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q; and the iterative \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q using these \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q transformations to arrive at a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, implemented using an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q required to translate an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q into a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q was negligible.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe combination of a constraint model and \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Qs for its Dummies is said to be an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of the constraint model ,\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe context may depend on data that is only known at an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q level.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe following example constructs an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q that contains the tripled even values of an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe following set of equations describes this “knapsack” problem as an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q:\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe goal in the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q problem is then to find an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for Boolean Dummies that maximizes the cumulative weights of the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q clauses.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe goal of the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q process is to arrive at a flat \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q: an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q that only contains Dummies that consist of a singular calls, all arguments to calls are \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q literals or \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q identifiers, and using only Dummies and \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q types that are \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q to the target \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe instance is parsed into an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe mapping ensures that the context is correctly transformed when accessing the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q table for an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q call.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe other two types of goals are used when the model describes an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe problem asks if there is an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for the Dummies of a given Boolean formula, such that the formula is \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe selection of an element from an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is in many way similar to the choice in a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q expression.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe selection of an element from an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is in many ways similar to the choice in a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q expression.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe translation to \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q turns all expressions into function calls, replaces the special generator syntax in the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q with an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, and creates the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q function.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThen, an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model forms an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, and is subsequently rewritten into a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThen, we describe a technique to optimize the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q process for incremental changes to an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QTherefore, a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for one \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q looks very different from an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for a different \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThese are said to be the “root-context” Dummies of the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, i.e. those that have to hold globally and are not just used to define an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThey can be used as immutable data used to define Dummies or provide structural information about an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThrough the use of an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q on the solving goal item, the modeller can express an order in which they think values should be tried for an arrangement of Dummies in the model.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QTo create an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of the problem, the user provides the number of jobs and machines that are considered, and the duration of each task.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QTo detect the situation where the sub-expression are only used in an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q access or \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q expression we introduce the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q context.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QTo detect the situation where the sub-expression are only used in an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q access or \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q expression we introduce the context.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QTo solve an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, it can be rewritten into a mixed integer program.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QTo solve the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q problem, the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q has to find an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for the Dummies where at least one literal is true in every clause.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QTogether with a complete \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q forms an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QTogether, the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and a complete \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q form an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q that can be executed by the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QUsing a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q the function body explicitly creates an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, constrains it to take to correct value, and then returns it.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QUsing the same mechanism, \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q defines how an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is encoded for a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QWe compare our methods against a naive system that repeatedly programmatically changes an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, rewrites the full Dummies, and starts a new \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q instance.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QWe compare the time that is required to (repeatedly) rewrite an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and the time taken by the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QWe do this by treating the mixed integer program as a linear program and find an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QWhen given an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, one may wonder how to find a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_GB_SIMPLE_REPLACE","sentence":"^\\QA \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model describing a 0-1 knapsack problem\\E$"}
{"rule":"EN_GB_SIMPLE_REPLACE","sentence":"^\\QThe following set of equations describes this “knapsack” problem as an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q:\\E$"}
{"rule":"EN_GB_SIMPLE_REPLACE","sentence":"^\\QThe removal of unused identifiers is taken care of by garbage collection in the interpreter.\\E$"}
{"rule":"EN_GB_SIMPLE_REPLACE","sentence":"^\\QThis \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q expresses the knapsack relation, with the following arguments: \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q are the weights of the items, \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q are the profits for each item, the Dummies in \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q represent how many of each item are present in the knapsack, and \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, respectively, represent the weight and profit of the knapsack\\E$"}
{"rule":"EN_GB_SIMPLE_REPLACE","sentence":"^\\QThis has the additional benefit that the knapsack structure of the problem is then known.\\E$"}
{"rule":"ENGLISH_WORD_REPEAT_BEGINNING_RULE","sentence":"^\\QIt develops a technique to simplify Dummies by efficiently eliminating Dummies.\\E$"}
{"rule":"ENGLISH_WORD_REPEAT_BEGINNING_RULE","sentence":"^\\QIt presents a design and implementation of techniques to automatically introduce \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of Dummies in \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"ENGLISH_WORD_REPEAT_BEGINNING_RULE","sentence":"^\\QIt presents an analysis technique to reason about in what (\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q) form Dummies should be considered.\\E$"}
{"rule":"ENGLISH_WORD_REPEAT_BEGINNING_RULE","sentence":"^\\QIt proposes two novel methods to reduce the overhead of using Dummies in incremental techniques: \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of changing Dummies.\\E$"}
{"rule":"ENGLISH_WORD_REPEAT_BEGINNING_RULE","sentence":"^\\QPropagate the downward diagonal.\\E$"}
{"rule":"I_LOWERCASE","sentence":"^\\QSuppose the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q a has index set \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, but i takes the value seven.\\E$"}
{"rule":"IT_IS","sentence":"^\\QWe design and evaluate an architecture for Dummies that can accommodate its the modern uses.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Q(TupC) and (TupD) handle the context inference during the construction and destructuring of tuples respectively.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Q[label=ownpubs]assets/bibliography/dekker_publications.bib\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QA UnaryResource can be used by at most one activity at a time.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qaccap amaze city-position community-detection depot-placement freepizza groupsplitter kidney-exchange multi-knapsack nonogram nside rcpsp-wet road-cons roster stack-cuttingstock steelmillslab triangular\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QAlthough a standard definition for the “argCtx” function may cover the most common cases, it does not cover user-defined functions.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QAny annotated \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is handled by the (CallNative) rule rather than the (Call) rule, which means that it is simply added as a call into the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q code, without evaluating its body.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QAs an input to the inference process, a “argCtx” function is used to give the context of the arguments of a function, given the function itself and the context of the call.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QAs previously discussed, the contexts in which the identifier was used can be retrieved using the “collectCtx” function.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QCalls to the random number functions have been renamed by appending slv, so that they are not simply evaluates directly.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qdblp computer science bibliography, https://dblp.org\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QDefinition of the “argCtx” function for operators.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QDummies of this type are influenced by the ScheduleHorizon \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q defined on \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of the model.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QDummies that follow from the evaluation of the let expression, by the (ItemC) rule, are collected in the third component, \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q , of the evaluation arguments.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QDummies that follow from the evaluation of the let expression, by the (ItemC) rule, are collected in the third component, \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, of the evaluation arguments.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QFinally, the (Compr) and (Arr) rules show simple inference rules for \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q construction expressions.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QFinally, the (Decl) and (Item0) rules describe two base cases in the inference.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qgls-ampl name=AMPL: A Mathematical Programming Language, description=AMPL is a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q originally designed to serve as a common input language for mathematical Dummies (e.g. \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q).\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qgls-api name=Application Programming Interface (API), description= A particular set of rules and specifications that a software program can follow to access and make use of the services and resources provided by another particular software program that implements that API ,\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QIn this thesis we will follow the same naming standard as \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, where a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q has the same name as the original \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q with reif appended.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QInstead, we introduce the functions “pushCtx” and “collectCtx”.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QOn \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q a UnaryResource is declared for every machine.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QSolver Unsatisfiable Optimal Solution Satisfied Unk.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QThe (Acess) rule evaluates the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q expression \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and the index \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QThe (CallBuiltin) rule applies to “built-in” functions that can be evaluated directly, such as arithmetic and Boolean operations on fixed values.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QThe (CallNative) rule applies to calls to \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q functions, that describe relations, that have been marked as Dummies \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q to the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QThe (Const) rule simply returns the constant.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QThe (Ident) rule looks up a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q in the environment and returns the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q itself to be used in any Dummies.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QThe (ItemT) rule handles introduction of new Dummies by adding them to the context.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QThe (ItemTE) rule handles introduction of new Dummies with a defining equation by evaluating them in the current context and substituting the name of the new \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q by the result of evaluation in the entire scope of the variable.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QThe (ListG) rule evaluates the iteration set \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q to get its value \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, which must be fixed.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QThe (WhereF) rule evaluates the guard and when false returns an empty list.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QThe (WhereT) rule evaluates the guard of a where \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and if true returns the resulting expression in a list.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QThe first rule, (Ident), is unique in the sense that the context of an identifier does not directly affect other expressions.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QThe machine operates using an Intel Xeon 8260 \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, which has 24 non-hyperthreaded cores, and has access to 268.55 GB of \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QThe makespan \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q represents the time spanned by all tasks.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QThe rules (ItemTupC) and (ItemTupD) are for the construction and deconstruction of tuple objects.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QWe ran experiments for three models from the MiniZinc Challenge \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q (gbac, steelmillslab, and rcpsp-wet).\\E$"}
{"rule":"PREPOSITION_VERB","sentence":"^\\QIt first states the resource objects and then merely has to use the requires keyword to force tasks on the same machine to be mutually exclusive.\\E$"}
{"rule":"PREPOSITION_VERB","sentence":"^\\QThe \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q uses the requires operator to bind an activity to a resource.\\E$"}
{"rule":"THE_SUPERLATIVE","sentence":"^\\QThe goal of the problem is to find a shortest path that visits all the cities exactly once and returns to its origin.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qa \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q that translates \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q models to a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, and a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q that produces a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qafter which b2 can be removed from the model.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qaggregation name=constraint aggregation, description=A technique that combines many smaller Dummies into a one or, by exception, a few larger Dummies,\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qallow us to express important aspects of the meta-optimization algorithm in a more convenient way, and enable a simple \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q scheme that requires no additional communication with and only small, simple extensions of the target \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qcontinuously updating \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q Dummies, \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for known Dummies, specialised Dummies when variables get \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, common sub-expression elimination, and removing Dummies and Dummies that are no longer required.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qcontinuously updating \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q Dummies, \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for known Dummies, specialized Dummies when variables get \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, common sub-expression elimination, and removing Dummies and Dummies that are no longer required.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qgiven \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q find \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Qtrue \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q,false \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Qsubject to \\E(?:Dummy|Ina|Jimmy-)[0-9]+$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qgiven \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q maximise \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q subject to \\E(?:Dummy|Ina|Jimmy-)[0-9]+$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qgiven \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q maximize \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q subject to \\E(?:Dummy|Ina|Jimmy-)[0-9]+$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qis a open source \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qis a proprietary \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qis an open source \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qis an open source \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q solver \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qjoin A table showing the result of joining two contexts.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qjoin The join context operation extended with .\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qjoin The join context operation extended with \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qmaximize \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q subject to \\E(?:Dummy|Ina|Jimmy-)[0-9]+$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qsupport incremental usage of the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qthe addition or removal of new Dummies or Dummies, changes made to the Dummies of Dummies, additions to the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q table, and substitutions made due to equality \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qthe disjunction itself is in \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q context, \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q are in \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q context, and the rest are in \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q context.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qthe variable \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q variables \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q multiplication Dummies.\\E$"}
{"rule":"WHITESPACE_RULE","sentence":"^\\Q[main]\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QOr, when this is not possible, prove that such an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q cannot exist.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QIf such an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q does not exist, then it reports that the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qcontinuously updating \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q Dummies, \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for known Dummies, specialized Dummies when variables get \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, common sub-expression elimination, and removing Dummies and Dummies that are not required any longer.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QA single \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, however, is negatively impacted by the change; for this \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q it cannot find an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q any longer.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QAlthough it does not prove the unsatisfiability of one instance any longer and slightly increases the number of solver errors, an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is found for five more instances.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qallow us to express important aspects of the meta-optimization algorithm in a more convenient way, and enable a simple \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q scheme that does not require any additional communication with and only small, simple extensions of the target \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Q[\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q has not been restarted yet; [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of the last \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q was \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q; [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] the last \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q found a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q; [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] the last \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q found and proved an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q in its \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q; [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] the last \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q did not find a solution, but did not exhaust its \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qgls-ast name=Abstract Syntax Tree, description=A tree structure representing the syntactic structure of a piece of computer language.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qavar name=auxiliary variable, description= A \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q not explicitly defined in a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, but rather introduced in the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qaggregation name=constraint aggregation, description=A technique that combines many smaller Dummies into a one or, by exception, a few larger Dummies.,\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qgls-api name=Application Programming Interface (API), description= A particular set of rules and specifications that a software program can follow to access and make use of the services and resources provided by another particular software program that implements that API.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qassignment name=assignment, description= A mapping from Dummies or Dummies to values.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qbacktrack name=backtrack, description=A \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is said to backtrack when it revisits a search decision (e.g. a value assumed during search).\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qbnb name=branch and bound, description=A search method to find a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qbooleanization name=Booleanization, description=The process of \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q to a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q or \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q problem.,\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qgls-cbc name=COIN-OR Branch-and-Cut, description=A well-known open source \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.,\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qgls-cbls name=constraint-based local search, description=A form of local search using \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q violations as its \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qcml name=constraint modelling language, description= A computer language used to define Dummies.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qcplex name=CPLEX, description=A well-known proprietary \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q developed by IBM \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.,\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qgls-chr name=constraint handling rules, description=A non-deterministic declarative rule based programming language to maintain or improve a constraint store.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qgls-cp name=constraint programming, description= A general technique to find Dummies to Dummies of Dummies.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qgls-cse name=common sub-expression elimination, description=A technique stemming from programming language to avoid duplicate computation.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qgls-clp name=constraint logic programming, description=An extension of logic programming to include the concepts of \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qgls-cse name=common sub-expression elimination, description=A technique stemming from programming language to avoid duplicate computation.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qcvar name=control variable, description= A special form of an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q where the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q represent the result of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Qcvar name=control variable, description= A special form of an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q where the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q represent the result of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qcompiler name=compiler, description= A computer program that transforms a program in a computer language, referred to as the “source”, into a different language (or instruction set), the “target”.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qcompiling name=compiling, description=see \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.,\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qdec-prb name=decision problem, description= A problem which can be defined as making a set of decisions under a certain set of rules.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qdecomp name=decomposition, description= A formulation of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q in terms of other Dummies in order to reach \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q Dummies.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qdel-rew name=delayed rewriting, description=A technique using during \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qeqsat name=equisatisfiable, description=Two Dummies are equisatisfiable when a bijective function can be defined to map the Dummies of one \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q onto the Dummies of the other.,\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qfixpoint name=fix-point, description=A set of algorithms is set to be at fix-point when none of the algorithms can further change the overall state.,\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qflatzinc name=FlatZinc, description=A subset of \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q chosen to represent Dummies.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qgecode name=Gecode, description=A well-known open source \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.,\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qgurobi name=Gurobi, description=A well-known proprietary \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.,\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qhalf-reif name=half-reification, description=A half-reification is a variation of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q where for a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q it enforces that a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q b represents the logical implication of the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q: \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.,\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Qincremental-rewriting name=incremental-rewriting, description=The \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q that is continuously changed.,\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qint-sol name=intermediate solution, description=A \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q in an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q that is not (yet) proven to be the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.,\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Qint-sol name=intermediate solution, description=A \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q in an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q that is not (yet) proven to be the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.,\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qkleene-sem name=Kleene semantic, description= A semantic model for treating undefined behaviour in Dummies.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qlinearization name=linearization, description=The process of \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q to a mixed integer program.,\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qgls-lcg name=lazy clause generation, description=Types of \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q that extend \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q solving with \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q capabilities.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qgls-lns name=large neighbourhood search, description= A \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q strategy that repeatedly reduces the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q by applying different Dummies often based on a previous \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qmeta-optimization name=meta-optimization, description= Methods used to improve on the general techniques used by Dummies to look for Dummies, such as \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qmicrozinc name=MicroZinc, description=A subset of \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q used to describe transformations performed during \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qminisearch name=MiniSearch, description= \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q introduced MiniSearch as a way to describe \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q methods from within a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qmodel name=constraint model, description= A formalization of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q or an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe combination of a constraint model and \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Qs for its Dummies is said to be an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of the constraint model.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qminizinc name=MiniZinc, description= The primary \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q studied in this thesis.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qnormal-form name=normal form, description=A \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q has reached its normal form when none of the rewriting rules can be applied.,\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qgls-mip name=mixed integer programming, description= A solving technique tries to find the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q containing a mixture of Integer and floating point Dummies subject to Dummies in the form of linear (in-)equations.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qnative name=native, description=Dummies and \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q types are said to be native to a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q when they can be directly used as input for the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.,\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qnanozinc name=NanoZinc, description=A language to represent the current state of an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q during \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.,\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Qnanozinc name=NanoZinc, description=A language to represent the current state of an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q during \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.,\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qopenwbo name=OpenWBO, description=A well-known \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.,\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qgls-opl name=OPL: The optimization modelling language, description=A \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q aimed at combining the powers of mathematical programming and \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qopt-prb name=optimization problem, description= A decision problem with an additional \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QFor such a problem, an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q with the highest quality.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qoptional name=optional, description=When it is not certain if a value, either \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q or \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, will exist in a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, its type is marked as optional (\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q).\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Qopt-sol name=optimal solution, description=A \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q in an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for which it has been proven that other \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of higher quality do not exist.,\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qrbmo name=restart based meta-optimization, description= A technique to apply \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q methods within the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qgls-sat name=boolean satisfiability, description= A problem class that tries to find a valid \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for a set of Boolean Dummies subject to a logical formula.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qsearch-decision name=search decision, description= Dummies generally make search decisions when they can not directly infer a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qsearch-heuristic name=search heuristic, description= A specification of how to make Dummies in an effort to find Dummies in a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qsearch-space name=search space, description= The set of possible Dummies in the current state of the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qsol name=solution, description=A complete \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q such that all Dummies are satisfied.,\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Qsol name=solution, description=A complete \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q such that all Dummies are satisfied.,\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qstrict-sem name=strict semantic, description= A semantic model for treating undefined behaviour in Dummies.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qparameter name=parameter, description= Parameter variables, shortened to parameters, are variables in the sense of programming languages, and are not to be confused with Dummies.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qparameter-assignment name=parameter assignment, description=see \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q,\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QSimilarly, an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is said to be partial when it maps only a subset of the Dummies and Dummies in a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.,\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QFor example, a problem parameter can influence the number of Dummies in an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qprb-par name=problem parameter, description= Problem parameters are part of the external input for a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qpropagation name=constraint propagation, description=The removal of values from Dummies of Dummies that violate a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qreif name=reification, description=A reification is a special form of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q where, instead of the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q being enforced in the Dummies, it enforces that a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q b represents whether the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q holds or not: \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.,\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qrel-sem name=relational semantic, description= A semantic model for treating undefined behaviour in Dummies.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qrewriting name=rewriting, description= The process of transforming a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q into an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is referred to as rewriting.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qsatisfied name=satisfied, description= A \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is said to be satisfied when its logical expression is proven to hold.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qslv-mod name=solver model, description= A \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q where all Dummies and \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q types are \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for the targeted \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qscip name=SCIP, description=A well-known open source \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.,\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qtrs name=term rewriting system, description=A computational model that expresses computation through the application of rewriting rules.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qunsat name=unsatisfiable, description=An \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, or a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, is unsatisfiable when a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q cannot exist.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qvariable-assignment name=variable assignment, description=see \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.,\\E$"}
{"rule":"IE_NO_COMMA","sentence":"^\\QThe second component of our \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q definition is the “restarting strategy”, defining how much effort the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q should put into each \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q (i.e. \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q), and when to stop the overall search.\\E$"}
{"rule":"ACTUAL","sentence":"^\\QHowever, since functions returning Boolean Dummies are equivalent to a predicate, it is actually the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q that gets used.\\E$"}
{"rule":"THREE_NN","sentence":"^\\QOur first model is based on a problem of planning cancer radiation therapy treatment using multi-leaf collimators \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"METRIC_UNITS_EN_IMPERIAL","sentence":"^\\Q=15pt =1em\\E$"}
{"rule":"ACTUAL","sentence":"^\\QIt could be said that a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q actually describes the answer to the problem.\\E$"}
{"rule":"MEANING","sentence":"^\\QThe problem classes can be restrictive: the input to the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, can only contain \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q Dummies and Dummies, meaning those that are directly supported by the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QAn \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model of the open shop problem.\\E$"}
{"rule":"MEANING","sentence":"^\\QThe \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model provides a clear definition of the problem class, but it can be argued that its meaning is hard to decipher.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qgls-ampl name=AMPL: A Mathematical Programming Language, description=AMPL is a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q originally designed to serve as a common input language for mathematical Dummies (e.g., \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q).\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qbacktrack name=backtrack, description=A \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is said to backtrack when it revisits a search decision (e.g., a value assumed during search).\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qboundsr-con name=bounds(\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q) consistent, description=A \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is bounds(\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q) consistent when it tightens the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q such that they could satisfy the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q if it where using rational arithmetic.,\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qboundsz-con name=bounds(\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q) consistent, description=A \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is bounds(\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q) consistent when it tightens the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q such that they can satisfy the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.,\\E$"}
{"rule":"MAP","sentence":"^\\Qeqsat name=equisatisfiable, description=Two Dummies are equisatisfiable when a bijective function can be defined to map the Dummies of one \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q onto the Dummies of the other.,\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qkleene-sem name=Kleene semantics, description= A semantic model for treating undefined behaviour in Dummies.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QIt is defined in terms of formalized decision, Dummies of different kinds (e.g., Boolean, integers, or even sets), and Dummies, Boolean logic formulas which are forced to hold in any \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, and, in case of an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qstrict-sem name=strict semantics, description= A semantic model for treating undefined behaviour in Dummies.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qrel-sem name=relational semantics, description= A semantic model for treating undefined behaviour in Dummies.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QA specific problem is captured by an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, the combination of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q with a complete \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q (i.e., a mapping from all Dummies to a value).\\E$"}
{"rule":"MAP","sentence":"^\\QThe \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q functions are Dummies used to map toys, \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, to a numeric value describing the amount of enjoyment and space required respectively.\\E$"}
{"rule":"MAP","sentence":"^\\QDummies declare the Dummies \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, that map toys to integer values.\\E$"}
{"rule":"EN_GB_SIMPLE_REPLACE","sentence":"^\\QA \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model describing a 0-1 knapsack problem.\\E$"}
{"rule":"MEANING","sentence":"^\\QThe term “variable” has two overlapping, and slightly confusing meanings.\\E$"}
{"rule":"TOO_LONG_SENTENCE","sentence":"^\\Q[\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] The \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q expression which assigns the values of collections to identifiers, [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] an optional filtering condition, which has to evaluate to true for the iteration to be included in the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] and the expression that is evaluated for each iteration when the filtering condition succeeds.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QFor many problems the use of \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q Dummies, such as \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and RC2 \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, offers a very successful method to find an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q to a problem.\\E$"}
{"rule":"MEANING","sentence":"^\\QThis makes it harder in \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q to write the correct \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and its meaning is less clear.\\E$"}
{"rule":"TOO_LONG_SENTENCE","sentence":"^\\Q[\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] The \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q expression which assigns the values of collections to identifiers, [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] an optional filtering condition, which decided whether the iteration to be included in the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] and the expression that is evaluated for each iteration when the filtering condition succeeds.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QTo solve the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q problem, the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q has to find an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for the Dummies where at least one literal takes the value \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q in every clause.\\E$"}
{"rule":"MEANING","sentence":"^\\QThis means that, depending on the target \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q will not be able to understand the meaning of all Dummies.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThese are said to be the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q-context Dummies of the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, i.e., those that have to hold globally and are not just used to define an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QThe (WhereT) rule evaluates the guard of a where \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and if \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q returns the resulting expression in a list.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QThe (WhereF) rule evaluates the guard and when \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q returns an empty list.\\E$"}
{"rule":"ACTUAL","sentence":"^\\QActually make source available\\E$"}
{"rule":"MEANING","sentence":"^\\QIts meaning is now completely captured by the Dummies of the Dummies.\\E$"}
{"rule":"TOO_LONG_SENTENCE","sentence":"^\\QTo simplify presentation, we assume that all rules that introduce new identifiers into the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q program do so in a way that ensures those identifiers are fresh (i.e., not used in the rest of the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q program), by suitable alpha renaming.\\E$"}
{"rule":"THREE_NN","sentence":"^\\QWe also present our rules using a call by name evaluation strategy, i.e., the arguments to function calls are substituted into function body.\\E$"}
{"rule":"THREE_NN","sentence":"^\\QAlthough pure \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q behaves the same under any call evaluation strategy, in implementation a call by value strategy might provide more predictable behaviour with debugging functions in the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q language, such as \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"THREE_NN","sentence":"^\\QIn \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q we introduce our new context analysis algorithm: a way to determine where \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q can be used in \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, and by extension \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QDefinition of the “argCtx” function for \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q operators.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qjoin A table showing the result of joining two contexts, considering the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q context.\\E$"}
{"rule":"PUNCTUATION_PARAGRAPH_END","sentence":"^\\QThe case shown in the example can be generalized to\\E$"}
{"rule":"PUNCTUATION_PARAGRAPH_END","sentence":"^\\QThe \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q reports\\E$"}
{"rule":"TOO_LONG_SENTENCE","sentence":"^\\Q[Unsatisfiable] when it proves the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q does not have a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, [Optimal solution] when it has found a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and has proven the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q to be optimal, [Satisfied] when it has found a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for the problem, [Unknown] when it does not find a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is found within the time limit, and [Error] when the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q program crashes.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QFor this comparison, we analyse the time that is required to (repeatedly) rewrite an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q and the time required by the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q by different methods.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qaccap amaze code-generator fox-geese-corn groupsplitter hrc kidney-exchange liner-sf-repositioning lot-sizing median-string multi-knapsack nside ptv rcpsp-wet-diverse rotating-workforce stack-cuttingstock steelmillslab stochastic-vrp triangular zephyrus\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qbnn-planner cabletreewiring code-generator collaborative-construction gbac hoist-benchmark is lot-sizing minimal-decision-sets p1f-pjs pentominoes pillars-and-planks racp radiation sdn-change skill-allocation soccer-computational stable-goods towerchallenge whirlpool\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qgbac radiation steelmillslab rcpsp-wet\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Qincremental-rewriting name=incremental rewriting, description=The \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q that is continuously changed.,\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QIt finds an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of a linear program in worst-case exponential time.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QAn \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is indicated by the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q followed by an identifier or function call.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QThe (CallBuiltin) rule applies to “built-in” functions that can be evaluated directly, such as arithmetic and Boolean operations on \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q values.\\E$"}
{"rule":"TOO_LONG_SENTENCE","sentence":"^\\QTherefore, we extended we the partial evaluation using well-known techniques to improve the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q: \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is used throughout the rewriting process (possibly to \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q), calls can be delayed until more information is known, \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is used both when evaluating calls and during the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q to \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q transformation, and Dummies can be aggregated when beneficial for the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QThe (ListG) rule evaluates the iteration set \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q to get its value \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, which must be \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QIn previous chapters we explored \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q as a definitive linear process: an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is translated into a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, for which a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q produces Dummies.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QAll of these examples have in common that an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is solved, new Dummies are added, the resulting \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is solved again, and the Dummies may be removed again.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Q[\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q has not been restarted yet; [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of the last \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q was \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q; [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] the last \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q found a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q; [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] the last \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q found and proved an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q in its \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q; [\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q] the last \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q did not find a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, but did not exhaust its \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe path of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is designed to give a unique identifier to a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q when an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is rewritten multiple times.\\E$"}
{"rule":"THREE_NN","sentence":"^\\QA predicate providing the round-robin selection strategy.\\E$"}
{"rule":"WANT","sentence":"^\\QHowever, when \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is used to describe a complete search, we still want to stop the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q when the process is known to be finished.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QInitially, the stage is set to one: it tries to find an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for the first \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QCalls to the random number functions have been renamed by appending slv, so that they are not simply evaluated directly.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QWe compare our methods against a naive system that repeatedly programmatically changes an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, rewrites the full \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, and starts a new \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q process each time.\\E$"}
{"rule":"TOO_LONG_SENTENCE","sentence":"^\\QThe next and final chapter presents the conclusions of this thesis, which reiterate the discoveries and contributions of this research to theory and practice, comment on the scope and limitations of the presented architecture, and presents further avenues for research in this area.\\E$"}
{"rule":"PUNCTUATION_PARAGRAPH_END","sentence":"^\\QThe source code for this version can be found here: \\E(?:Dummy|Ina|Jimmy-)[0-9]+$"}
{"rule":"TOO_LONG_SENTENCE","sentence":"^\\QThis thesis is an original work of my research and contains no material which has been accepted for the award of any other degree or diploma at any university or equivalent institution and that, to the best of my knowledge and belief, this thesis contains no material previously published or written by another person, except where due reference is made in the text of the thesis.\\E$"}
{"rule":"PUNCTUATION_PARAGRAPH_END","sentence":"^\\QTitle State\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qsicstus name=SICStus Prolog, description=A well-known implementation of the Prolog \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q language and constraint modelling environment \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.,\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qslv-mod name=solver model, description= A \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q where all Dummies and \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q types are \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for the targeted \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QAn \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q model can be rewritten by Savile Row into a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for a variety of Dummies, including \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, and \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q Dummies.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QEach algorithm solves an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, adds new Dummies, the resulting \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is solved again, and the Dummies may be removed again.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qgls-cnf name=conjunctive normal form, description=The formulation of a Boolean formula as a conjunction of disjunctions of Boolean literals.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qcomet name=COMET, description=A \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q with advanced \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q functionality \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\Qgls-maxsat name=Maximum Satisfiability, description=An extension of the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q problem class into an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Qgls-maxsat name=Maximum Satisfiability, description=An extension of the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q problem class into an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QAn \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of a problem \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q maximizes the weights of the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q clauses.,\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qgls-sat name=Boolean satisfiability, description= A problem class that tries to find a valid \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q for a set of Boolean Dummies subject to a logical formula.\\E$"}
{"rule":"UPPERCASE_SENTENCE_START","sentence":"^\\Qsearch-comb name=search combinators, description=A language extension proposed for Dummies that allows the modeller to describe search conducted by the \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QTo create an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of the problem, the modeller provides the number of jobs and machines that are considered, and the duration of each task.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QMoreover, the process to encode an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q into a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q all happens “behind the scenes”.\\E$"}
{"rule":"MORFOLOGIK_RULE_EN_GB","sentence":"^\\QThe definition of nonoverlap requires that either task A precedes task B, or vice versa.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\Q\\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q also determines how an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is encoded for a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q through function definitions.\\E$"}
{"rule":"WILL_ALLOW","sentence":"^\\QCrucially, this architecture will allow us to:\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QThe goal of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is to find a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q: a complete \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q that satisfies the Dummies, or, when this is not possible, prove that such an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q cannot exist.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QIn previous chapters, we explored \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q as a definitive linear process, where an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q is translated into a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q, for which a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q produces Dummies.\\E$"}
{"rule":"EN_A_VS_AN","sentence":"^\\QWe allow a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q algorithm, implemented in \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q or a scripting language, to make incremental changes to an \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q of a \\E(?:Dummy|Ina|Jimmy-)[0-9]+\\Q.\\E$"}
{"rule":"TOO_LONG_SENTENCE","sentence":"^\\QThe next and final chapter presents the conclusions of this thesis, which reiterate the discoveries and contributions of this research to theory and practice, comment on the scope and limitations of the presented architecture, and present further avenues for research in this area.\\E$"}