🧠 Fundamentals of Protein Structure Prediction

Q: What is protein structure prediction?

Protein structure prediction is the computational determination of the 3D structure of a protein from its amino acid sequence. It aims to predict how a linear chain of amino acids folds into a functional three-dimensional structure, which determines the protein's function, interactions, and role in health and disease.

Q: What is the difference between homology modeling, threading, and ab initio?

Homology modeling uses a homologous template with known structure (>30% sequence identity). Threading (fold recognition) fits a sequence to known folds without close homologs. Ab initio predicts structure from sequence alone using physics or knowledge-based potentials. Modern deep learning methods (AlphaFold2) often outperform all three by combining evolutionary and structural information.

Q: What is AlphaFold2 and how does it work?

AlphaFold2 is a deep learning system developed by DeepMind that predicts protein structures with accuracy comparable to experimental methods. It uses a transformer-based neural network with multiple sequence alignments (MSAs), template structures, and an attention mechanism to predict inter-residue distances and angles, producing highly accurate 3D models.

Q: What is a PDB file?

A PDB (Protein Data Bank) file is the standard text format for storing 3D structural data of biological macromolecules. It contains atomic coordinates (ATOM/HETATM records), secondary structure annotations (HELIX/SHEET), and metadata. It's used by all major structural biology tools including PyMOL, ChimeraX, and Biopython.

Q: How do I validate a predicted protein structure?

Use validation tools such as MolProbity (Ramachandran outliers, rotamers, clashes), PROCHECK, QMEAN, and ERRAT. Check pLDDT confidence scores (AlphaFold), PAE (Predicted Aligned Error), and compare with experimental data if available. Low-confidence regions often correspond to intrinsically disordered regions.

🎯 What is Protein Structure Prediction?

Protein structure prediction is the computational determination of the 3D structure of a protein from its amino acid sequence. It aims to predict how a linear chain of amino acids folds into a functional three-dimensional structure, which determines the protein's function, interactions, and role in health and disease. This is one of the grand challenges of computational biology.

Why It Matters

Function: Structure determines function. Drugs: Target identification. Disease: Mutation impact. Design: Novel proteins. Evolution: Relationships. Clinical: Variant interpretation.

📌 Sequence → Structure📌 Folding📌 Function📌 AlphaFold

# Protein Structure Prediction — the big picture
# From sequence to 3D structure.

# CONCEPTUAL OVERVIEW
print("""
=== Protein Structure Prediction ===

What it is:
  - Predict 3D structure from sequence
  - Amino acid chain → folded protein
  - Function follows structure
  - Grand challenge of biology

Why it's hard:
  - Levinthal's paradox
  - Astronomical conformations
  - Protein folding problem
  - Many-body interactions

Why it matters:
  - Drug discovery
  - Disease mechanisms
  - Protein engineering
  - Variant interpretation
  - Structural biology

Methods:
  - Homology modeling
  - Threading (fold recognition)
  - Ab initio (physics-based)
  - Deep learning (AlphaFold)
  - Molecular dynamics

Levels:
  - Primary: Sequence
  - Secondary: α-helix, β-sheet
  - Tertiary: 3D fold
  - Quaternary: Complex

Workflow:
  1. Sequence retrieval
  2. Template search (BLAST)
  3. Alignment
  4. Model building
  5. Loop modeling
  6. Side-chain packing
  7. Refinement
  8. Validation

Applications:
  - Drug design
  - Enzyme engineering
  - Antibody design
  - Vaccine development
  - Variant interpretation
  - Protein-protein interactions
""")

# WHY IT MATTERS
print("=== Why It Matters ===")
print("""
Biological questions:
  - What is the 3D structure?
  - How does it fold?
  - What is its function?
  - How do mutations affect it?
  - How do drugs bind?

Structure prediction answers:
  - 3D coordinates
  - Fold
  - Active sites
  - Binding pockets
  - Stability
""")

# HISTORICAL CONTEXT
print("=== Historical Context ===")
print("""
1950s: Protein folding problem
1960s: First protein structures (myoglobin, hemoglobin)
1970s: Anfinsen's dogma
1980s: Homology modeling
1990s: CASP (Critical Assessment)
2000s: Threading, ab initio (Rosetta)
2010s: Deep learning (AlphaFold1)
2020: AlphaFold2 (CASP14)
2021: RoseTTAFold, ESMFold
2022: AlphaFold DB (200M structures)
2024: AlphaFold3 (complexes)
""")

# CHALLENGES
print("=== Challenges ===")
print("""
1. SEQUENCE DIVERSITY
   - No template for many proteins
   - Novel folds

2. LOOP REGIONS
   - Variable
   - Hard to model

3. SIDE CHAINS
   - Packing
   - Rotamers

4. FLEXIBILITY
   - Dynamics
   - Multiple states

5. COMPLEXES
   - Protein-protein
   - Protein-ligand

6. VALIDATION
   - Accuracy assessment
   - Confidence
""")

🎯 Why Protein Structure Prediction Matters

🎯 The Value of Structure Prediction

Protein structure prediction bridges the gap between sequence and function, enabling drug discovery, protein engineering, and disease understanding.

Key Applications

Drugs: Target structure. Disease: Mutation impact. Design: Novel proteins. Antibodies: Design. Enzymes: Engineering. Variants: Interpretation.

🎯 Drug discovery🎯 Disease🎯 Design🎯 Variants

# Why Protein Structure Prediction Matters
print("=== 1. Drug Discovery ===")
print("""
Drug discovery:
  - Target structure
  - Binding pockets
  - Virtual screening
  - Lead optimization

Workflow:
  1. Predict structure
  2. Identify pocket
  3. Dock compounds
  4. Optimize
  5. Test

Examples:
  - Kinases
  - GPCRs
  - Proteases
  - Ion channels

Tools:
  - AlphaFold
  - AutoDock
  - PyMOL
""")

print("\n=== 2. Disease Mechanisms ===")
print("""
Disease:
  - Mutation impact
  - Stability
  - Interactions

Workflow:
  1. Predict wild-type
  2. Predict mutant
  3. Compare
  4. Assess impact

Examples:
  - Cancer mutations
  - Rare disease
  - Pharmacogenomics

Tools:
  - AlphaFold
  - FoldX
  - Rosetta
""")

print("\n=== 3. Protein Engineering ===")
print("""
Engineering:
  - Novel proteins
  - Stability
  - Activity
  - Binding

Workflow:
  1. Design
  2. Predict structure
  3. Validate
  4. Test

Examples:
  - Enzymes
  - Antibodies
  - Biosensors
  - Vaccines

Tools:
  - RFdiffusion
  - ProteinMPNN
  - AlphaFold
""")

print("\n=== 4. Antibody Design ===")
print("""
Antibodies:
  - Structure prediction
  - Epitope mapping
  - Affinity maturation

Workflow:
  1. Sequence
  2. Predict structure
  3. Dock antigen
  4. Optimize

Tools:
  - AlphaFold
  - IgFold
  - ABodyBuilder
""")

print("\n=== 5. Variant Interpretation ===")
print("""
Variants:
  - Clinical significance
  - Structure impact
  - Function

Workflow:
  1. Variant
  2. Predict structure
  3. Assess impact
  4. Classify

Tools:
  - AlphaFold
  - FoldX
  - CADD
""")

print("\n=== 6. Enzyme Engineering ===")
print("""
Enzymes:
  - Substrate specificity
  - Catalysis
  - Stability

Workflow:
  1. Structure
  2. Active site
  3. Design
  4. Test

Tools:
  - AlphaFold
  - Rosetta
  - PyMOL
""")

