Biochemistry

Enzyme Kinetics

Michaelis-Menten Equation

v = (Vmax × [S]) / (Km + [S])

Where:
- v = reaction velocity
- Vmax = maximum velocity
- [S] = substrate concentration
- Km = Michaelis constant (substrate at half Vmax)

Enzyme Inhibition Types

import numpy as np

class EnzymeKinetics:
    """Enzyme kinetics calculations"""
    
    def michaelis_menten(self, S, Vmax, Km):
        """
        Calculate reaction velocity
        S: Substrate concentration
        Vmax: Maximum velocity  
        Km: Michaelis constant
        """
        return (Vmax * S) / (Km + S)
    
    def lineweaver_burk(self, S, v):
        """
        Linearize: 1/v = (Km/Vmax)(1/S) + 1/Vmax
        Plot: x = 1/S, y = 1/v
        - Slope = Km/Vmax
        - y-intercept = 1/Vmax
        - x-intercept = -1/Km
        """
        return 1/v, 1/S
    
    def inhibition_effect(self, S, Vmax, Km, Ki, I, inhibitor_type):
        """
        Calculate velocity with inhibitor
        """
        if inhibitor_type == 'competitive':
            Km_app = Km * (1 + I/Ki)
            return self.michaelis_menten(S, Vmax, Km_app)
        
        elif inhibitor_type == 'non-competitive':
            Vmax_app = Vmax / (1 + I/Ki)
            return self.michaelis_menten(S, Vmax_app, Km)
        
        elif inhibitor_type == 'uncompetitive':
            Vmax_app = Vmax / (1 + I/Ki)
            Km_app = Km / (1 + I/Ki)
            return self.michaelis_menten(S, Vmax_app, Km_app)
        
        elif inhibitor_type == 'mixed':
            alpha = 1 + I/Ki
            alpha_prime = 1 + I/Ki  # Simplified
            Vmax_app = Vmax / alpha
            Km_app = Km * alpha_prime / alpha
            return self.michaelis_menten(S, Vmax_app, Km_app)
    
    def catalytic_efficiency(self, kcat, Km):
        """
        kcat/Km - specificity constant
        Upper limit: 10^8-10^9 M^-1 s^-1 (diffusion limit)
        """
        return kcat / Km

Metabolic Pathways

Glycolysis

Glucose → Glucose-6-P → Fructose-6-P → Fructose-1,6-BP
                            ↓
                    [Payoff phase]
                    1,3-BPG → 3-PG → 2-PG → PEP → Pyruvate

Net: Glucose + 2 NAD+ + 2 ADP + 2 Pi → 2 Pyruvate + 2 NADH + 2 ATP

Citric Acid Cycle (Krebs Cycle)

Acetyl-CoA + Oxaloacetate → Citrate → Isocitrate → α-Ketoglutarate
                                                    ↓
                                          Succinyl-CoA → Succinate
                                                    ↓
                                          Fumarate → Malate → Oxaloacetate

Products per acetyl-CoA:
- 3 NADH
- 1 FADH₂
- 1 GTP (ATP)
- 2 CO₂

Oxidative Phosphorylation

class OxidativePhosphorylation:
    """ETC and ATP synthesis"""
    
    # P/O ratios (ATP per electron pair)
    P_TO_O = {
        "NADH": 2.5,  # Complex I
        "FADH2": 1.5,  # Complex II
        "QH2": 1.5     # Complex III
    }
    
    # Electron transport chain complexes
    COMPLEXES = {
        "I": {
            "name": "NADH:ubiquinone oxidoreductase",
            "substrates": ["NADH"],
            "inhibitors": ["rotenone", "amytal"]
        },
        "II": {
            "name": "Succinate dehydrogenase",
            "substrates": ["succinate", "FADH2"],
            "inhibitors": ["thenoyltrifluoroacetone"]
        },
        "III": {
            "name": "Cytochrome bc1",
            "substrates": ["QH2"],
            "inhibitors": ["antimycin A", "myxothiazol"]
        },
        "IV": {
            "name": "Cytochrome c oxidase",
            "substrates": ["cytochrome c"],
            "inhibitors": ["cyanide", "CO", "azide"]
        }
    }
    
    def calculate_atp(self, nadh_input, fadh2_input):
        """Calculate ATP yield from glucose"""
        # Glycolysis: 2 NADH (cytosolic - requires shuttle)
        glycolytic_nadh = 2 * 1.5  # ~1.5 or 2.5 depending on shuttle
        
        # Pyruvate dehydrogenase: 2 NADH
        pdh_nadh = 2 * 2.5
        
        # Krebs cycle: 6 NADH + 2 FADH2
        krebs_nadh = 6 * 2.5
        krebs_fadh2 = 2 * 1.5
        
        total_nadh = glycolytic_nadh + pdh_nadh + krebs_nadh
        total_fadh2 = krebs_fadh2 + fadh2_input
        
        return (total_nadh * 2.5) + (total_fadh2 * 1.5) + 2  # +2 GTP

Protein Structure

Hierarchical Organization

class ProteinStructure:
    """Protein structure concepts"""
    
    # Secondary structure prediction (simplified)
    CHOU_FASMAN = {
        "alpha_helix": {
            "residues": ["A", "C", "L", "M", "E", "H", "Q"],
            "Pα": 1.42
        },
        "beta_sheet": {
            "residues": ["V", "Y", "I", "F", "W"],
            "Pβ": 1.70
        }
    }
    
    def predict_secondary(self, sequence):
        """
        Chou-Fasman method
        Calculate Pα and Pβ for windows
        """
        predictions = []
        
        for i in range(len(sequence) - 6):
            window = sequence[i:i+6]
            
            p_alpha = sum(self.CHOU_FASMAN["alpha_helix"]["Pα"] 
                         for aa in window if aa in self.CHOU_FASMAN["alpha_helix"]["residues"])
            p_beta = sum(self.CHOU_FASMAN["beta_sheet"]["Pβ"]
                        for aa in window if aa in self.CHOU_FASMAN["beta_sheet"]["residues"])
            
            if p_alpha > p_beta and p_alpha > 1.0:
                predictions.append("H")  # Helix
            elif p_beta > p_alpha and p_beta > 1.0:
                predictions.append("E")  # Sheet
            else:
                predictions.append("C")  # Coil
        
        return predictions

Biochemical Techniques

Spectroscopy

Chromatography

Electrophoresis

class ProteinPurification:
    """Protein purification calculations"""
    
    def calculate_ion_exchange(self, protein_pI, buffer_pH):
        """
        Determine if cation or anion exchange
        pI < pH → net negative → anion exchange
        pI > pH → net positive → cation exchange
        """
        if protein_pI < buffer_pH:
            return "Anion exchange (negatively charged)"
        else:
            return "Cation exchange (positively charged)"
    
    def est_sds_page_mw(self, migration_distance, standard_distances):
        """
        Estimate MW from migration
        log(MW) = log(MW_std) - K × (migration - migration_std)
        """
        pass

Metabolic Regulation

Allosteric Regulation

Covalent Modification

Signaling Pathways

Major Pathways

Common Errors to Avoid

1. Ignoring enzyme saturation — Michaelis-Menten applies at low [S]
2. Not accounting for product inhibition — Real systems are more complex
3. Confusing Km with affinity — Lower Km ≠ higher affinity always
4. Oversimplifying metabolism — Regulation is multi-level
5. Ignoring cellular context — In vitro ≠ in vivo
6. Forgetting cofactor requirements — NAD+, ATP, Mg²⁺ etc.
7. Incorrect protein concentration — Dilute solutions absorbances
8. Not validating structure predictions — Computational only