Introduction

GRASP - Generating random alanine scanned peptides is a peptide mutator that performs conserved substitutions based on inputs from an alanine scan. This was a crucial step in significantly increasing the scope of possible mutations. Existing softwares in the domain only consider surface-level information, ignoring any conformational changes that may occur. GRASP creates combinations of conserved substitutions on selected amino acids that fall within the specified range. Then, five random sequences are chosen from the sample set created. These are then tested and subjected to further analysis. Thus, our software is a one-of-a-kind approach to automating and exponentially simplifying the process of random conserved mutations. This process can be employed to potentially increase the affinity of the peptide to its interacting ligands.

GRASP

Peptide sequence mutator through Alanine Scanning

About

For more information, refer to this page on our wiki: Engineering success
Checkout the software at: MIT_MAHE Software tools

Description

The software comprises of the following modules:

1. Alanine Scan \( \Delta \Delta G \) values BUDE Alanine scan is employed to obtain \( \Delta \Delta G \) values of each residue present in the input.

2. Conservative mutations

   Conserved mutation is a process in which mutations are made within the same type of residues.

   For example: We replaced amino acids within the same group, for example, hydrophobic re 3—hydrophobic residues with hydrophobic residues or amino acids of same charge with each other.

3. Random sampler

   Random peptides are selected as samples from the huge sequence list received to reduce the user workload. Note that this selection is pseudo-random.

Features

1. Command Line Interface (CLI) We can use the software locally on command prompt.

2. Integrable modules

   Our software consists of different modules for the mutator and alanine scan to integrate them into different and more extensive networks by other iGEM teams and parties.

3. Mutation lock To prevent the mutation of an already modified residue, that part of the sequence was put under a mutation lock

4. Aggrescan

   Inclusion of a BASH script, which takes the output and prepends FASTA headers to each sequence in the text file.

Background

Protein engineering is modifying a protein through substitution, insertion, or deletion to exhibit desired characteristics and properties.

During the process of designing our peptide, we came across the problem of having an extensive sample set of substitutions through trial and error. However, even after this, we could not guarantee an increase in affinity compared to the original peptide as needed in our case. To overcome this problem, we designed this software to provide all the most probable mutations that increase the binding affinity.

Furthermore, we explored other point mutation softwares for our problem; however, they only took surface information into consideration. We decided to take \( \Delta \Delta G \) value of a residue as the parameter for mutation which give an increase in the accuracy of the mutation.

Method

\( \Delta \Delta G \) threshold

We take \( \Delta \Delta G \)value of each residue derived from BUDE alanine scan as a parameter to do mutations. To make these mutations we set a threshold \( \Delta \Delta G \)range for each residue (in our case, 0 to 1). Only if the \( \Delta \Delta G \) value lies between this range will it be mutated.

Significance of Cartesian product

Cartesian Product: The Cartesian Product of sets \(A\) and \(B\) is defined as the set of all ordered pairs \((x, y)\) such that \(x\) belongs to \(A\)and \(y\) belongs to \(B\) For example, if \(A = {1, 2}\) and \(B = {3, 4, 5}\), then the Cartesian Product of A and B is \({(1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5)}\). Originally, during a test run, the computational time that the software took for making 3 mutation positions was 2 hours 20 mins. After incorporating the cartesian product into the mutator, the time reduced to 11 mutation positions in 10 seconds.

Algorithm

We first create a Mutater object, which support the following three formats:

1. Wild type amino acid, the position of the Amino acid, and the Mutant type it needs to be replaced with.
2. Just the Wild type amino acid and its position, without the Mutant type. This can act as the template to create new Mutater objects.
3. Just the position in the sequence.

Alanine scanning

The Alanine scanning results from BUDE Alanine scan are parsed through which results in a position array over which mutations are possibly required.

Group mutations

The sequence is taken as a template over which a special array is constructed, with the following steps:

1. Iterate over the sequence and get the wild type amino acid at each stage.
2. Retain the wild type if mutation isn't required at this position. This could result when the position doesn't want to be mutated, or when the position is present in the mutation lock array.
3. If a mutation is required in the current position, replace the position with an array of all the possible amino acids within the same group. This step is important to achieve Conserved mutations.

Cartesian product

The special array is then passed to the itertools.product() function, which evaluates the Cartesian product on the elements of the special array. This results in an iterable object that contains all the final sequences, which is then stored in the text file.

Random sample

A trivial random sampler is implemented using random.sample() on the sequences array, and then stored in a text file.