print("\n=== 7. Structural Genomics ===")
print("""
Structural genomics:
  - Many structures
  - Coverage
  - Function

Examples:
  - AlphaFold DB (200M)
  - PDB (200K)
  - Model organisms

Tools:
  - AlphaFold
  - PDB
  - UniProt
""")

print("\n=== 8. Vaccine Design ===")
print("""
Vaccines:
  - Antigen structure
  - Epitope
  - Design

Workflow:
  1. Antigen
  2. Structure
  3. Epitope
  4. Design

Examples:
  - SARS-CoV-2
  - Influenza
  - HIV
  - Malaria

Tools:
  - AlphaFold
  - PyMOL
  - Rosetta
""")

📖 Protein Structure Levels

🎯 Hierarchical Organization

Protein structure is organized hierarchically: primary, secondary, tertiary, and quaternary. Understanding each level is essential for prediction.

Levels

Primary: Sequence. Secondary: α-helix, β-sheet. Tertiary: 3D fold. Quaternary: Complex. Domains: Modules. Motifs: Patterns.

📖 Primary📖 Secondary📖 Tertiary📖 Quaternary

# Protein Structure Levels
print("=== 1. Primary Structure ===")
print("""
Primary:
  - Amino acid sequence
  - Linear chain
  - N-terminus to C-terminus

Example:
  MVLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHF...

Bonds:
  - Peptide bonds
  - Covalent

Information:
  - Sequence determines structure
  - Anfinsen's dogma
""")

print("\n=== 2. Secondary Structure ===")
print("""
Secondary:
  - Local folding
  - α-helix
  - β-sheet
  - Turns, loops

α-helix:
  - 3.6 residues/turn
  - H-bonds i to i+4
  - Right-handed

β-sheet:
  - Parallel or antiparallel
  - H-bonds between strands
  - Pleated

Tools:
  - DSSP
  - STRIDE
  - PSIPRED
""")

print("\n=== 3. Tertiary Structure ===")
print("""
Tertiary:
  - 3D fold
  - Full chain
  - Domains

Driving forces:
  - Hydrophobic effect
  - H-bonds
  - Disulfide bonds
  - Electrostatics
  - Van der Waals

Folds:
  - Globular
  - Fibrous
  - Membrane

Examples:
  - Myoglobin
  - Lysozyme
  - GFP
""")

print("\n=== 4. Quaternary Structure ===")
print("""
Quaternary:
  - Multiple chains
  - Complex
  - Subunits

Types:
  - Homodimer
  - Heterodimer
  - Tetramer
  - Larger

Examples:
  - Hemoglobin (α2β2)
  - Antibodies
  - Proteasome
  - Ribosome

Tools:
  - AlphaFold-Multimer
  - PISA
  - PDBePISA
""")

print("\n=== 5. Domains ===")
print("""
Domains:
  - Independent folding units
  - Functional modules
  - Reused in evolution

Examples:
  - Kinase domain
  - SH2 domain
  - Zinc finger
  - Immunoglobulin

Databases:
  - CATH
  - SCOP
  - Pfam
  - InterPro
""")

print("\n=== 6. Motifs ===")
print("""
Motifs:
  - Short patterns
  - Functional sites
  - Structural

Examples:
  - Walker A: GXXXXGK[ST]
  - Zinc finger: CXXC
  - N-glycosylation: NX[ST]
  - Nuclear localization: K[KR]X[KR]

Databases:
  - PROSITE
  - Pfam
  - ELM
""")

print("\n=== 7. Folds ===")
print("""
Fold:
  - Overall topology
  - Arrangement of secondary structure
  - Conserved

Examples:
  - TIM barrel
  - Immunoglobulin
  - Rossmann fold
  - Greek key

Databases:
  - CATH
  - SCOP
  - FSSP
""")

print("\n=== 8. Disorder ===")
print("""
Intrinsic disorder:
  - No fixed structure
  - Flexible
  - Functional

Examples:
  - Linkers
  - Binding regions
  - Signaling

Prediction:
  - IUPred
  - DisEMBL
  - PONDR
  - AlphaFold pLDDT

Note:
  - Low pLDDT = disorder
""")

⚙️ Prediction Methods

🎯 Overview of Methods

Protein structure prediction methods fall into four main categories: homology modeling, threading, ab initio, and deep learning.

Methods

Homology: Template-based. Threading: Fold recognition. Ab initio: Physics-based. Deep learning: AlphaFold. Hybrid: Combine. MD: Dynamics.

⚙️ Homology⚙️ Threading⚙️ Ab initio⚙️ Deep learning

# Prediction Methods
print("=== 1. Homology Modeling ===")
print("""
Homology modeling:
  - Template-based
  - > 30% sequence identity
  - Most accurate for close homologs

Steps:
  1. Template search (BLAST)
  2. Sequence alignment
  3. Model building
  4. Loop modeling
  5. Side-chain packing
  6. Refinement

Tools:
  - MODELLER
  - SWISS-MODEL
  - I-TASSER
  - Phyre2

Accuracy:
  - > 90% for > 50% identity
  - Decreases with identity
""")

print("\n=== 2. Threading (Fold Recognition) ===")
print("""
Threading:
  - Fold recognition
  - No close homolog
  - Fit sequence to known folds

Steps:
  1. Fold library
  2. Sequence-structure alignment
  3. Scoring
  4. Rank
  5. Model

Tools:
  - I-TASSER
  - Phyre2
  - MUSTER
  - HHpred

Accuracy:
  - Moderate
  - Depends on fold library
""")

print("\n=== 3. Ab Initio ===")
print("""
Ab initio:
  - Physics-based
  - No template
  - From sequence alone

Approaches:
  - Energy minimization
  - Monte Carlo
  - Fragment assembly (Rosetta)
  - Knowledge-based potentials

Tools:
  - Rosetta
  - I-TASSER
  - QUARK
  - EVfold

Accuracy:
  - Small proteins (< 100 aa)
  - Limited
""")

print("\n=== 4. Deep Learning ===")
print(""
Deep learning:
  - AlphaFold2 (DeepMind)
  - RoseTTAFold
  - ESMFold
  - Accurate

AlphaFold2:
  - Transformer
  - MSA
  - Attention
  - End-to-end

Accuracy:
  - Near-experimental
  - CASP14 winner
  - 200M+ structures

Tools:
  - AlphaFold
  - ColabFold
  - RoseTTAFold
  - ESMFold
""")

print("\n=== 5. Molecular Dynamics ===")
print(""
Molecular dynamics:
  - Physics simulation
  - Time evolution
  - Refinement

Applications:
  - Refinement
  - Dynamics
  - Binding
  - Folding

Tools:
  - GROMACS
  - AMBER
  - NAMD
  - OpenMM

Force fields:
  - AMBER
  - CHARMM
  - OPLS
""")

