A GENERAL-PURPOSE CRN-TO-DSD COMPILER WITH FORMAL VERIFICATION, - PowerPoint PPT Presentation

A GENERAL-PURPOSE CRN-TO-DSD COMPILER WITH FORMAL VERIFICATION, OPTIMIZATION, AND SIMULATION CAPABILITIES Stefan Badelt , Seung Woo Shin, Robert F. Johnson, Qing Dong, Chris Thachuk, and Erik Winfree DNA and Natural Algorithms (DNA) Group, Caltech Austin, Sept, 26 , 2017 th DNA Computing & Molecular Programming Conference 23 rd 1

OUTLINE domain-level strand displacement (DSD) systems formal chemical reaction networks (CRNs) importance of a CRN-to-DSD compiler translate formal CRNs into DSD systems verify the correctness of a DSD system examples of DSD system analysis 2

DNA STRAND DISPLACEMENT = Adenine = long domain = Thymine = short domain = Cytosine = Guanine = 5' end = Phosphate = 3' end backbone DNA DNA b b a* a* b* b* 3

DOMAIN-LEVEL STRAND DISPLACEMENT long (branch-migration) domain: binds irreversibly short (toehold) domain: binds reversibly A B x x F2 F1 t b a + + t a x t x t b t* x* t* t* x* t* 3-way branch migration unbind bind x x x a x a t b t t t b t* x* t* t* x* t* a t x x t b i3 i1 t* x* t* i2 4

DOMAIN-LEVEL STRAND DISPLACEMENT long (branch-migration) domain: binds irreversibly detailed network short (toehold) domain: binds reversibly condensed network A B x x F2 F1 t b a + + t a x t x t b t* x* t* t* x* t* 3-way branch migration bind unbind x x x a x a t b t t t b t* x* t* t* x* t* a t x x t b i2 i1 t* x* t* 5

DOMAIN-LEVEL STRAND DISPLACEMENT long (branch-migration) domain: binds irreversibly detailed network short (toehold) domain: binds reversibly condensed network A B x x F2 F1 t b a + + t a x t x t b t* x* t* t* x* t* 3-way branch migration unbind bind x x x a x a t b t t t b t* x* t* t* x* t* a t x x t b i2 i1 t* x* t* 6

DOMAIN-LEVEL STRAND DISPLACEMENT long (branch-migration) domain: binds irreversibly short (toehold) domain: binds reversibly A B x x F2 F1 t b a + + t a x t x t b t* x* t* t* x* t* 3-way branch migration unbind bind DSD sytem specification formal CRN x x x a x a t b t t t b formal species: {A, B} signal species (low concentation): {A, B} t* x* t* t* x* t* a t x x t b fuel species (high concentration): {F1, F2} i3 i1 t* x* t* i2 7

FROM CRN TO DSD SYSTEMS Soloveichik Lakin Cardelli (2011) Qian et al. (2011) et al. (2010) et al. (2012) Chen et al. (2012), Cardelli (2013), Srinivas (2015), Lakin et al. (2016), ... Images drawn using VisualDSD, Lakin et al. (2012) 8

TRADITIONAL WORKFLOW choose translation scheme design modules for every sequence design reaction and experimental testing traditional workflow try to find errors VisualDSD enumeration & simulation 9

A CRN-TO-DSD COMPILER try all translation schemes sequence design experimental verify testing correctness (for all inputs) automated workflow choose optimal scheme 10

THE NUSKELL COMPILER PROJECT Badelt et al. (2017) - compiler framework and CRN-to-DSD translation Grun et al. (2014) - reaction enumeration Shin et al. (2014) - CRN pathway decomposition equivalence Johnson et al. (2016) - CRN bisimulation equivalence 11

THE NUSKELL COMPILER PROJECT A B x x F1 F2 t a t + + b x a t x t b t* x* t* t* x* t* unbind bind a x t A x F2 3-way branch migration x x a t t* x* t* a x t b a t x t t b x t b t* x* t* t* x* t* x a t x x t b F1 i1 i3 t B b t* x* t* t* x* t* i2 Badelt et al. (2017) - compiler framework and CRN-to-DSD translation Grun et al. (2014) - reaction enumeration Shin et al. (2014) - CRN pathway decomposition equivalence Johnson et al. (2016) - CRN bisimulation equivalence 12

TRANSLATION SCHEMES # Translate formal reactions with two reactants and two products. # Lakin et. al (2012) "Abstractions for DNA circuit design." [Figure 5] # Define a global short toehold domain global toehold = short(); # Define domains and structure of signal species class formal(s) = "? t f" | ". . ." where { t = toehold; f = long() }; # Define fuel complexes for bimolecular reactions class binary_fuels(r, p) = [ "a t i + b t k + ch t c + dh t d + t* dh* t* ch* t* b* t* a* t*" | "( ( . + ( ( . + ( ( . + ( ( . + ) ) ) ) ) ) ) ) . ", "a t i" | " . . . ", "t ch t dh t" | ". . . . ." ] where { a = r[0].f; b = r[1].f; c = p[0].f; ch = long(); d = p[1].f; dh = long(); i = long(); k = long(); t = toehold }; # Module *rxn* applies the fuel production to every bimolecular reaction module rxn(r) = sum(map(infty, fuels)) where fuels = if len(r.reactants) != 2 or len(r.products) != 2 then abort('Reaction type not implemented') else binary_fuels(r.reactants, r.products); # Module *main* applies *rxn* to the crn module main(crn) = sum(map(rxn, crn)) where crn = irrev_reactions(crn); simplified variant of translation scheme: lakin2012.ts 13

