35 Eugene rules list file The Eugene (Bilitchenko 2011A, Bilitchenko 2011B) (a biological design specification computer language) rules list file is a text file that contains a list of design rules. j5 checks that these rules are satisfied prior to designing an assembly. Currently, j5 only enforces six types of Eugene rules (see below) and ignores all other rules and declarations; all lines that do not begin with "Rule" are ignored, as well as is everything following the commenting escape characters "//". Currently, composite rules (e.g. utilizing AND, OR, XOR operators) are not supported, but will be in the future. SLIC/Gibson/CPEC/SLiCE and Golden-gate assemblies designed with j5: If any of the specified design rules are broken, j5 terminates the assembly design and returns an error message. Combinatorial Golden-gate and Combinatorial SLIC/Gibson/CPEC/SLiCE assemblies designed with j5: j5 skips combinations of parts that break any of the specified design rules. Rule syntax: Rule rule_name([NOT] operand1 compositional_operator operand2); The [NOT] is an optional rule negation operator. The rule_name currently has no significant effect on the j5 design process, other than providing a name for the first rule in the list that was broken that resulted in j5 not pursuing the assembly. operand1 is a part name specified in the parts list file. compositional_operator is one of the following six operators: "AFTER", "BEFORE", "WITH", "THEN", "NEXTTO", or "MORETHAN". operand2 is either an integral copy number (if the compositional_operator is "MORETHAN") or a part name specified in the parts list file (if the compositional_operator is "AFTER", "BEFORE", "WITH", "THEN", or "NEXTTO"). AFTER operator: Rule rule_name([NOT] operand1 AFTER operand2); Rules utilizing the AFTER operator (or its [NOT] negated version) only apply to those devices that contain both part operand1 and part operand2. In the same linear construct, all instances of part operand1 must occur after (to the 3' of) all instances of part operand2. Note that this is equivalent to Rule rule_name(operand2 BEFORE operand1). This rule is ignored for circular constructs. Note that the AFTER operator does not take into consideration the directionalities (forward/reverse) of operand1 and operand2. BEFORE operator: Rule rule_name([NOT] operand1 BEFORE operand2); Rules utilizing the BEFORE operator (or its [NOT] negated version) only apply to those devices that contain both part operand1 and part operand2. In the same linear construct, all instances of part operand1 must occur before (to the 5' of) all instances of part operand2. Note that this is equivalent to Rule rule_name(operand2 AFTER operand1). This rule is currently ignored for circular constructs. Note that the BEFORE operator does not take into consideration the directionalities (forward/reverse) of operand1 and operand2. WITH operator: Rule rule_name([NOT] operand1 WITH operand2); Part operand1 and part operand2 must both occur in every construct. Note that this definition of the WITH operator is different from (and much more strict than) its original implementation in j5, which has been migrated to the THEN operator. For backwards compatibility, the NOTWITH operator is currently supported and equivalent to (NOT operand1 WITH operand2), although support for NOTWITH may be deprecated going forward. THEN operator: Rule rule_name([NOT] operand1 THEN operand2); Rules utilizing the THEN operator (or its [NOT] negated version) only apply to those devices that contain part operand1. Part operand1 only occurs if part operand2 also occurs in the same construct.  This is a useful rule to set if you are designing a combinatorial library where some of the parts require the presence of specific partner parts. Note that this rule is not symmetric, so operand1 THEN operand2 does not imply operand2 THEN operand1. Note that the THEN operator is equivalent to the original implementation of the WITH operator in j5. NEXTTO operator: Rule rule_name([NOT] operand1 NEXTTO operand2); Rules utilizing the NEXTTO operator (or its [NOT] negated version) only apply to those devices that contain part operand1. In the same construct, all instances of part operand1 must occur immediately before or immediately after an instance of part operand2. Note that this rule is not symmetric, so operand1 NEXTTO operand2 does not imply operand2 NEXTO operand1. MORETHAN operator: Rule rule_name([NOT] operand1 MORETHAN operand2); Part operand1 must occur more than operand2 times in each construct. This is a useful rule to set if you are designing a combinatorial library where you would like to have the order of parts shuffled (which requires placing the same part in multiple target part bins (see the target part list file documentation for more information), and you would like the copy number of each part above a certain threshold (i.e. you are not interested in assembling a plasmid without a gene present at least once). For backwards compatibility, the NOTMORETHAN operator is currently supported and equivalent to (NOT operand1 MORETHAN operand2), although support for NOTMORETHAN may be deprecated going forward. Here is an example Eugene rules list file (stylized for clarity): In this example, note that the seemingly redundant rules that contain the THEN operator need to be defined twice to ensure a symmetric dependency. Here is the actual example Eugene rules list file (eugenerules.eug):