print("\n=== 6. Hybrid Methods ===")
print(""
Hybrid:
  - Combine methods
  - Best of both
  - More accurate

Examples:
  - I-TASSER (threading + ab initio)
  - Rosetta (fragments + physics)
  - AlphaFold (MSA + templates)

Strategy:
  - Use template if available
  - Ab initio for loops
  - Refine with MD
""")

print("\n=== Method Comparison ===")
print(f"{'Method':<20} {'Template':<15} {'Accuracy':<15} {'Speed':<15}")
print("-" * 65)
print(f"{'Homology':<20} {'Yes':<15} {'High':<15} {'Fast':<15}")
print(f"{'Threading':<20} {'Yes':<15} {'Medium':<15} {'Fast':<15}")
print(f"{'Ab initio':<20} {'No':<15} {'Low':<15} {'Slow':<15}")
print(f"{'Deep learning':<20} {'MSA':<15} {'High':<15} {'Medium':<15}")
print(f"{'MD':<20} {'No':<15} {'Refine':<15} {'Slow':<15}")

print("\n=== Choosing a Method ===")
print("""
Choose method:
  - Close homolog (> 30%): Homology
  - Remote homolog: Threading
  - No homolog: AlphaFold / Ab initio
  - Small protein: Ab initio
  - Refinement: MD

Modern default:
  → AlphaFold2 / ColabFold
  → ESMFold (fast)
  → RoseTTAFold
""")

🏗️ Homology Modeling

🎯 Template-Based Modeling

Homology modeling builds a 3D model of a target protein using an experimentally determined structure of a homologous protein (template).

Homology

Template: Known structure. Alignment: Target-template. Identity: > 30%. Loops: Model. Side chains: Pack. Refine: Optimize.

🏗️ Template🏗️ Alignment🏗️ Loops🏗️ Side chains

# Homology Modeling
print("=== Steps ===")
print("""
1. TEMPLATE SEARCH
   - BLAST against PDB
   - Identify homologs
   - Select best template

2. SEQUENCE ALIGNMENT
   - Target vs template
   - ClustalW, MUSCLE
   - Manual curation

3. MODEL BUILDING
   - Copy backbone
   - Model loops
   - Pack side chains

4. LOOP MODELING
   - Insertions/deletions
   - Loop library
   - Ab initio

5. SIDE-CHAIN PACKING
   - Rotamer library
   - Optimization

6. REFINEMENT
   - Energy minimization
   - MD
   - Validation
""")

print("\n=== Template Selection ===")
print("""
Criteria:
  - Sequence identity (> 30%)
  - Resolution (< 2.5 Å)
  - Coverage
  - R-factor
  - Ligands

Tools:
  - BLAST
  - HHpred
  - Phyre2
  - SWISS-MODEL

Example:
  Target: Human kinase
  Template: 1ATP (2.0 Å)
  Identity: 45%
""")

print("\n=== MODELLER ===")
print(""
MODELLER:
  - Most popular
  - Python
  - Accurate

Script:
  from modeller import *
  from modeller.automodel import *
  
  env = Environ()
  env.io.atom_files_directory = ['.']
  
  a = AutoModel(env,
                alnfile='target-template.ali',
                knowns='1abc',
                sequence='target')
  a.starting_model = 1
  a.ending_model = 5
  a.make()

Command:
  modeller script.py
""")

print("\n=== SWISS-MODEL ===")
print(""
SWISS-MODEL:
  - Web server
  - Automated
  - Easy

Workflow:
  1. Submit sequence
  2. Template search
  3. Alignment
  4. Model building
  5. Validation

URL:
  swissmodel.expasy.org
""")

print("\n=== I-TASSER ===")
print(""
I-TASSER:
  - Threading + ab initio
  - Web + CLI
  - Accurate

Workflow:
  1. Submit sequence
  2. Threading
  3. Assembly
  4. Refinement
  5. Validation

URL:
  zhanggroup.org/I-TASSER
""")

print("\n=== Accuracy ===")
print(""
Accuracy vs identity:
  - > 90%: Near-experimental
  - 50-90%: Good
  - 30-50%: Moderate
  - < 30%: Poor

RMSD:
  - < 1 Å: Excellent
  - 1-2 Å: Good
  - 2-5 Å: Moderate
  - > 5 Å: Poor
""")

print("\n=== Best Practices ===")
print(""
1. Use multiple templates
2. Check alignment
3. Model loops carefully
4. Pack side chains
5. Refine
6. Validate
7. Compare with experiment
8. Report accuracy
""")

🧵 Threading & Fold Recognition

🎯 Fitting Sequence to Fold

Threading (fold recognition) fits a target sequence onto known folds, even without close homologs, using sequence-structure compatibility.

Threading

Fold library: Known folds. Scoring: Compatibility. Alignment: Sequence-structure. Rank: Best fold. Model: Build. Remote: Homologs.

🧵 Fold library🧵 Scoring🧵 Alignment🧵 Remote homologs

# Threading & Fold Recognition
print("=== Concept ===")
print(""
Threading:
  - Sequence → Fold
  - No close homolog
  - Use known folds

Key idea:
  - Sequence-structure compatibility
  - Energy function
  - Fold library

Difference from homology:
  - Homology: Sequence similarity
  - Threading: Structure compatibility
""")

print("\n=== Steps ===")
print(""
1. FOLD LIBRARY
   - SCOP, CATH
   - Representative folds

2. SEQUENCE-STRUCTURE ALIGNMENT
   - Thread sequence
   - Gap penalties
   - Scoring

3. SCORING
   - Knowledge-based
   - Statistical potentials
   - Environment

4. RANKING
   - Z-score
   - Confidence

5. MODEL BUILDING
   - Backbone
   - Loops
   - Side chains
""")

print("\n=== Scoring Functions ===")
print(""
Knowledge-based:
  - Statistical potentials
  - Contact frequencies
  - Environment

Examples:
  - DOPE
  - DFIRE
  - ProSA
  - Rosetta

Energy terms:
  - Solvation
  - H-bonds
  - Van der Waals
  - Torsion
""")

print("\n=== Tools ===")
print(""
1. I-TASSER
   - Threading + ab initio
   - Accurate

2. Phyre2
   - Web
   - HMM
   - Fold recognition

3. HHpred
   - HMM-HMM
   - Sensitive

4. MUSTER
   - Profile
   - Accurate

5. Rosetta
   - Fragment assembly
   - Ab initio

6. Threader
   - Classic
""")

print("\n=== I-TASSER ===")
print(""
I-TASSER:
  - Threading
  - Assembly
  - Refinement

Steps:
  1. Threading
  2. Fragment assembly
  3. Clustering
  4. Refinement
  5. Validation

Output:
  - Top 5 models
  - C-score
  - TM-score
  - RMSD

URL:
  zhanggroup.org/I-TASSER
""")

print("\n=== Phyre2 ===")
print(""
Phyre2:
  - Web
  - HMM
  - Fold recognition

Workflow:
  1. Submit sequence
  2. HMM search
  3. Fold recognition
  4. Model building
  5. Validation

Output:
  - Model
  - Confidence
  - Template

URL:
  sbg.bio.ic.ac.uk/phyre2
""")

print("\n=== HHpred ===")
print(""
HHpred:
  - HMM-HMM
  - Sensitive
  - Remote homologs

Workflow:
  1. Sequence → HMM
  2. Search HMM databases
  3. Alignment
  4. Model

Databases:
  - PDB
  - SCOP
  - Pfam

URL:
  toolbox.compbio.sdu.dk
""")

print("\n=== Best Practices ===")
print(""
1. Use multiple templates
2. Check alignment
3. Assess confidence
4. Compare methods
5. Validate
6. Report Z-score
7. Consider alternative folds
8. Use AlphaFold when possible
""")

🔬 Ab Initio & Physics-Based

🎯 From Sequence Alone

Ab initio prediction builds structure from sequence alone using physics-based or knowledge-based energy functions, without templates.

Ab Initio

Physics: Energy. Fragments: Rosetta. Sampling: Monte Carlo. Scoring: Energy. Small: Proteins. Hard: Problem.

