Specification for Biosystems in the Presence of Unknowns
In our last post we discussed how two abstractions in L++ can be implemented to create highly specific and detailed descriptions of biosystems; however, before any design is implemented we should know how the final product should be assembled and how it should behave when it is complete. L++ allows for users to design their own specification for a biosystem before additionally building it. This allows for the inclusion of all of the chemical and molecular components required to accomplish the expected result, as well as how they will come together to build the biosystem, to be established. In order to accomplish this, it’s critical that we can understand how components come together within the system without getting bogged down in the details.
Picture the engine of a car. Even if you are not a mechanic you can specify where in the car it belongs and what its function is without knowing how every component interacts within the engine. For most drivers it is enough to know that a simple input will carry out a specific function. When we get in a car we only have to understand that turning on the ignition will allow the engine to power the car, we do not have to consider how the pistons will align to pump fuel into the engine while the spark plugs ignite the fuel to convert it to usable energy. So how do we use these same principles to create specifications for biosystems? Let’s take a look at a different kind of fuel: the fuel of a cell.
Figure 1. We design specifications for systems to designate how they should behave. The specification of a process or system shows us the expected behavior of the system given its inputs and the outputs that should be produced if it is implemented correctly. When we create a specification for a car engine, we should know where in the system of a car it belongs and what kind of output we should expect from it: the torque and power it will generate to move the car. Similarly, when we specify a biosystem like glycolysis we need only to provide the inputs of the system and the expected chemical outputs once it is carried out.
Glycolysis is a vital pathway for cells to perform in order to take in glucose from their environment and process it into a molecule that is usable for more efficient energy generation. Similar to our car engine, glycolysis has several steps that are performed before glucose can be converted into a usable fuel source for the cell. We could walk through each of the ten steps required for a cell to perform glycolysis, but when we create specifications for biosystems we do not require all of the details to understand the function of a system; instead we can look at the whole process as its inputs and outputs we get: C6H12O6 + 2 ADP + 2 NAD+→ 2 C3H3O3– + 2 ATP + 2 NADH. This equation just tells us that the mechanism used to process a single glucose molecule generates a net of 2 ATP molecules, 2 NADH molecules, and 2 Pyruvate molecules. Just like the ignition required to start an engine, it is sufficient to establish the inputs of the biosystem and what outputs we should expect from them in order to specify the pathway, and with all of the discoveries that are yet to be made in biology, this simple method for specifying biosystems in L++ allows us to do so even in the presence of unknowns.
Figure 2. Specification of the glycolytic pathway using its inputs and outputs. Glycolysis is a critical process used by many cells to convert nutrients into usable energy. In order to design it in a biologically meaningful way we only require the inputs and the outputs of the process to understand how it is supposed to function in cells.
When we write a specification for the glycolytic pathway we require only the inputs, outputs, and the concentrations of each while we let the program fill in the gaps of the intermediate steps required to carry out the process. The systems that build the processes of life are complicated and filled with components that we have not yet fully discovered or of which we still have an incomplete understanding. We are continually striving to make discoveries about the processes of life, but despite the missing pieces of the puzzle we can still generate virtual biosystems by looking at the big picture.
reaction Glycolysis(G6P + 2 ADP + 2 NAD -> 2 pyruvate + 2 ATP + 2 NADH)
specification
{
float c = 0.019M; // Glycolytic capacity
ATP’ = (ADP / ATP) * c;
}
G6P[:] = 8.8mM; // Constant G6P level
ATP = 9.6mM, ADP = 0.56mM;
NADH = 8.3mM, NAD = 2.6mM;
pyruvate = 0.39mM;
Figure 3. Specification of Glycolysis using L++ code. When programming life we use the inputs and outputs of a system to design how the system should behave when it is implemented.
The specification of biosystems using L++ allows us to examine the expected behavior and outputs independent of implementation. Recall back to our previous post, two abstractions of L++ enables the precise description of biosystems, in which we discussed how L++ allows us to generate virtual biosystems at various resolutions of life; however, while the implementation of L++ code fills in the intermediate details necessary for the system to be carried out, specification of the behavior of the system given a precise set of inputs is required to both initiate the pathway and understand that it has been carried out correctly once the outputs are provided. In the future we will release another post that discusses how we can use L++ to generate virtual biosystems in the presence of both knowns and unknowns.
0 Comments