Synthetic Biology: Programming Genetic Circuits in Living Cells

# Genetic circuit design (conceptual representation)
# Actual implementation uses DNA assembly and transformation

class GeneticToggleSwitch:
    """
    Two-repressor toggle switch (Gardner et al., Nature 2000)
    
    Circuit design:
    - LacI represses tetR
    - TetR represses lacI
    - IPTG inactivates LacI → TetR expressed → stable State 2
    - aTc inactivates TetR → LacI expressed → stable State 1
    """
    def __init__(self):
        # Promoter strengths (arbitrary units)
        self.p_lac = 1.0  # lacI promoter strength
        self.p_tet = 1.0  # tetR promoter strength
        
        # Repression constants
        self.k_lac = 2.0  # LacI repression efficiency
        self.k_tet = 2.0  # TetR repression efficiency
        
        # Degradation rates
        self.gamma_lac = 0.1
        self.gamma_tet = 0.1
        
        # Initial state
        self.lacI_level = 10.0
        self.tetR_level = 0.1
    
    def simulate_dynamics(self, iptg=0.0, atc=0.0, timesteps=100):
        """Simulate toggle switch dynamics"""
        lacI_history = [self.lacI_level]
        tetR_history = [self.tetR_level]
        
        for t in range(timesteps):
            # LacI production (repressed by TetR)
            tetR_active = self.tetR_level * (1 - atc)  # aTc inactivates TetR
            lacI_production = self.p_lac / (1 + (tetR_active / self.k_tet)**2)
            lacI_degradation = self.gamma_lac * self.lacI_level
            
            # TetR production (repressed by LacI)
            lacI_active = self.lacI_level * (1 - iptg)  # IPTG inactivates LacI
            tetR_production = self.p_tet / (1 + (lacI_active / self.k_lac)**2)
            tetR_degradation = self.gamma_tet * self.tetR_level
            
            # Update concentrations (Euler integration)
            self.lacI_level += 0.1 * (lacI_production - lacI_degradation)
            self.tetR_level += 0.1 * (tetR_production - tetR_degradation)
            
            lacI_history.append(self.lacI_level)
            tetR_history.append(self.tetR_level)
        
        return lacI_history, tetR_history
    
    def get_state(self):
        """Determine current bistable state"""
        if self.lacI_level > self.tetR_level:
            return "State 1: LacI HIGH, TetR LOW"
        else:
            return "State 2: LacI LOW, TetR HIGH"

# Demonstrate bistability
switch = GeneticToggleSwitch()

print("Initial state:", switch.get_state())

# Pulse IPTG to flip to State 2
print("\nApplying IPTG pulse...")
switch.simulate_dynamics(iptg=0.9, timesteps=50)
print("After IPTG:", switch.get_state())

# Pulse aTc to flip back to State 1
print("\nApplying aTc pulse...")
switch.simulate_dynamics(atc=0.9, timesteps=50)
print("After aTc:", switch.get_state())

from dataclasses import dataclass
from typing import List

@dataclass
class BioBrick:
    """Standardized genetic part (RFC10 standard)"""
    name: str
    type: str  # promoter, RBS, CDS, terminator
    sequence: str
    prefix: str = "GAATTCGCGGCCGCTTCTAGAG"  # EcoRI-NotI-XbaI
    suffix: str = "TACTAGTAGCGGCCGCTGCAG"   # SpeI-NotI-PstI

class GeneticCircuit:
    """Compose BioBricks into functional circuits"""
    def __init__(self, name: str):
        self.name = name
        self.parts = []
    
    def add_part(self, brick: BioBrick):
        """Add BioBrick to circuit"""
        # Validate part ordering
        expected_types = ["promoter", "RBS", "CDS", "terminator"]
        if self.parts:
            last_type = self.parts[-1].type
            current_type = brick.type
            
            last_idx = expected_types.index(last_type) if last_type in expected_types else -1
            current_idx = expected_types.index(current_type) if current_type in expected_types else -1
            
            if current_idx <= last_idx:
                print(f"⚠️ Warning: Unusual part ordering ({last_type} → {current_type})")
        
        self.parts.append(brick)
    
    def assemble(self) -> str:
        """Assemble full DNA sequence"""
        # BioBrick assembly removes suffix/prefix between parts
        if not self.parts:
            return ""
        
        dna = self.parts[0].prefix + self.parts[0].sequence
        
        for brick in self.parts[1:]:
            dna += brick.sequence
        
        dna += self.parts[-1].suffix
        
        return dna
    
    def analyze_safety(self):
        """Check for horizontal gene transfer risks"""
        dna = self.assemble()
        
        warnings = []
        
        # Check for origin of replication
        if "ORICOLEI" in dna or "ORIC" in dna:
            warnings.append("⚠️ Contains origin of replication - may replicate autonomously")
        
        # Check for antibiotic resistance
        resistance_markers = ["AMPR", "KANR", "TETR"]
        for marker in resistance_markers:
            if marker in dna:
                warnings.append(f"⚠️ Contains {marker} - antibiotic resistance marker")
        
        # Check for mobilization elements
        if "MOB" in dna or "TRA" in dna:
            warnings.append("⚠️ Contains mobilization genes - horizontal transfer risk")
        
        return warnings