🔬 Energy🔬 Fragments🔬 Monte Carlo🔬 Small proteins

# Ab Initio & Physics-Based
print("=== Concept ===")
print(""
Ab initio:
  - Sequence → Structure
  - No template
  - Physics or knowledge

Levinthal's paradox:
  - Astronomical conformations
  - Cannot sample all
  - Need heuristics
""")

print("\n=== Energy Functions ===")
print(""
Physics-based:
  - Bond lengths
  - Bond angles
  - Dihedrals
  - Van der Waals
  - Electrostatics
  - Solvation

Knowledge-based:
  - Statistical potentials
  - Contact frequencies
  - Environment

Force fields:
  - AMBER
  - CHARMM
  - OPLS
  - Rosetta
""")

print("\n=== Rosetta ===")
print(""
Rosetta:
  - Fragment assembly
  - Monte Carlo
  - Energy

Steps:
  1. Fragment library
  2. Fragment insertion
  3. Monte Carlo
  4. Scoring
  5. Refinement

Command:
  rosetta_scripts.default.linuxgccrelease \
    -in:file:fasta target.fa \
    -parser:protocol abinitio.xml \
    -nstruct 100

Output:
  - 100 models
  - Scored
  - Clustered
""")

print("\n=== QUARK ===")
print(""
QUARK:
  - Ab initio
  - Fragment
  - Web

Workflow:
  1. Submit sequence
  2. Fragment assembly
  3. Replica exchange
  4. Clustering
  5. Refinement

Output:
  - Models
  - Confidence
  - TM-score

URL:
  zhanggroup.org/QUARK
""")

print("\n=== EVfold ===")
print(""
EVfold:
  - Coevolution
  - Contact prediction
  - Structure

Concept:
  - Covarying residues
  - Contact prediction
  - Fold from contacts

Tools:
  - EVcouplings
  - Direct Coupling Analysis (DCA)
  - GREMLIN

Steps:
  1. MSA
  2. Covariation
  3. Contacts
  4. Structure
""")

print("\n=== Limitations ===")
print(""
Limitations:
  - Small proteins (< 100 aa)
  - High computational cost
  - Low accuracy
  - Multiple minima
  - Force field errors

Current status:
  - Superseded by AlphaFold
  - Still useful for:
    - Small peptides
    - Novel folds
    - Refinement
    - Dynamics
""")

print("\n=== Best Practices ===")
print(""
1. Small proteins
2. Multiple runs
3. Cluster models
4. Validate
5. Compare with AlphaFold
6. Use coevolution
7. Refine with MD
8. Report confidence
""")

🚀 AlphaFold & Deep Learning

🎯 The Revolution

AlphaFold2 and related deep learning methods have revolutionized protein structure prediction, achieving near-experimental accuracy.

AlphaFold

Transformer: Attention. MSA: Evolution. Templates: Structures. E2E: End-to-end. pLDDT: Confidence. PAE: Error.

🚀 Transformer🚀 MSA🚀 pLDDT🚀 PAE

# AlphaFold & Deep Learning
print("=== AlphaFold2 ===")
print(""
AlphaFold2:
  - DeepMind
  - CASP14 (2020)
  - Near-experimental
  - Transformer

Architecture:
  - Input: MSA + templates
  - Evoformer: MSA processing
  - Structure module: 3D
  - End-to-end

Key innovations:
  - Attention
  - MSA
  - End-to-end
  - Recycling
  - pLDDT
  - PAE
""")

print("\n=== AlphaFold2 Workflow ===")
print(""
1. SEQUENCE
   - Input FASTA

2. MSA
   - Jackhmmer
   - HHblits
   - UniRef, MGnify

3. TEMPLATES
   - PDB
   - Optional

4. MODEL
   - Evoformer
   - Structure module
   - Recycling

5. OUTPUT
   - PDB
   - pLDDT
   - PAE
   - JSON
""")

print("\n=== ColabFold ===")
print(""
ColabFold:
  - AlphaFold + MMseqs2
  - Fast
  - Free
  - Easy

Command:
  colabfold_batch input.fasta output_dir

Options:
  --msa-mode mmseqs2_uniref_env
  --num-recycle 3
  --num-models 5
  --use-gpu-relax

Output:
  - PDB
  - pLDDT
  - PAE
  - JSON

URL:
  colab.research.google.com
""")

print("\n=== ESMFold ===")
print(""
ESMFold:
  - Meta AI
  - Language model
  - Fast
  - No MSA

Concept:
  - Protein language model
  - ESM-2
  - Structure prediction
  - End-to-end

Advantages:
  - Fast
  - No MSA
  - Single sequence
  - 600M+ structures

Command:
  esm-fold -i input.fasta -o output_dir

URL:
  esmatlas.com
""")

print("\n=== RoseTTAFold ===")
print(""
RoseTTAFold:
  - Baker lab
  - Deep learning
  - 3-track

Architecture:
  - 1D sequence
  - 2D distance
  - 3D coordinates
  - Attention

Command:
  python predict.py input.fasta output_dir

URL:
  rosettacommons.org
""")

print("\n=== AlphaFold3 ===")
print(""
AlphaFold3:
  - 2024
  - Complexes
  - Ligands
  - Nucleic acids

Features:
  - Protein-protein
  - Protein-DNA
  - Protein-RNA
  - Protein-ligand
  - Ions

Architecture:
  - Diffusion
  - Pairformer
  - No MSA for ligands

URL:
  alphafold.ebi.ac.uk
""")

print("\n=== Confidence Metrics ===")
print(""
pLDDT:
  - Per-residue confidence
  - 0-100
  - > 90: Very high
  - 70-90: Confident
  - 50-70: Low
  - < 50: Very low (disorder)

PAE:
  - Predicted Aligned Error
  - Domain arrangement
  - Inter-domain confidence

pTM:
  - Global confidence
  - 0-1
  - > 0.8: Confident

ipTM:
  - Interface confidence
  - Complexes
""")

print("\n=== Best Practices ===")
print(""
1. Use ColabFold for most
2. Check pLDDT
3. Check PAE
4. Validate
5. Compare with experiment
6. Use AlphaFold DB
7. Consider disorder
8. Report confidence
""")

✅ Validation & Quality

🎯 Is My Model Good?

Structure validation assesses the quality of a predicted model using stereochemical, energetic, and statistical criteria.

Validation

Ramachandran: Dihedrals. MolProbity: Comprehensive. ERRAT: Statistics. QMEAN: Quality. pLDDT: Confidence. PAE: Error.

✅ Ramachandran✅ MolProbity✅ QMEAN✅ pLDDT

# Validation & Quality
print("=== Ramachandran Plot ===")
print(""
Ramachandran:
  - Phi/psi dihedrals
  - Allowed regions
  - Outliers

Regions:
  - Core: Favored
  - Allowed: Acceptable
  - Outlier: Problem

Interpretation:
  - > 98% core: Excellent
  - 95-98%: Good
  - < 95%: Problem

Tools:
  - PROCHECK
  - MolProbity
  - RAMPAGE
""")

print("\n=== MolProbity ===")
print(""
MolProbity:
  - Comprehensive
  - Standard
  - Web + CLI

Metrics:
  - Ramachandran
  - Rotamers
  - Clashes
  - Bonds
  - Angles

Score:
  - MolProbity score
  - Lower is better
  - < 2.0: Good

URL:
  molprobity.biochem.duke.edu
""")

print("\n=== QMEAN ===")
print(""
QMEAN:
  - Quality estimate
  - Z-score
  - Composite

Metrics:
  - Torsion
  - Solvation
  - Packing
  - H-bonds

Interpretation:
  - Z-score > -4: Good
  - < -4: Problem

URL:
  swissmodel.expasy.org/qmean
""")