TRANSLATION SCHEMES # Translate formal reactions with two reactants and two products. # Lakin et. al (2012) "Abstractions for DNA circuit design." [Figure 5] # Define a global short toehold domain global toehold = short(); formal(s) = # Define domains and structure of signal species class formal(s) = "? t f" | ". . ." where { t = toehold; f = long() }; ? t f # Define fuel complexes for bimolecular reactions class binary_fuels(r, p) = [ "a t i + b t k + ch t c + dh t d + t* dh* t* ch* t* b* t* a* t*" | "( ( . + ( ( . + ( ( . + ( ( . + ) ) ) ) ) ) ) ) . ", "a t i" | " . . . ", "t ch t dh t" | ". . . . ." ] where { a = r[0].f; b = r[1].f; c = p[0].f; ch = long(); d = p[1].f; dh = long(); i = long(); k = long(); t = toehold }; # Module *rxn* applies the fuel production to every bimolecular reaction c i k d module rxn(r) = sum(map(infty, fuels)) where fuels = a t b t ch t dh t if len(r.reactants) != 2 or len(r.products) != 2 then abort('Reaction type not implemented') else t* a* t* b* t* ch* t* dh* t* binary_fuels(r.reactants, r.products); a ch dh # Module *main* applies *rxn* to the crn t i t t t module main(crn) = sum(map(rxn, crn)) where crn = irrev_reactions(crn); simplified variant of translation scheme: lakin2012.ts 14

TRANSLATION SCHEMES # Translate formal reactions with two reactants and two products. # Lakin et. al (2012) "Abstractions for DNA circuit design." [Figure 5] # Define a global short toehold domain t ? d1 global toehold = short(); formal(s) = # Define domains and structure of signal species t ? d2 class formal(s) = "? t f" | ". . ." where { t = toehold; f = long() }; ? t f # Define fuel complexes for bimolecular reactions class binary_fuels(r, p) = [ "a t i + b t k + ch t c + dh t d + t* dh* t* ch* t* b* t* a* t*" | "( ( . + ( ( . + ( ( . + ( ( . + ) ) ) ) ) ) ) ) . ", "a t i" | " . . . ", "t ch t dh t" | ". . . . ." ] where { a = r[0].f; b = r[1].f; c = p[0].f; ch = long(); d = p[1].f; dh = long(); i = long(); k = long(); t = toehold }; # Module *rxn* applies the fuel production to every bimolecular reaction c i k d module rxn(r) = sum(map(infty, fuels)) where fuels = a t b t ch t dh t if len(r.reactants) != 2 or len(r.products) != 2 then abort('Reaction type not implemented') else t* a* t* b* t* ch* t* dh* t* binary_fuels(r.reactants, r.products); a ch dh # Module *main* applies *rxn* to the crn t i t t t module main(crn) = sum(map(rxn, crn)) where crn = irrev_reactions(crn); simplified variant of translation scheme: lakin2012.ts 15

TRANSLATION SCHEMES # Translate formal reactions with two reactants and two products. # Lakin et. al (2012) "Abstractions for DNA circuit design." [Figure 5] # Define a global short toehold domain t ? d1 global toehold = short(); formal(s) = # Define domains and structure of signal species t ? d2 class formal(s) = "? t f" | ". . ." where { t = toehold; f = long() }; ? t f # Define fuel complexes for bimolecular reactions class binary_fuels(r, p) = [ "a t i + b t k + ch t c + dh t d + t* dh* t* ch* t* b* t* a* t*" | "( ( . + ( ( . + ( ( . + ( ( . + ) ) ) ) ) ) ) ) . ", "a t i" | " . . . ", "t ch t dh t" | ". . . . ." ] where { a = r[0].f; b = r[1].f; c = p[0].f; ch = long(); d = p[1].f; dh = long(); i = long(); k = long(); t = toehold }; # Module *rxn* applies the fuel production to every bimolecular reaction d3 d4 d2 d2 c i k d module rxn(r) = sum(map(infty, fuels)) d1 d2 d5 d6 t t t t where fuels = a t b t ch t dh t if len(r.reactants) != 2 or len(r.products) != 2 then abort('Reaction type not implemented') else t* d1* t* d2* t* d5* t* d6* t* t* a* t* b* t* ch* t* dh* t* binary_fuels(r.reactants, r.products); d1 t d3 t d5 t d6 t a ch dh # Module *main* applies *rxn* to the crn t i t t t module main(crn) = sum(map(rxn, crn)) where crn = irrev_reactions(crn); simplified variant of translation scheme: lakin2012.ts 16