# Example: Build GFP expression circuit
circuit = GeneticCircuit("GFP_Expression")

# Add parts in order
circuit.add_part(BioBrick("pLac", "promoter", "TTTACAGCTAGCTCAGTCCTAGGTATAATACTAGTATGGCTAGC"))
circuit.add_part(BioBrick("RBS_strong", "RBS", "AAAGAGGAGAAA"))
circuit.add_part(BioBrick("GFP", "CDS", "ATGAGTAAAGGAGAAGAACTTTTCACTGGAGTTGTCCCAATT..."))  # GFP gene
circuit.add_part(BioBrick("T1", "terminator", "AAAAAAAAAAAAAAAAAAGCGGCCGC"))

print("Assembled circuit:", circuit.assemble()[:100], "...")

# Safety analysis
safety_warnings = circuit.analyze_safety()
if safety_warnings:
    print("\nSafety warnings:")
    for warning in safety_warnings:
        print(warning)

class MetabolicPathway:
    """Engineer metabolic flux for chemical production"""
    def __init__(self):
        # Enzyme expression levels (normalized)
        self.enzymes = {
            'E1_glucose_import': 1.0,
            'E2_glycolysis': 1.0,
            'E3_pathway_branch': 0.1,  # Low native expression
            'E4_target_synthesis': 0.1,
            'E5_export': 0.5
        }
        
        # Metabolite concentrations
        self.metabolites = {
            'glucose': 100.0,
            'intermediate_A': 0.0,
            'intermediate_B': 0.0,
            'target_product': 0.0
        }
    
    def overexpress_enzyme(self, enzyme_name, fold_change):
        """Genetic modification to overexpress enzyme"""
        if enzyme_name in self.enzymes:
            self.enzymes[enzyme_name] *= fold_change
            print(f"Overexpressed {enzyme_name} by {fold_change}x")
    
    def knockout_gene(self, enzyme_name):
        """Delete competing pathway"""
        if enzyme_name in self.enzymes:
            self.enzymes[enzyme_name] = 0.0
            print(f"Knocked out {enzyme_name}")
    
    def simulate_production(self, hours=24):
        """Simulate engineered strain production"""
        product_yield = []
        
        for hour in range(hours):
            # Flux through pathway (simplified)
            flux_glycolysis = self.enzymes['E2_glycolysis'] * self.metabolites['glucose']
            flux_branch = self.enzymes['E3_pathway_branch'] * flux_glycolysis
            flux_synthesis = self.enzymes['E4_target_synthesis'] * flux_branch
            
            # Update metabolites
            self.metabolites['glucose'] -= flux_glycolysis * 0.1
            self.metabolites['intermediate_A'] += flux_branch - flux_synthesis
            self.metabolites['target_product'] += flux_synthesis
            
            product_yield.append(self.metabolites['target_product'])
            
            # Cell death if intermediate accumulates (toxicity)
            if self.metabolites['intermediate_A'] > 50:
                print(f"⚠️ Cell death at hour {hour}: toxic intermediate accumulation")
                break
        
        return product_yield

# Engineer strain for target chemical production
strain = MetabolicPathway()

print("=== Wild-type strain ===")
wt_yield = strain.simulate_production()
print(f"Final yield: {wt_yield[-1]:.2f}\n")

# Apply metabolic engineering
engineered_strain = MetabolicPathway()
engineered_strain.overexpress_enzyme('E3_pathway_branch', 10.0)
engineered_strain.overexpress_enzyme('E4_target_synthesis', 20.0)
engineered_strain.overexpress_enzyme('E5_export', 5.0)

print("=== Engineered strain ===")
eng_yield = engineered_strain.simulate_production()
print(f"Final yield: {eng_yield[-1]:.2f}")
print(f"Improvement: {eng_yield[-1] / wt_yield[-1]:.1f}x")