print("\n=== ERRAT ===")
print(""
ERRAT:
  - Statistical
  - Non-bonded
  - Error

Interpretation:
  - > 95%: Good
  - 85-95%: Acceptable
  - < 85%: Problem

URL:
  servicesn.mbi.ucla.edu/ERRAT
""")

print("\n=== pLDDT (AlphaFold) ===")
print(""
pLDDT:
  - Per-residue
  - 0-100
  - Confidence

Interpretation:
  - > 90: Very high
  - 70-90: Confident
  - 50-70: Low
  - < 50: Very low

Use:
  - Color in PyMOL
  - Blue = high
  - Red = low
""")

print("\n=== PAE (AlphaFold) ===")
print(""
PAE:
  - Predicted Aligned Error
  - Domain arrangement
  - Inter-domain

Interpretation:
  - Low: Confident
  - High: Uncertain
  - Plot: Heatmap

Use:
  - Domain boundaries
  - Complex confidence
""")

print("\n=== Validation Tools ===")
print(f"{'Tool':<20} {'Type':<20} {'Metric':<20}")
print("-" * 65)
print(f"{'PROCHECK':<20} {'Stereochemistry':<20} {'Ramachandran':<20}")
print(f"{'MolProbity':<20} {'Comprehensive':<20} {'Score':<20}")
print(f"{'QMEAN':<20} {'Composite':<20} {'Z-score':<20}")
print(f"{'ERRAT':<20} {'Statistics':<20} {'Error':<20}")
print(f"{'Verify3D':<20} {'Environment':<20} {'Profile':<20}")
print(f"{'ProSA':<20} {'Energy':<20} {'Z-score':<20}")

print("\n=== Best Practices ===")
print(""
1. Multiple validation tools
2. Check Ramachandran
3. Check clashes
4. Check rotamers
5. Check pLDDT
6. Check PAE
7. Compare with experiment
8. Report all metrics
""")

📄 PDB & File Formats

🎯 Storing Structural Data

The PDB format is the standard for storing 3D structural data. Understanding it is essential for structural bioinformatics.

PDB

PDB: Classic format. mmCIF: Modern. ATOM: Coordinates. HETATM: Ligands. HELIX: Secondary. HEADER: Metadata.

📄 PDB📄 mmCIF📄 ATOM📄 HETATM

# PDB & File Formats
print("=== PDB Format ===")
print(""
PDB:
  - Text format
  - Fixed columns
  - Classic
  - Legacy

Records:
  - HEADER: Metadata
  - TITLE: Title
  - COMPND: Compound
  - SOURCE: Source
  - KEYWDS: Keywords
  - EXPDTA: Experiment
  - AUTHOR: Authors
  - REVDAT: Revision
  - SEQRES: Sequence
  - HELIX: Helices
  - SHEET: Sheets
  - ATOM: Atoms
  - HETATM: Ligands
  - CONECT: Connectivity
  - TER: Terminator
  - END: End
""")

print("\n=== ATOM Record ===")
print(""
ATOM:
  - Atomic coordinates
  - 80 columns
  - Fixed format

Columns:
  1-6:   Record name
  7-11:  Serial
  13-16: Atom name
  17:    Alt loc
  18-20: Residue name
  22:    Chain ID
  23-26: Residue seq
  27:    Insertion
  31-38: X
  39-46: Y
  47-54: Z
  55-60: Occupancy
  61-66: B-factor
  77-78: Element

Example:
  ATOM      1  N   MET A   1      27.340  24.430   2.614  1.00  9.67           N
""")

print("\n=== HETATM Record ===")
print(""
HETATM:
  - Non-standard residues
  - Ligands
  - Water
  - Ions

Example:
  HETATM 1000  O   HOH A 101      20.000  30.000  15.000  1.00 20.00           O
""")

print("\n=== mmCIF ===")
print(""
mmCIF:
  - Modern format
  - Flexible
  - Recommended
  - PDBx

Advantages:
  - No column limits
  - Extensible
  - Better for large structures
  - Data types

Records:
  - _atom_site
  - _struct
  - _entity
  - _refine
""")

print("\n=== PDB Tools ===")
print(""
1. PyMOL
   - Visualization
   - Scripting
   - Analysis

2. ChimeraX
   - Visualization
   - Analysis
   - Modern

3. Biopython
   - Parsing
   - Analysis
   - Python

4. pymol
   - Python API
   - Scripting

5. MDAnalysis
   - Dynamics
   - Analysis6. ProDy
   - Dynamics
   - Analysis
""")

print("\n=== Downloading Structures ===")
print(""
RCSB PDB:
  https://www.rcsb.org/
  
PDBe:
  https://www.ebi.ac.uk/pdbe/
  
AlphaFold DB:
  https://alphafold.ebi.ac.uk/
  
PDB Format:
  https://files.rcsb.org/download/1ABC.pdb
  
mmCIF:
  https://files.rcsb.org/download/1ABC.cif
""")

print("\n=== File Formats ===")
print(f"{'Format':<15} {'Type':<20} {'Use':<20}")
print("-" * 60)
print(f"{'PDB':<15} {'Text':<20} {'Classic':<20}")
print(f"{'mmCIF':<15} {'Text':<20} {'Modern':<20}")
print(f"{'PDBQT':<15} {'Text':<20} {'Docking':<20}")
print(f"{'MOL2':<15} {'Text':<20} {'Ligands':<20}")
print(f"{'SDF':<15} {'Text':<20} {'Chemistry':<20}")
print(f"{'XYZ':<15} {'Text':<20} {'Simple':<20}")

print("\n=== Best Practices ===")
print(""
1. Use mmCIF for new
2. Parse with Biopython
3. Check metadata
4. Check resolution
5. Check R-factor
6. Check ligands
7. Check missing residues
8. Report PDB ID
""")

🛠️ Tools (PyMOL, ChimeraX)

🎯 Visualization & Analysis

PyMOL and ChimeraX are the standard tools for protein structure visualization and analysis.

Tools

PyMOL: Visualization. ChimeraX: Modern. VMD: Dynamics. Coot: Model building. Jmol: Web. NGL: Web.

🛠️ PyMOL🛠️ ChimeraX🛠️ VMD🛠️ Coot

# Tools
print("=== PyMOL ===")
print(""
PyMOL:
  - Most popular
  - Visualization
  - Scripting
  - Free (open-source)

Features:
  - Cartoon, surface, sticks
  - Color by pLDDT
  - Align structures
  - Measure distances
  - Mutagenesis
  - Ray tracing

Commands:
  load 1abc.pdb
  show cartoon
  color blue
  select active, resi 100-110
  show sticks, active
  ray 1200, 900
  png output.png

Python:
  from pymol import cmd
  cmd.load("1abc.pdb")
  cmd.show("cartoon")
""")

print("\n=== ChimeraX ===")
print(""
ChimeraX:
  - Modern
  - Visualization
  - Analysis
  - Free

Features:
  - High quality
  - Large structures
  - AlphaFold
  - Volume
  - MD

Commands:
  open 1abc.pdb
  cartoon
  color bychain
  view
  save output.png

AlphaFold:
  open alphafold_model.pdb
  color byattribute bfactor
""")

print("\n=== VMD ===")
print(""
VMD (Visual Molecular Dynamics):
  - MD visualization
  - Analysis
  - Free

Features:
  - Trajectories
  - Analysis
  - Scripting

Commands:
  mol new 1abc.pdb
  display projection orthographic
  color Display Background white
""")

print("\n=== Coot ===")
print(""
Coot:
  - Model building
  - Crystallography
  - Free

Features:
  - Fit to density
  - Real space refine
  - Validation
  - Ramachandran
""")

print("\n=== Web Viewers ===")
print(""
1. NGL Viewer
   - Web
   - Interactive
   - Embeddable

2. Jmol
   - Java
   - Web
   - Classic

3. Mol*
   - Web
   - Modern
   - RCSB PDB

4. 3Dmol.js
   - JavaScript
   - Web
""")

print("\n=== Other Tools ===")
print(""
1. PyMOL
   - Visualization

2. ChimeraX
   - Visualization

3. VMD
   - MD

4. Coot
   - Crystallography

5. Rosetta
   - Modeling

6. MODELLER
   - Homology

7. GROMACS
   - MD

8. AutoDock
   - Docking
""")

print("\n=== Best Practices ===")
print(""
1. Use PyMOL or ChimeraX
2. Color by confidence
3. Check clashes
4. Check Ramachandran
5. Compare structures
6. Ray trace for publication
7. Script for reproducibility
8. Save sessions
""")

🐍 Python Integration

🎯 Structural Bioinformatics in Python

You can run structure prediction and analysis from Python using Biopython, PyMOL API, MDAnalysis, and ColabFold.

Python

Biopython: PDB parsing. PyMOL: Visualization. MDAnalysis: Dynamics. ProDy: Analysis. subprocess: ColabFold. Pipeline: Automate.

🐍 Biopython🐍 PyMOL🐍 MDAnalysis🐍 ColabFold

# Python Integration
print("=== Parse PDB with Biopython ===")
print(""
from Bio.PDB import PDBParser

def parse_pdb(pdb_file):
    \"\"\"Parse PDB file.\"\"\"
    parser = PDBParser()
    structure = parser.get_structure("protein", pdb_file)
    
    print(f"Model: {structure}")
    for model in structure:
        print(f"Chains: {len(model)}")
        for chain in model:
            print(f"  Chain {chain.id}: {len(chain)} residues")
            for residue in chain:
                print(f"    {residue.resname} {residue.id}")
                for atom in residue:
                    print(f"      {atom.name}: {atom.coord}")
    
    return structure

# Use
# structure = parse_pdb("1abc.pdb")
""")

print("\n=== Analyze Structure ===")
print(""
from Bio.PDB import PDBParser
import numpy as np

def analyze_structure(pdb_file):
    \"\"\"Analyze structure.\"\"\"
    parser = PDBParser()
    structure = parser.get_structure("protein", pdb_file)
    
    # Residue count
    residues = list(structure.get_residues())
    print(f"Residues: {len(residues)}")
    
    # Atoms
    atoms = list(structure.get_atoms())
    print(f"Atoms: {len(atoms)}")
    
    # CA coordinates
    ca_coords = []
    for residue in residues:
        if "CA" in residue:
            ca_coords.append(residue["CA"].coord)
    
    # Center
    center = np.mean(ca_coords, axis=0)
    print(f"Center: {center}")
    
    # Radius of gyration
    rg = np.sqrt(np.mean(np.sum((ca_coords - center)**2, axis=1)))
    print(f"Radius of gyration: {rg:.2f} Å")
    
    return structure

# Use
# structure = analyze_structure("1abc.pdb")
""")

print("\n=== PyMOL from Python ===")
print(""
import pymol
from pymol import cmd

def visualize_pymol(pdb_file, output_png="output.png"):
    \"\"\"Visualize with PyMOL.\"\"\"
    pymol.finish_launching(['pymol', '-qc'])
    
    cmd.load(pdb_file)
    cmd.show("cartoon")
    cmd.color("blue")
    cmd.bg_color("white")
    
    # Color by pLDDT
    cmd.color("red", "b < 50")
    cmd.color("yellow", "b > 50 and b < 70")
    cmd.color("green", "b > 70 and b < 90")
    cmd.color("blue", "b > 90")
    
    # Ray trace
    cmd.ray(1200, 900)
    cmd.png(output_png)
    
    print(f"Saved {output_png}")

# Use
# visualize_pymol("alphafold_model.pdb")
""")

print("\n=== Run ColabFold ===")
print(""
import subprocess

def run_colabfold(fasta_file, output_dir="colabfold_output"):
    \"\"\"Run ColabFold.\"\"\"
    cmd = [
        'colabfold_batch',
        fasta_file,
        output_dir,
        '--num-recycle', '3',
        '--num-models', '5',
        '--use-gpu-relax'
    ]
    
    result = subprocess.run(cmd, capture_output=True, text=True)
    
    if result.returncode != 0:
        raise RuntimeError(f"ColabFold failed: {result.stderr}")
    
    return output_dir

# Use
# output = run_colabfold("protein.fasta")
""")

print("\n=== Run ESMFold ===")
print(""
def run_esmfold(fasta_file, output_dir="esmfold_output"):
    \"\"\"Run ESMFold.\"\"\"
    cmd = [
        'esm-fold',
        '-i', fasta_file,
        '-o', output_dir
    ]
    
    result = subprocess.run(cmd, capture_output=True, text=True)
    
    if result.returncode != 0:
        raise RuntimeError(f"ESMFold failed: {result.stderr}")
    
    return output_dir

# Use
# output = run_esmfold("protein.fasta")
""")

print("\n=== Calculate RMSD ===")
print(""
from Bio.PDB import PDBParser, Superimposer
import numpy as np

def calculate_rmsd(pdb1, pdb2):
    \"\"\"Calculate RMSD between two structures.\"\"\"
    parser = PDBParser()
    struct1 = parser.get_structure("1", pdb1)
    struct2 = parser.get_structure("2", pdb2)
    
    # Get CA atoms
    atoms1 = [res["CA"] for res in struct1.get_residues() if "CA" in res]
    atoms2 = [res["CA"] for res in struct2.get_residues() if "CA" in res]
    
    # Superimpose
    sup = Superimposer()
    sup.set_atoms(atoms1, atoms2)
    
    print(f"RMSD: {sup.rms:.2f} Å")
    print(f"Rotation: {sup.rotran[0]}")
    print(f"Translation: {sup.rotran[1]}")
    
    return sup.rms

# Use
# rmsd = calculate_rmsd("model.pdb", "experimental.pdb")
""")

print("\n=== Complete Pipeline ===")
print(""
import subprocess
from Bio.PDB import PDBParser

def structure_pipeline(fasta_file, output_dir="structure_output"):
    \"\"\"Complete structure prediction pipeline.\"\"\"
    import os
    os.makedirs(output_dir, exist_ok=True)
    
    # 1. Predict with ColabFold
    print("Predicting structure...")
    run_colabfold(fasta_file, output_dir)
    
    # 2. Parse
    pdb_file = f"{output_dir}/model.pdb"
    parser = PDBParser()
    structure = parser.get_structure("model", pdb_file)
    
    # 3. Analyze
    residues = list(structure.get_residues())
    print(f"Residues: {len(residues)}")
    
    # 4. pLDDT
    b_factors = [atom.bfactor for atom in structure.get_atoms()]
    print(f"Mean pLDDT: {np.mean(b_factors):.1f}")
    
    print("Pipeline complete!")
    return pdb_file

# Use
# pdb = structure_pipeline("protein.fasta")
""")

⚖️ Method Comparison

🎯 Which Method?

Choosing the right structure prediction method depends on sequence identity, protein size, and available resources.

Comparison

Homology: Close homolog. Threading: Remote. Ab initio: No template. AlphaFold: Best. ESMFold: Fast. MD: Dynamics.

⚖️ Homology⚖️ Threading⚖️ AlphaFold⚖️ ESMFold

Method	Template	Accuracy	Speed	Best For
Homology	Yes (>30%)	High	Fast	Close homologs
Threading	Yes (fold)	Medium	Fast	Remote homologs
Ab initio	No	Low	Slow	Small proteins
AlphaFold2	MSA	Very high	Medium	General purpose
RoseTTAFold	MSA	High	Medium	General purpose
ESMFold	No MSA	High	Very fast	Large-scale
AlphaFold3	Complexes	Very high	Slow	Complexes, ligands
MD	Refine	Refine	Very slow	Dynamics

# Decision Guide
print("=== Choose Method ===")
print(""
Close homolog (> 30%):
  → Homology modeling
  → MODELLER, SWISS-MODEL

Remote homolog:
  → Threading
  → I-TASSER, Phyre2

No homolog:
  → AlphaFold / ESMFold
  → Ab initio

Complexes:
  → AlphaFold3
  → AlphaFold-Multimer

Large-scale:
  → ESMFold
  → AlphaFold DB

Dynamics:
  → MD (GROMACS, AMBER)
""")

print("\n=== Accuracy Comparison ===")
print(f"{'Method':<20} {'Identity':<15} {'RMSD':<15} {'Use':<20}")
print("-" * 70)
print(f"{'Homology':<20} {'> 50%':<15} {'< 1 Å':<15} {'Close homolog':<20}")
print(f"{'Homology':<20} {'30-50%':<15} {'1-3 Å':<15} {'Remote':<20}")
print(f"{'Threading':<20} {'< 30%':<15} {'3-6 Å':<15} {'Fold':<20}")
print(f"{'Ab initio':<20} {'No':<15} {'5-10 Å':<15} {'Small':<20}")
print(f"{'AlphaFold2':<20} {'Any':<15} {'< 2 Å':<15} {'General':<20}")
print(f"{'ESMFold':<20} {'Any':<15} {'< 3 Å':<15} {'Fast':<20}")

print("\n=== Speed Comparison ===")
print(f"{'Method':<20} {'100 aa':<15} {'500 aa':<15} {'1000 aa':<15}")
print("-" * 65)
print(f"{'Homology':<20} {'1 min':<15} {'5 min':<15} {'10 min':<15}")
print(f"{'Threading':<20} {'10 min':<15} {'30 min':<15} {'1 hour':<15}")
print(f"{'AlphaFold2':<20} {'10 min':<15} {'1 hour':<15} {'4 hours':<15}")
print(f"{'ESMFold':<20} {'1 min':<15} {'5 min':<15} {'20 min':<15}")
print(f"{'MD':<20} {'Hours':<15} {'Days':<15} {'Weeks':<15}")

print("\n=== When to Use Which ===")
print(""
USE HOMOLOGY:
  ✓ Close homolog
  ✓ Fast
  ✓ Accurate

USE THREADING:
  ✓ Remote homolog
  ✓ Fold recognition

USE ALPHAFOLD:
  ✓ General purpose
  ✓ Best accuracy
  ✓ Publication

USE ESMFOLD:
  ✓ Large-scale
  ✓ Fast
  ✓ No MSA

USE ALPHAFOLD3:
  ✓ Complexes
  ✓ Ligands
  ✓ Nucleic acids

USE MD:
  ✓ Dynamics
  ✓ Refinement
  ✓ Binding
""")

💼 Use Cases

🎯 Where Structure Prediction Is Used

Protein structure prediction is used in virtually every area of biology: drug discovery, disease, engineering, and more.

Use Cases

Drugs: Targets. Disease: Mutations. Design: Proteins. Antibodies: Design. Enzymes: Engineering. Variants: Interpretation.

💼 Drug discovery💼 Disease💼 Design💼 Variants

# Use Cases
print("=== 1. Drug Discovery ===")
print(""
Use case:
  - Target structure
  - Binding pockets
  - Virtual screening

Workflow:
  1. Predict structure
  2. Identify pocket
  3. Dock compounds
  4. Optimize
  5. Test

Examples:
  - Kinases
  - GPCRs
  - Proteases

Tools:
  - AlphaFold
  - AutoDock
  - PyMOL
""")

print("\n=== 2. Disease Mechanisms ===")
print(""
Use case:
  - Mutation impact
  - Stability
  - Interactions

Workflow:
  1. Predict wild-type
  2. Predict mutant
  3. Compare
  4. Assess impact

Examples:
  - Cancer mutations
  - Rare disease
  - Pharmacogenomics

Tools:
  - AlphaFold
  - FoldX
  - Rosetta
""")

print("\n=== 3. Protein Engineering ===")
print(""
Use case:
  - Novel proteins
  - Stability
  - Activity

Workflow:
  1. Design
  2. Predict structure
  3. Validate
  4. Test

Examples:
  - Enzymes
  - Antibodies
  - Biosensors

Tools:
  - RFdiffusion
  - ProteinMPNN
  - AlphaFold
""")

print("\n=== 4. Antibody Design ===")
print(""
Use case:
  - Structure prediction
  - Epitope mapping
  - Affinity maturation

Workflow:
  1. Sequence
  2. Predict structure
  3. Dock antigen
  4. Optimize

Tools:
  - AlphaFold
  - IgFold
  - ABodyBuilder
""")

print("\n=== 5. Variant Interpretation ===")
print(""
Use case:
  - Clinical significance
  - Structure impact
  - Function

Workflow:
  1. Variant
  2. Predict structure
  3. Assess impact
  4. Classify

Tools:
  - AlphaFold
  - FoldX
  - CADD
""")

print("\n=== 6. Enzyme Engineering ===")
print(""
Use case:
  - Substrate specificity
  - Catalysis
  - Stability

Workflow:
  1. Structure
  2. Active site
  3. Design
  4. Test

Tools:
  - AlphaFold
  - Rosetta
  - PyMOL
""")

print("\n=== 7. Structural Genomics ===")
print(""
Use case:
  - Many structures
  - Coverage
  - Function

Examples:
  - AlphaFold DB (200M)
  - PDB (200K)
  - Model organisms

Tools:
  - AlphaFold
  - PDB
  - UniProt
""")

print("\n=== 8. Vaccine Design ===")
print(""
Use case:
  - Antigen structure
  - Epitope
  - Design

Workflow:
  1. Antigen
  2. Structure
  3. Epitope
  4. Design

Examples:
  - SARS-CoV-2
  - Influenza
  - HIV
  - Malaria

Tools:
  - AlphaFold
  - PyMOL
  - Rosetta
""")

print("\n=== Comparison ===")
print(f"{'Use Case':<25} {'Tool':<20} {'Output':<20}")
print("-" * 65)
print(f"{'Drug discovery':<25} {'AlphaFold':<20} {'Pocket':<20}")
print(f"{'Disease':<25} {'FoldX':<20} {'Impact':<20}")
print(f"{'Engineering':<25} {'RFdiffusion':<20} {'Design':<20}")
print(f"{'Antibody':<25} {'IgFold':<20} {'Structure':<20}")
print(f"{'Variants':<25} {'CADD':<20} {'Classification':<20}")
print(f"{'Enzyme':<25} {'Rosetta':<20} {'Active site':<20}")
print(f"{'Structural genomics':<25} {'AlphaFold DB':<20} {'Structures':<20}")
print(f"{'Vaccine':<25} {'AlphaFold':<20} {'Epitope':<20}")

❓ FAQ

🎯 Frequently Asked Questions

Answers to common questions about protein structure prediction.

What is protein structure prediction?

What is the difference between homology modeling, threading, and ab initio?

Homology modeling uses a homologous template with known structure (>30% sequence identity). Threading (fold recognition) fits a sequence to known folds without close homologs. Ab initio predicts structure from sequence alone using physics or knowledge-based potentials. Modern deep learning methods (AlphaFold2) often outperform all three.

What is AlphaFold2 and how does it work?

AlphaFold2 is a deep learning system developed by DeepMind that predicts protein structures with accuracy comparable to experimental methods. It uses a transformer-based neural network with multiple sequence alignments (MSAs), template structures, and an attention mechanism to predict inter-residue distances and angles, producing highly accurate 3D models.

What is a PDB file?

A PDB (Protein Data Bank) file is the standard text format for storing 3D structural data of biological macromolecules. It contains atomic coordinates (ATOM/HETATM records), secondary structure annotations (HELIX/SHEET), and metadata. It's used by all major structural biology tools including PyMOL, ChimeraX, and Biopython.

How do I validate a predicted protein structure?

Use validation tools such as MolProbity (Ramachandran outliers, rotamers, clashes), PROCHECK, QMEAN, and ERRAT. Check pLDDT confidence scores (AlphaFold), PAE (Predicted Aligned Error), and compare with experimental data if available. Low-confidence regions often correspond to intrinsically disordered regions.

What is pLDDT and how do I interpret it?

pLDDT (predicted Local Distance Difference Test) is AlphaFold's per-residue confidence metric (0-100). Interpretation: > 90 = very high, 70-90 = confident, 50-70 = low, < 50 = very low (often disordered). Use it to identify reliable regions of the model.

What is the difference between AlphaFold2, RoseTTAFold, and ESMFold?

AlphaFold2 (DeepMind) uses MSAs and templates, achieving near-experimental accuracy. RoseTTAFold (Baker lab) uses a 3-track architecture and is also highly accurate. ESMFold (Meta) uses a protein language model without MSAs, making it much faster for large-scale predictions but slightly less accurate.

Can AlphaFold predict protein complexes?

Yes — AlphaFold-Multimer and AlphaFold3 predict protein-protein complexes, protein-nucleic acid complexes, and protein-ligand interactions. AlphaFold3 (2024) uses a diffusion-based architecture and handles a wide range of biomolecular interactions.

What is molecular dynamics and when should I use it?

Molecular dynamics (MD) simulates the time evolution of a protein using physics-based force fields. Use it for refinement, studying dynamics, binding, and folding. Tools include GROMACS, AMBER, NAMD, and OpenMM. MD is slow but provides dynamic insight that static structures cannot.

How accurate are current structure prediction methods?

For proteins with good MSAs, AlphaFold2 achieves RMSD < 2 Å for most domains, comparable to experimental structures. Accuracy decreases for proteins with few homologs, intrinsically disordered regions, and large complexes. Always check pLDDT and PAE, and validate with orthogonal methods.

# Quick Reference
print("=== Quick Answers ===")
print(""
Q: What is structure prediction?
A: Predict 3D structure from sequence.

Q: Best method?
A: AlphaFold2 / ColabFold.

Q: Homology vs threading?
A: Homology >30% identity; threading for remote.

Q: Ab initio?
A: No template; small proteins.

Q: AlphaFold confidence?
A: pLDDT, PAE.

Q: Validation?
A: MolProbity, Ramachandran, QMEAN.

Q: PDB format?
A: Standard for 3D structures.

Q: Complexes?
A: AlphaFold-Multimer, AlphaFold3.

Q: Dynamics?
A: MD (GROMACS, AMBER).

Q: Free tools?
A: Yes — AlphaFold, PyMOL, ChimeraX.
""")

🚀 Future

🎯 Where Structure Prediction Is Going

The future is complexes, dynamics, design, single-cell, and AI-driven.

Future Directions

Complexes: AlphaFold3. Dynamics: MD + AI. Design: RFdiffusion. Single-cell: Proteomics. AI: Foundation models. Clinical: Variants.

🚀 Complexes🚀 Dynamics🚀 Design🚀 AI

# Future of Protein Structure Prediction
print("=== 1. Complexes & Interactions ===")
print(""
Trend: Beyond single proteins

Current:
  - Single chains
  - AlphaFold2

Future:
  - Protein-protein
  - Protein-DNA/RNA
  - Protein-ligand
  - AlphaFold3
  - Diffusion

Tools:
  - AlphaFold3
  - RoseTTAFold All-Atom
  - DiffDock
""")

print("\n=== 2. Dynamics & Ensembles ===")
print(""
Trend: Beyond static structures

Current:
  - Single structure
  - Static

Future:
  - Ensembles
  - Dynamics
  - Conformational states

Tools:
  - AlphaFold (ensemble)
  - MD
  - AI-MD
  - Time-lapse
""")

print("\n=== 3. Protein Design ===")
print(""
Trend: Design novel proteins

Current:
  - Predict natural
  - Limited design

Future:
  - De novo design
  - RFdiffusion
  - ProteinMPNN
  - AlphaFold

Examples:
  - Enzymes
  - Antibodies
  - Vaccines
  - Biosensors
""")

print("\n=== 4. Single-Cell Proteomics ===")
print(""
Trend: Single-cell

Current:
  - Bulk
  - Average

Future:
  - Single-cell
  - Spatial
  - Proteomics

Examples:
  - Cell types
  - Tumor
  - Development

Tools:
  - AlphaFold
  - Mass spec
  - AI
""")

print("\n=== 5. AI Foundation Models ===")
print(""
Trend: Foundation models

Current:
  - AlphaFold2
  - ESMFold
  - Specialized

Future:
  - General models
  - Multi-modal
  - Protein + DNA + RNA
  - Ligands

Examples:
  - ESM-2
  - AlphaFold3
  - RoseTTAFold
  - Protein language models
""")

print("\n=== 6. Clinical Applications ===")
print(""
Trend: Clinical

Current:
  - Research
  - Specialized

Future:
  - Clinical routine
  - Variant interpretation
  - Drug response
  - Diagnostics

Examples:
  - Cancer variants
  - Rare disease
  - Pharmacogenomics
""")

# TIMELINE
print("\n=== Timeline ===")
print(""
Past:
  1950s: Folding problem
  1960s: First structures
  1970s: Anfinsen
  1980s: Homology
  1990s: CASP
  2000s: Threading
  2010s: Deep learning
  2020: AlphaFold2
  2022: AlphaFold DB
  2024: AlphaFold3

Present:
  2025: Complexes
  2026: Dynamics

Future:
  2030: Design?
  2035: Single-cell?
  2040: Predictive biology?
""")

print("\n=== Final Thoughts ===")
print(""
Protein structure prediction is:
  - Fundamental to biology
  - Revolutionized by AI
  - Needed for drug discovery
  - Needed for disease
  - Rapidly improving

The future is:
  - Complexes
  - Dynamics
  - Design
  - Single-cell
  - AI-driven
  - Clinical

"Structure is the key to function.
 Prediction is the key to structure."

Keep exploring. Keep building.
""")