A Soliton and its owned Bions (Awareness and Mind) – part 4


5 Out-of-Body Travels

Regarding section 3.8, bions can move themselves by using the move_this_bion() learned-program statement. However, in the case of a soliton and its owned bions, it’s assumed that the computing-element program keeps a soliton and its owned bions together and limits to a short distance how far apart any of them can move away from each other. For convenience, because they are always kept together regardless of where they are, an awareness (a soliton) and its mind (that soliton’s owned bions) will often be referred to simply as awareness/mind or soliton/mind. The awareness/mind phrase emphasizes more the soliton as the seat of our consciousness, and the soliton/mind phrase emphasizes more that the seat of our consciousness is itself an intelligent particle.

This chapter considers two kinds of out-of-body experiences: lucid-dream out-of-body experiences and bion-body out-of-body experiences. The chapter sections are:

5.1 Internal Dreams and External Dreams

Dreams need no introduction, because dreaming is an experience most people have. However, there has long been the question as to the location of dreams. Some past cultures believed in a separate dream world, which exists around the dreamer, and when a person dreams, that person’s awareness/mind is moving about in that external dream world. Call this kind of dream an external dream. What is commonly known as a lucid dream, is an external dream. The alternative is that dreams are spatially confined to the dreamer’s mind: call this kind of dream an internal dream.

The mathematics-only reality model cannot explain external dreams, and according to that reality model all dreams are internal. The computing-element reality model allows both kinds of dreams, because one’s awareness/mind is not physical matter, and a running learned program is needed to keep one’s awareness/mind in one’s physical head when one is awake in one’s physical body (see the description of the learned program LP_maintain_AM_position_close_to_one_bion in section 5.2).

For an internal dream, the imagery and sounds of that dream are generated by one’s own mind, without using substantial sensory input. It is certain that the human mind can generate high-quality images and sounds without sensory input, because most people can imagine or recall low-quality (and for some people, higher or high-quality) images and sounds while awake, and psychedelics such as LSD and DMT can provoke a torrent of high-quality images while the person is awake. One’s visual imagination generates the imagery for an internal dream (see the discussion of the visual imagination in section 3.1). And, because one is asleep while having an internal dream, the generated imagery is not made faint.

I suppose that for most people, at least in terms of what they remember after they awake from sleep, internal dreaming is the rule, and external dreaming is the exception. However, given the possibility of one’s mind messaging with other minds using the learned-program send() statement, without the awareness knowing about it, a given internal dream can incorporate communicated information from other minds, without a person having any conscious knowledge of this. Thus, even an internal dream can have an external component.

5.1.1 The Soliton Directory

An obvious feature of our minds is the ability to recognize people known to us, and associated with that recognition of a person is knowledge of one’s relationship with that person. For us humans, one can assume that this recognition ability extends to send() messages received by one’s own mind from another person’s mind (in this context, “another person” is a soliton/mind other than oneself, typically but not necessarily another human). Recall that, as stated in subsection 3.8.4, every message sent by a bion includes a copy of that bion’s complete identifier block, and, if that bion is owned by a soliton, included in that bion’s identifier block is the unique identifier of that owning soliton. Within the learned programs of one’s mind, to identify the person who sent a message received by one’s mind, assume there is a lookup table named soliton directory, and its lookup_key is the unique identifier of a soliton (only one table entry per soliton). For simplicity, assume that among the learned programs of one’s mind, there is one central soliton directory, and each entry in this soliton directory, besides its lookup_key, includes the following:

  • The unique identifier of this soliton’s MESSAGING_WITH_OTHER_OWNED_MINDS bion (this bion is explained in detail further below; MESSAGING_WITH_OTHER_OWNED_MINDS is an integer constant and has a specific integer value).

  • The total_relationship_score is a signed integer. It is explained in detail further below.

  • There are probably other items in a typical entry in one’s soliton directory, such as a link to memories, if any, regarding that person; these possible other items are not considered further except to note one thing regarding memories: in general, an interaction with a person that results in substantial feedback, either positive or negative, from one’s own soliton, will have a nonzero relationship_score, either a positive or negative number, stored with the memory of that interaction, and this relationship_score is added to the total_relationship_score.

Given the importance of being able to identify a person, and also the simplicity of being able to identify a person by the unique identifier of that person’s soliton, and also the importance of the soliton—one can, if one wants, see the purpose of our universe as being a playground for all the awarenesses in existence—it may be that the data structure for the soliton directory is predefined in the computing-element program, along with supporting routines. However, beyond noting this possibility it is not considered further.

To simplify messaging between owned minds (an owned mind is the owned bions of a soliton), let’s assume that each of our minds has a single owned bion designated to both send and receive any messages between one’s own mind and any other owned mind(s) (presumably, other parts of one’s mind would construct the messages to be sent by this bion, and process any messages received by this bion). Also, regarding subsection 3.8.1 and the user-settable identifiers block, let’s assume that in the case of owned bions, the integers of the user-settable identifiers block are used to subdivide one’s mind into different functional parts, and let’s assume that this single bion in one’s mind that will send/receive any messages between one’s own mind and any other owned mind(s) is identified in one’s mind by having the first integer in its user-settable identifiers block, USID_1, set to MESSAGING_WITH_OTHER_OWNED_MINDS, and no other bion in one’s mind has the first integer in its user-settable identifiers block, USID_1, set to MESSAGING_WITH_OTHER_OWNED_MINDS.

With the assumptions of the previous paragraph, define the phrase owned-minds broadcast message as being any message sent by the send() statement that identifies the intended recipient(s) of that message by setting the user_settable_identifiers_block parameter as follows: the first integer in user_settable_identifiers_block is set to MESSAGING_WITH_OTHER_OWNED_MINDS and the other integers are set to null. When an owned-minds broadcast message is sent, each owned mind within range of that sent message, assuming its MESSAGING_WITH_OTHER_OWNED_MINDS bion is awake, will receive that sent message (the range of a sent message is determined by that sent message’s message_instance.send_distance value).

Thus, by sending an owned-minds broadcast message, an owned mind can send a message to all the other owned minds that are within range of that sent message, regardless of whether or not the sending owned mind currently knows anything about the within-range recipient(s) of that sent message. In effect, among other things, the owned-minds broadcast message is a way to initiate contact with strangers (in this section, a stranger is any soliton/mind for which there is no entry in one’s soliton directory). Whether or not a stranger replies back in some way to one or more received owned-minds broadcast messages, depends on the stranger’s reaction, if any, to those messages.

As a specific example of how owned-minds broadcast messages can be useful during the lucid-dream stage of the afterlife (section 6.3), a given person who wants to speak to, or sing to, or generate music for, a nearby audience which may include strangers, can send a stream of short-range owned-minds broadcast messages with enough range to cover that intended audience. However, note that, in general, there is no guarantee that the sent owned-minds broadcast messages will be consciously listened to by any of the recipients, because that depends on the recipients.

In general, when a message is received by one’s mind from the owned mind of another person, regardless of whether or not that received message is an owned-minds broadcast message, assume that the initial processing of that received message includes a search of one’s soliton directory for the unique identifier of that person’s soliton. If found, then that person is identified and the other data stored in that soliton-directory entry for that person can be referenced and/or used as needed when processing that received message. However, if there is no entry in one’s soliton directory for that person, then assume that there is an initial step that decides whether or not this received message should be discarded, by using the value of distance_between_sender_and_receiver that was computed for that message when it was received (see the code for examine_a_message_instance() in subsection 3.8.5). In this context, distance_between_sender_and_receiver is the distance between that sender’s soliton/mind and one’s own soliton/mind. If distance_between_sender_and_receiver is a far distance, then that is a good reason to discard that received message, especially if that received message is an owned-minds broadcast message. But if that distance_between_sender_and_receiver is a very short distance, then that would be a good reason to, in effect, consider that received message further by examining its message text.

Assuming there is no entry in one’s soliton directory for the person who sent that received message, and that received message was not discarded by the initial step described in the previous paragraph, then the learned program that manages one’s soliton directory can add that person’s soliton to one’s soliton directory if there is sufficient accumulated feedback from one’s own soliton that justifies doing so (accumulated feedback from one’s own soliton that would result in either a sufficiently large enough positive or negative number being the starting value of the total_relationship_score for that person’s entry in one’s soliton directory if that entry were made).

For example, if during the lucid-dream stage of the afterlife one is consciously listening to a stranger who is sending a stream of owned-minds broadcast messages, and one consciously likes what that stranger is sending (for example, it could be a lecture by that stranger, or singing, or music), then, if one’s accumulated conscious reaction to that stranger is strong enough (for example, after listening for a while to that lecture, singing, or music), then the learned program that manages one’s soliton directory will make an entry in one’s soliton directory for that stranger, at which point that stranger will no longer be a stranger. Note: to make an entry in one’s soliton directory, besides having an initial value for the total_relationship_score, the unique identifier of that stranger’s soliton and the unique identifier of that stranger’s MESSAGING_WITH_OTHER_OWNED_MINDS bion are also needed, and both of these unique identifiers are in each of the received messages from that stranger, in the message_instance.sender’s_identifier_block (the stranger’s MESSAGING_WITH_OTHER_OWNED_MINDS bion is the bion that sent those received messages, and its identity as a MESSAGING_WITH_OTHER_OWNED_MINDS bion can be confirmed by checking the USID_1 value of the user-settable identifiers block in that message_instance.sender’s_identifier_block, the integer value of which should be MESSAGING_WITH_OTHER_OWNED_MINDS).

Another example regards the people one encounters during one’s physical human life: If one has conscious interactions with a person who is not currently in one’s soliton directory, and one’s accumulated conscious interactions with that person has resulted in a large enough positive or negative total_relationship_score for that person to be added to one’s soliton directory, then perhaps the human mind has a learned program that will send a short-range owned-minds broadcast message when that other person is nearby, asking, in effect, for that other person’s mind to send a reply message. And if one’s mind then receives that wanted reply message from that person, then the learned program that manages one’s soliton directory would then make an entry in one’s soliton directory for that person.

Besides having programming for adding a new entry, the learned program that manages the soliton directory would also have programming to delete an older entry when room is needed to add a new entry. I don’t know how many entries that managing learned program allows in the soliton directory before it will delete an older entry, but my guess is a soliton-directory size that can hold many thousands of entries. Regarding the algorithm for selecting among all the entries in the soliton directory which one to delete, my guess is that this algorithm considers several factors, including but not limited to how old an entry is, what its total_relationship_score is, and how long ago was the last significant update to that total_relationship_score. For a typical person one’s soliton directory probably includes many people from their everyday lives, such as one’s parents, one’s children if any, other relatives of significance, friends, workplace acquaintances, perhaps one or more persons currently deceased, and perhaps one or more non-human animals that have a soliton/mind, such as one’s pet dog or pet cat if any.

For each entry in one’s soliton directory, representing a specific soliton/mind: Its total_relationship_score represents in a single number a summation of how that soliton/mind has interacted with one’s own soliton/mind over the duration of that entry. Each time one’s soliton/mind has an interaction with that other soliton/mind, and that interaction gets a conscious reaction from oneself (a reaction from one’s soliton), the learned program that manages one’s soliton directory either adds to (if a positive conscious reaction from one’s soliton) or subtracts from (if a negative conscious reaction from one’s soliton) that total_relationship_score, and that number that is added or subtracted is proportional to how good or bad respectively one consciously reacted to that interaction. Thus, that total_relationship_score, whether positive or negative and by how much, summarizes in a single number past relations with that soliton/mind, and can be the basis for either wanting to continue with, or wanting to avoid, future relations with that soliton/mind if there is that opportunity in one’s next human life, even though one’s mind after reincarnation may no longer have any memory of past-life events that contributed to that total_relationship_score for that soliton/mind.

In subsection 5.2.1, the soliton directory is used by one’s soliton/mind during a lucid dream to locate and move to where a soliton/mind known to oneself is, and after the death of one’s physical body this ability will also be useful during the lucid-dream stage of the afterlife (section 6.3), because one can reunite in the afterlife with important persons to oneself who are also currently in the lucid-dream stage of the afterlife and have yet to reincarnate. Also, I see no reason for one’s soliton directory to have its entries deleted just because one has lost one’s physical body (has died) or has reincarnated in a new physical body. Instead, just specific additions to, and deletions from, one’s soliton directory over the course of time, without regard to any of the major transition points in one’s life cycle, such as the death of one’s physical body, one’s time in the afterlife, and one’s reincarnation. And, for this reason, one’s association with a particular person (soliton/mind) can span across several lifetimes or even many lifetimes.

Also, in general, memories are deleted from memory storage over time, to make room for new memories, and a lot of this memory loss probably happens for a typical person around the time of reincarnation to make room for new memories in the new life. In addition, a lot of this memory loss is probably already happening during the lucid-dream stage of the afterlife, because that is a new life unto itself with its own need for new memories in a very different environment than when one was physically embodied in the physical world. The lucid-dream stage of the afterlife may be when one forgets the majority of one’s memories of one’s physical life. And, soon after reincarnating, is probably when a typical person loses his memories of his time in the afterlife and also loses whatever remains of his memories of his previous life in a physical body.

As long as a person’s entry remains in one’s soliton directory, the total_relationship_score for that person is a summary of one’s past experiences with that person, and this will be useful after the loss of past-life memories, because there is always the possibility of reencountering that person’s soliton/mind sometime in the future when one is again in physical embodiment or again in the lucid-dream environment. Also, a future reencounter can be planned: For example, two persons who have a large positive total_relationship_score for each other, could agree in the afterlife to meet again when they are both human again, and then each of them chooses parents so that they will both live in the same country and speak the same language, and then it is up to their unconscious minds to arrange, sometime in the future, a physical meeting between the two. However, because human life, in general, is filled with so much unpredictability, including the possibility of hazards and circumstances beyond one’s control, an actual physical meeting between the two might not actually happen, regardless of what they agreed to before reincarnating. A more certain way to guarantee a physical meeting in the next human life is to reincarnate into a family or extended family, as siblings or close relatives, but this option, unless the culture allows it (such as cousin marriages in some cultures), would not be the choice of married couples or lovers who want to become again with each other a married couple or lovers.

5.1.2 External Dreams aka Lucid Dreams

Briefly, what happens during an external dream, also known as a lucid dream (“lucid” because one is fully conscious during a lucid dream), is that one’s soliton/mind leaves behind, temporarily, both one’s physical body and also all the cell-controlling bions of one’s physical body. In this separated state, one’s soliton/mind can move freely in any direction, at various speeds including very fast, and can also locate and move to where other persons who are currently also just a soliton/mind are, so as to interact with them, and can also locate and move back to one’s physical body at the end of the lucid dream.

The primary interaction with others during a lucid dream is talking with them, and even though one typically sees an appearance of the other person or persons as dressed humans, that appearance is mostly static with little or no movement of that appearance (for example, while one hears someone in front of oneself talking to oneself, there is no seen movement in their apparent face (no moving of the mouth or lips). Thus, one can assume that talking and being talked to during a lucid dream is just direct communication between minds using the learned-program send() statement. What is heard as one’s own talking and the talking of others sounds to one’s awareness very much like talking with another person when in our physical bodies. However, because the lucid-dream environment is so very different from being in one’s physical body, there is no danger during a lucid dream of thinking that one is in one’s physical body just because lucid-dream conversations sound the same as when conversing in one’s physical body. In terms of the messages one’s mind sends to the soliton (awareness) during a lucid-dream conversation, the final construction of those messages is probably using the same learned programs that are used to communicate to the awareness conversations when in one’s physical body.

Regarding what is seen during a lucid dream, both based on my own experience with lucid dreaming and also the written experiences of other lucid dreamers, it really does seem that the world of lucid dreaming has its own class of common particles that are very different than the common particles of our physical world. For convenience, call the common particles of physics p-common particles (this includes both the elementary particles of physics such as electrons, quarks, and photons, and also for convenience the atoms of physical matter), and call the common particles observed during a lucid dream d-common particles. These d-common particles do not interact with p-common particles, and these two classes of common particles are, in effect, invisible to each other (invisible to each other because the computing-element program has no programming to interact p-common particles with d-common particles; the one exception would be gravity assuming d-common particles have a nonzero mass). In terms of what can be seen, the lucid-dream world and the physical world are separate from each other, but the lucid-dream world that we humans have access to, exists in the same large volume of space that our physical world exists in, since both d-common particles and p-common particles are just data manipulated by the computing elements, and the computing elements themselves are the space in which both common particles and intelligent particles exist.

Regarding d-common particles, my own experience and the experience of other lucid dreamers is that our minds, based on what is seen and experienced during a lucid dream, can directly see and, in effect, both create and destroy objects composed of d-common particles (my vision during lucid dreaming was always in color, and overall the lucid-dream world is colorful, and both the man-made objects and the appearances of others always looked smooth and continuous and were never grainy looking). Thus, there are learned-program statements that can see, create, destroy, and manipulate d-common particles. The rule given in subsection 3.8.7, besides applying to physical atoms, also applies to d-common atoms:

The distance at which a bion can directly manipulate one or more d-common atoms by calling a learned-program statement, cannot exceed the maximum distance at which that bion can directly see any and all of the d-common atoms surrounding that bion by calling the get_relative_locations_of_d_common_atoms() learned-program statement.

Subsection 3.8.7 also gives reasons for why the learned-program statements for directly seeing and manipulating physical matter have a very short range estimated by me as being less than one-tenth of a millimeter (less than 1/250th of an inch). In all my lucid dreams, which typically included seeing other people, I always just assumed that the size of the persons that I was seeing was the same size as their physical bodies (or, in the case of seeing someone currently dead, assuming that their seen appearance had the same size that their physical body had). However, after all the thinking that went into subsection 3.8.7 regarding the reasons for a limited range for seeing p-common atoms (physical atoms), and realizing there would also be a limited range for seeing d-common atoms, it occurred to me that because the only part of myself that was present in a lucid dream was my soliton/mind—the intelligent particles of which, are, in effect, confined to a sphere of about an inch in diameter—that perhaps when I was seeing the appearance of another person in a lucid dream—assuming that appearance was constructed from d-common atoms by that person’s mind—that that seen appearance was only a few inches in height or perhaps substantially less than that.

Let get_relative_locations_of_d_common_atoms() be the learned-program statement for seeing d-common atoms. What is the maximum distance at which a bion can see d-common atoms by calling get_relative_locations_of_d_common_atoms()? In a lucid dream one can see at a good distance from oneself, and if a seen person in a lucid dream has the same height as their physical body, then my very rough estimate is that one can see in a lucid dream out to a distance of about 100 feet (about 30 meters). However, the actual size of the persons seen in a lucid dream may be much smaller than the size of their physical bodies. For the sake of being able to compute some numbers and compare d-common atoms with physical atoms, let’s consider two different values for the maximum distance at which a bion can see d-common atoms by calling get_relative_locations_of_d_common_atoms():

  • 100 feet: This assumes that a seen person in a lucid dream has the same height as their physical body.

  • 1 foot: This assumes that a seen person in a lucid dream has a height that is only 1/100th the height of their physical body.

In either case, because even the shorter distance of 1 foot is much greater than the maximum distance at which a bion can see physical atoms by calling get_relative_locations_of_physical_atoms(), and given subsection 3.8.7, it follows that in a given volume of space on our Earth, many more physical atoms can fit in that volume of space than d-common atoms. Presumably, a d-common atom, like a low-energy physical atom, is, at any instant in time, just data in a single computing element (note that in a given “instant in time”, the computing element currently holding the data of an atom may be in the process of transferring that atom’s data to an adjacent computing element, moving that atom thru space). Also presumably, the computing-element program limits how close together any two d-common atoms can be, with the end result that a lot more physical atoms can fit in a given volume of space than d-common atoms.

Comparing d-common atoms with physical atoms, one can approximate the difference between how closely d-common atoms can be packed together, and how closely physical atoms can be packed together, as follows: Assume 1/250th of an inch is how far distant from the calling bion that physical atoms can be, and still be seen by calling the get_relative_locations_of_physical_atoms() learned-program statement. And assume either 1 foot or 100 feet (the two cases given above) is how far distant from the calling bion that d-common atoms can be, and still be seen by calling the get_relative_locations_of_d_common_atoms() learned-program statement. Also, the volume of 3D space viewed by these atom-seeing learned-program statements is—given the message-transmission algorithm in subsection 3.8.5—the volume of a sphere.

The volume of a sphere is the cube of the radius, times a small constant (approximately 4.19) which we will ignore here. For the three distances given in the previous paragraph, 1/250th of an inch, 1 foot which is 12 inches, and 100 feet which is 1200 inches, the three volumes, measured in cubic inches, are (1 ÷ 250)3, (12)3, and (1200)3, respectively, which is 0.000000064, 1728, and 1,728,000,000, respectively. Regarding the limit—1/250th of an inch—on how far away physical atoms can be from the calling bion and still be seen by calling get_relative_locations_of_physical_atoms(), and also regarding the limit—either 1 foot or 100 feet—on how far away d-common atoms can be from the calling bion and still be seen by calling get_relative_locations_of_d_common_atoms(): If we assume that the reason for these two distance limits is the limited computation speed of a computing element and the need to avoid being overwhelmed by too many replies in too short a time, then, because the total number of replies to the sent message is, at most, the total number of atoms—either physical atoms in the case of calling get_relative_locations_of_physical_atoms(), or d-common atoms in the case of calling get_relative_locations_of_d_common_atoms()—in the spherical volume of space reached by that sent message, then one can conclude the following: If the maximum distance at which a bion can see d-common atoms by calling get_relative_locations_of_d_common_atoms() is 1 foot, then, in a given volume of space in our world, about (1728 ÷ 0.000000064) = 27 billion (2.7×1010) times more physical atoms can fit in that volume of space than d-common atoms. And if instead the maximum distance at which a bion can see d-common atoms by calling get_relative_locations_of_d_common_atoms() is 100 feet, then, in a given volume of space in our world, about (1,728,000,000 ÷ 0.000000064) = 27 million billion (2.7×1016) times more physical atoms can fit in that volume of space than d-common atoms.

To operate fully in the lucid-dream world, one’s mind needs several different learned programs that together do the following:

  • See objects composed of d-common atoms by calling get_relative_locations_of_d_common_atoms() many times per second and construct from each call an image that can be sent to the soliton so that one can consciously see.

  • To be seen, use the learned-program statements for creating and/or manipulating d-common atoms to construct a visual appearance for oneself out of d-common atoms when in the presence of one or more other persons who are also using the get_relative_locations_of_d_common_atoms() learned-program statement to see the lucid-dream world.

  • Move to where a person known to oneself is, who is also currently operating in the lucid-dream world (a procedure for doing this is detailed in subsection 5.2.1).

Based on my own experience with lucid dreams, the lucid-dream world is devoid of lower forms of life: no trees or plants to see, no birds or insects to see, no fish or small animals to see. Perhaps the computing-element program only allows the mind of a soliton/mind—in other words, only allows owned bions—to call the learned-program statements for seeing, creating, destroying, and manipulating d-common atoms. In my approximately 400 lucid-dream projections, only in one lucid dream did I see a non-human animal, a tiger, mentioned in section 10.1. Although I had encountered two different pet cats during a few of my bion-body projections (at the time of each encounter, both that pet cat and myself were living in the same house; see subsection 5.2.2 and section 10.1 for some detail of those pet-cat encounters), I never encountered any pet cats during my lucid-dream projections. Perhaps the pet-cat mind lacks one or more of the learned programs needed to fully operate in the lucid-dream world, or alternatively, because there is a lot of self-segregation that goes on in the lucid-dream world, even if pet cats have the learned programs needed to fully operate in the lucid-dream world, it may be that they only move to where other such cats are, and present their constructed appearance there.

My guess is that most if not all humans have the learned programs needed to fully operate in the lucid-dream world, but for those other animal species whose members each have a soliton/mind, with the exception of that one tiger encounter, I don’t know. The answer to this question about the presence or absence of other animal species in the lucid-dream world is probably an ongoing question that is answered in the lucid-dream stage of the afterlife for any humans curious about it, because the currently dead human inhabitants who live there full-time, typically for many years before they reincarnate, are free to roam about looking for other animal species in the lucid-dream world, and they are free to report their findings to others who are interested in this question. In fact, it is probably standard lore in at least some of the human lucid-dream afterlife societies as to which kinds of animals if any are also in the lucid-dream world and what kind of interactions if any are possible with them or are reported to have happened with them. Also, regarding the Caretakers (section 7.6), if one assumes that the life cycle of a Caretaker includes a stage without its bion-body where it’s just a soliton/mind for an extended period of time before reincarnating into a new bion-body, then that standard lore may also include accounts of interactions with Caretaker afterlife societies in the lucid-dream world.

5.2 Movement when Out-of-Body

During both lucid dreams (section 5.3) and bion-body projections (section 5.4), one’s awareness/mind is often moving in 3D space, being able to move in any direction, and moving at a variety of speeds that range from very slow to very fast, and these movements, when they happen, can be consciously decided or unconsciously decided. What I am saying here about movement during lucid dreams and bion-body projections is based on my own experience, although the same is said about these movement abilities by others in the out-of-body projection literature.

I say in chapter 10 that I’ve had about five hundred out-of-body projections, about four-fifths were lucid dreams during which my awareness/mind was separate from my physical body, and about one-fifth were bion-body projections during which my awareness/mind was separate from my physical body but was situated in the head of a ghost-like body that was shaped like my human body. I am confident that that ghost-like body was composed of cell-controlling bions temporarily withdrawn from cells in my physical body, because during those bion-body projections I was often fully conscious both when that ghost-like body withdrew from my physical body and later when that ghost-like body reentered my physical body ending that out-of-body experience (I also experienced during many of my bion-body projections the brief returns to the physical body that other bion-body projectionists have explained as a recharging of the projected body so that the projection could continue, which I explain in subsection 5.2.3 as being the return to their cells of those cell-controlling bions in the projected bion-body whose allowed time away from their cells is over or will soon be over, and their replacement with other cell-controlling bions that can currently leave their cells and join the projected bion-body).[35]

Regarding awareness/mind movement when out-of-body, how is this movement coordinated between a soliton and its owned bions: Because the programming of our minds is divided into different functional parts, there is probably a separate group of owned bions in one’s mind whose learned programs are specialized to handle awareness/mind movement, with one or more of those bions using the move_this_bion() learned-program statement to, in effect, move the awareness/mind. When out-of-body, those learned programs take into account different inputs including what the soliton wants in terms of movement (thus, sometimes one has conscious control over one’s movement out-of-body and sometimes one doesn’t).

Among the learned programs that handle awareness/mind movement, there is a learned program that keeps our awareness/mind within our physical head when we are awake in our physical body, and this same learned program also keeps our awareness/mind within our bion-body head during a bion-body projection. For convenience because it is referenced further below, this learned program is named LP_maintain_AM_position_close_to_one_bion (LP is short for learned program, and AM is short for awareness/mind). When running, this learned program, whose input is the unique identifier of a bion, calls many times per second the get_relative_location_of_bion_uid() statement (detailed in subsection 5.2.1), and depending on the returned distance and direction to that bion, one’s awareness/mind is moved closer to that bion as needed so as to stay very close to that bion (by “very close” my guess is a distance of less than a millimeter, which is less than 1/25th of an inch). Regarding when LP_maintain_AM_position_close_to_one_bion is running:

  • When one is awake in one’s physical body: As a rule, this learned program is always running in the background when one is awake in one’s physical body, so as to keep one’s awareness/mind in the same location in one’s physical head regardless of how one’s physical body is moving or being moved. The selected bion to stay very close to will probably be a cell-controlling bion of a small brain-cell whose position in the brain places it at about the midpoint in one’s head, perhaps a few inches back from the midpoint between one’s eyes.

  • When one is projected in a bion-body: As a rule, this learned program is always running in the background during a bion-body projection, so as to keep one’s awareness/mind within one’s bion-body head regardless of how one’s bion-body is moving or being moved. The selected bion to stay very close to will be a bion that is a part of that projected bion-body’s head.

  • When one is projected in a lucid dream: As a rule, this learned program is not running during a lucid dream, except at the very end of a lucid dream when one has returned close to one’s physical body and one’s awareness/mind is going to reenter and stay in one’s physical head. The selected bion to stay very close to will probably be the same bion that was last used by this learned program as its input when one was awake in one’s physical body.


footnotes

[35] The various molecules of a cell are more or less stable. Thus, typically, a cell without its bion soon reaches a mostly stable state where chemical reactions cease, and the structure of the cell just before that bion’s departure remains mostly unchanged—succumbing only slowly to environmental stresses from outside the cell. This quasi-stability means that a bion can leave its cell for at least a short time, and, upon return, find its cell in much the same state as when it left that cell (in effect, a bion also “leaves” its cell each time it sleeps—see section 9.3—and this periodic sleeping of a cell’s bion has probably been a contributing factor in the evolution of the cell’s stability).

However, because there is so much interdependency in the human body, subpar performance by cells whose bions are absent—depending on how many bions are absent, for how long, and from which cells—could have a cascading effect that ultimately causes sickness or possibly even death. It seems that to avoid these dangers, the bions are, in effect, collectively careful about staying with their cells in the physical body. For the typical person who has bion-body projections, the bions in their projected bion-body apparently maintain comfortable safety margins limiting how long they are away from their cells.


5.2.1 Out-of-Body Movement during a Lucid Dream

Regarding out-of-body movement during a lucid dream, in my own case a typical lucid dream involved rapid moves to different locations where at each location I would stop and interact, often by telepathic talking, with one or more persons who were at that location, and, like myself, those persons were just their awareness and mind (they, and I presume myself, typically looked like dressed people, but this was just a constructed appearance, constructed by our minds, explained in section 5.3). The question is, how is this navigation done, knowing which direction in 3D space to move so as to get to where another person is, and also, at the end of the lucid dream, knowing which direction to move so as to get back to one’s physical body? The answer is already in subsection 3.8.6 with the learned-program statement get_relative_locations_of_bions() and its two supporting routines reply_to_this_location_request_bions() and process_a_location_reply_from_a_bion(): one can make minor changes to the code for get_relative_locations_of_bions() and its two supporting routines, to get a new learned-program statement get_relative_location_of_bion_uid() with its supporting routines reply_to_this_location_request_bion_uid() and process_location_reply_from_bion_uid(), and also add the following code to the examine_a_message_instance() routine in subsection 3.8.5 to call these two supporting routines:

if message_instance.special_handling_locate is GET_LOCATION_OF_BION_UID
and this_CE is currently holding a bion  /* It’s okay if this bion is asleep: if this bion is the wanted recipient, then want its location regardless of whether it is asleep or not. */
and that bion qualifies as a recipient of the message  /* Examine the message_instance and also that bion’s identifier block to determine this. */
then
reply_to_this_location_request_bion_uid(message_instance)
return  /* exit this routine */
end if

if message_instance.special_handling_locate is LOCATION_REPLY_FROM_BION_UID
and this_CE is currently holding a bion that is not asleep
and that bion qualifies as a recipient of the message  /* Examine the message_instance and also that bion’s identifier block to determine this. */
then
process_location_reply_from_bion_uid(message_instance)
return  /* exit this routine */
end if

The get_relative_location_of_bion_uid() statement has two parameters: the first parameter is bion_uid which is an integer and its value should be the unique identifier of a bion, and the second parameter is use_this_send_distance. If a call of get_relative_location_of_bion_uid() is successful—which means that in the time allowed to receive a reply, a location reply was received by the supporting routine process_location_reply_from_bion_uid(), and that reply’s message_instance.sender’s_identifier_block shows that this reply is from the bion whose unique identifier is bion_uid—the call returns three things (the same three things that get_relative_locations_of_bions() returns in each entry of its returned nearest-recipients list):

  • The replying bion’s identifier block (this returned identifier block is a copy of the message_instance.sender’s_identifier_block).

  • The replier’s_XYZ_relative_to_000, which, in effect, is a vector that points in the direction to that replying bion (this vector’s tail-point is (0, 0, 0) and its head-point is the returned replier’s_XYZ_relative_to_000).

  • The distance to that replying bion, which is simply the computed distance, using the distance formula, between XYZ coordinate (0, 0, 0) and the replier’s_XYZ_relative_to_000.

For the get_relative_location_of_bion_uid() statement, MAX_SEND_DISTANCE_ALLOWED_FOR_LOCATING_BION_UID is the maximum use_this_send_distance value allowed, and this maximum, based on what can be done in a lucid dream, is a distance of at least several thousand miles. In comparison, the maximum use_this_send_distance value allowed for get_relative_locations_of_bions() is MAX_SEND_DISTANCE_ALLOWED_FOR_LOCATING_BIONS which is estimated at 10 feet.

During a lucid dream, to move to where some other awareness/mind is, one’s mind probably has a learned program whose basic procedure looks like the following:

  1. Initialize list_of_solitons_out_of_reach to empty.

  2. Given the soliton directory, and avoiding any solitons currently in the list_of_solitons_out_of_reach, decide on which soliton to visit (this decision process would presumably include messaging with that soliton’s mind to determine if it is currently projected and can be visited in a lucid dream). If no soliton is selected to be visited, for whatever reason, then exit this procedure returning “failure”.

    If a soliton was selected to be visited, then for the two parameters of get_relative_location_of_bion_uid(), set bion_uid to the unique identifier of that soliton’s MESSAGING_WITH_OTHER_OWNED_MINDS bion, and set use_this_send_distance to MAX_SEND_DISTANCE_ALLOWED_FOR_LOCATING_BION_UID.

  3. Call get_relative_location_of_bion_uid(). If the call failed, then add the selected soliton to the list_of_solitons_out_of_reach, and then go to step 2; otherwise, this call was successful, and in the following steps, “returned distance” and “returned direction” refer to those two returns from this successful call (the also returned identifier block is not used in this procedure).

  4. The returned distance is the distance to the bion whose unique identifier is bion_uid (this bion is referred to simply as “that bion” in the remainder of this procedure). However, because that bion is owned by a soliton, and a soliton and its owned bions are always kept very close together by the computing-element program, the returned distance is also the distance between one’s own awareness/mind and the awareness/mind to be visited. If the returned distance is close enough to that bion (my guess is that “close enough” is being within 10 feet or so of that bion), then stop moving and exit this procedure returning “success”.

    (When this procedure exits with “success”, I expect that one or more other learned programs take over to adjust one’s position relative to the surrounding environment which includes the awareness/mind to be visited but may also include other persons nearby and/or various lucid-dream objects (in this lucid-dream context, “person” means an awareness/mind). Based on my own experience with lucid dreaming, as a rule after moving to a new location where one or more persons were, I was always positioned level with them and just a few feet from the nearest person which as a rule was the person with whom I then interacted with, such as by conversing with that person telepathically. And thinking about it now, it makes sense that, with regard to this procedure, that nearest person was the person to be visited.)

    Depending on the returned distance, set as needed how fast to move towards that bion, and move towards that bion in the returned direction, using the awareness/mind’s movement ability.

  5. Given the returned distance and how fast one’s awareness/mind is moving towards that bion, compute the estimated time to reach that bion. Then wait a fraction of that estimated time—a fraction close to, but less than 1 (for example, 97/100ths would be good)—before doing step 6 (one reason to wait a fraction of that estimated time is because, in general, the further away one is from that bion, the less accurate the returned direction will be in terms of pointing exactly at that bion; another reason is possible inaccuracies in the estimated time to reach that bion).

  6. Set use_this_send_distance to ((1 − (the fraction used in step 5)) × (the returned distance) × (a small safety factor such as 2)).

    Note that (1 − (the fraction used in step 5)) × (the returned distance) is an estimate of the distance remaining to reach that bion. The reason for the small safety factor is because of the inaccuracies mentioned in step 5 and also the possibility that that bion—more specifically with regard to lucid dreaming, that the awareness/mind to be visited—is moving in some direction at a speed that introduces a substantial error in the estimate of the distance remaining to reach that bion. My guess is that a safety factor of 2 is sufficient to avoid a failed call at step 3. Also, if one assumes that communication with the awareness/mind to be visited preceded trying to visit that awareness/mind, and this communication included getting an okay from that awareness/mind about being visited, then that awareness/mind is not going to be doing any substantial movements while it awaits that visit which should happen shortly.

    Go to step 3.

At the end of a lucid dream, to return to one’s physical body, one’s mind probably has a learned program whose basic procedure looks like the following:

  1. For the two parameters of get_relative_location_of_bion_uid(), set bion_uid to the unique identifier of one of the brain bions in one’s physical body (for simplicity, this can be the same brain bion that was the most recent input for the learned program LP_maintain_AM_position_close_to_one_bion when one was awake in one’s physical body), and set use_this_send_distance to MAX_SEND_DISTANCE_ALLOWED_FOR_LOCATING_BION_UID.

  2. Call get_relative_location_of_bion_uid(). If the call failed: if the value of use_this_send_distance is not MAX_SEND_DISTANCE_ALLOWED_FOR_LOCATING_BION_UID, then set use_this_send_distance to MAX_SEND_DISTANCE_ALLOWED_FOR_LOCATING_BION_UID and do this call over again; otherwise, this call failed even though the value of use_this_send_distance was MAX_SEND_DISTANCE_ALLOWED_FOR_LOCATING_BION_UID, so in this case exit returning “max distance failed”.

    (When this procedure exits with “max distance failed”, then one or more other brain bions can be tried, and if that also fails, then perhaps MAX_SEND_DISTANCE_ALLOWED_FOR_LOCATING_BION_UID is less than the diameter of the Earth and one’s awareness/mind is simply too far away from one’s physical body. If trying a few other brain bions has also failed, then one’s awareness/mind can try moving far distances in different directions, staying close to the Earth’s surface—after each long-distance move of one’s awareness/mind, go to step 1 and repeat this procedure to locate the given brain bion—until success is attained. If still no success, then at some point I guess one’s awareness/mind gives up and stops trying to return to one’s physical body. Whether or not this kind of failure ever happens, I have no way of knowing, since all those who talk or write about their lucid dreams were able to return to their physical bodies successfully, and in my own case, I was never consciously aware of any problems getting back to my physical body.)

    This call was successful, and in the following steps, “returned distance” and “returned direction” refer to those two returns from this successful call (the also returned identifier block is not used in this procedure).

  3. The returned distance is the distance to the bion whose unique identifier is bion_uid (this bion is referred to simply as “that bion” in the remainder of this procedure). If the returned distance is close enough to that bion (my guess is that “close enough” is being within a few feet of that bion), then stop moving and exit this procedure returning “success”.

    (When this procedure exits with “success”, the learned program LP_maintain_AM_position_close_to_one_bion, which was described earlier above, is run with its input being the unique identifier of a brain bion that is near the center of one’s physical head.)

    Depending on the returned distance, set as needed how fast to move towards that bion, and move towards that bion in the returned direction, using the awareness/mind’s movement ability.

  4. Given the returned distance and how fast one’s awareness/mind is moving towards that bion, compute the estimated time to reach that bion. Then wait a fraction of that estimated time—a fraction close to, but less than 1 (for example, 97/100ths would be good)—before doing step 5 (one reason to wait a fraction of that estimated time is because, in general, the further away one is from that bion, the less accurate the returned direction will be in terms of pointing exactly at that bion; another reason is possible inaccuracies in the estimated time to reach that bion).

  5. Set use_this_send_distance to ((1 − (the fraction used in step 4)) × (the returned distance) × (a small safety factor such as 2)).

    Note that (1 − (the fraction used in step 4)) × (the returned distance) is an estimate of the distance remaining to reach that bion. The reason for the small safety factor is because of the inaccuracies mentioned in step 4 and also the possibility that that bion—more specifically with regard to the purpose of this procedure, that one’s physical body—is moving in some direction at a speed that introduces a substantial error in the estimate of the distance remaining to reach that bion. My guess is that a safety factor of 2 is sufficient to avoid a failed call at step 2.

    Go to step 2.

5.2.2 Vision and Movement during my Bion-Body Projections

The raw data for vision during a lucid dream is provided by one’s mind calling get_relative_locations_of_d_common_atoms(), and the raw data for vision during a bion-body projection is provided by one’s mind calling get_relative_locations_of_bions(). In both vision cases, for the images constructed and ultimately sent to one’s soliton so that one can consciously see: those d-common atoms or bions respectively that are too close to whichever bion in one’s mind is calling that get_relative_locations_of_…() statement to get the raw vision data, are not included in the constructed image to be seen by one’s soliton. Thus, during a lucid dream, one cannot see one’s own constructed appearance, assuming it is there, when seeing the constructed appearance(s) of whichever person(s) one is currently interacting with, because the d-common atoms composing one’s own constructed appearance are too close to one’s own mind, and likewise during a bion-body projection, one cannot see one’s own bion-body head because the bions composing one’s bion-body head are too close to one’s own mind. Note that it is easy to not include in the constructed image the d-common atoms or bions respectively that are too close to the calling bion, because computing the distance from the calling bion to each replying d-common atom or bion respectively, is a simple matter of using the distance formula to compute the distance between point (0, 0, 0) and point replier’s_XYZ_relative_to_000, and then discarding those replies whose computed distance from the calling bion is less than some cutoff value (the computation of replier’s_XYZ_relative_to_000 for a replying bion is given in subsection 3.8.6, and this computation of replier’s_XYZ_relative_to_000 is the same for the other forms of get_relative_locations_of_…() including get_relative_locations_of_d_common_atoms()).

Another consideration regarding vision during a lucid dream, and also during a bion-body projection, is that the get_relative_locations_of_…() learned-program statement used to get the raw vision data, has nothing to do with light of any kind, neither physical light nor any other kind of light. There are no light sources, no shadows, no reflective surfaces nor mirrors of any kind, when seeing with either get_relative_locations_of_d_common_atoms() or get_relative_locations_of_bions(). And this complete lack of light sources, shadows, and reflections of any kind is consistent with my own experience, since I never saw any light sources, shadows, or reflections of any kind during any of my approximately 500 out-of-body projections, with the sole exception being when my mind’s third-eye, which sees physical light using the get_photon_vectors() learned-program statement (section 5.4), was activated during my one dense bion-body projection.

During a lucid dream, the fastest speed that the awareness/mind can move at in our world, is estimated by me in chapter 10 as being about 250 miles per second (400 kilometers per second), based on an estimated time to move an estimated distance. However, during a bion-body projection, the fastest speed that I ever experienced when moving in a bion-body was much, much slower (I don’t have an actual estimate for the fastest speed when I was moving in a bion-body, but thousands of times slower than the fastest speed during a lucid dream is probably approximately correct). In my approximately 100 bion-body projections, my awareness/mind was always inside where my bion-body head would be (I couldn’t actually see my bion-body head, presumably for the reason given above about my awareness/mind being too close to my bion-body head). The rest of my bion-body, insofar as I could see it, was complete, including my upper body and two arms and hands and my lower body including my legs, and I always had conscious control over how I could move my bion-body arms (I was also able to consciously move my bion-body legs, and when moving slowly in my bion-body I would often move my bion-body legs as if I were walking, but my projected bion-body was never able to make contact with anything in the physical world—the reason for this lack of physical contact is given in section 5.4—and there was never any floor or ground to walk on that I could see; I assume this attempt at walking when moving slowly thru 3D space in my projected bion-body was simply a result of habit, because like most people I walk a lot in my physical body to move around).

During one bion-body projection that I still remember clearly after more than 35 years—it is April 2016 and I am 60 years old as I write this paragraph—I experimented with how fast I could move my bion-body forearms in up-and-down chopping motions, and it was approximately twice as fast as I could move my physical forearms in those same up-and-down chopping motions (after that bion-body projection was over, for comparison I tried doing the same up-and-down chopping motions in my physical body). Regarding my vision during my bion-body projections, I never saw in color, only a grayscale (in contrast, lucid-dream vision for me was always in color), and with the sole exception of the one dense bion-body projection that I had (described in subsection 10.1.1), I never saw any physical objects and the world that I could see was mostly empty with just my own bion-body and only rarely the projected bion-body of another person, as well as a few bion-body projections during which I could see the moving bion-body of our family’s pet cat which I believed was also projected at those times when I could see it (in every case, when seeing my own bion-body or seeing another bion-body, it always looked grainy in its composition). And whenever I did see another bion-body, whether a human’s or our pet cat’s, I only saw it when it was very close to my own projected bion-body, which makes me think that my vision had a very short range during those bion-body projections.[36] In terms of moving my entire bion-body in a given direction, there was no noticeable weight to my bion-body, and I was able to move in any direction, and often did so with conscious intent.

The awareness/mind has its own independent movement ability as described earlier in this section, and the individual bions in the bion-body, presumably by using the move_this_bion() learned-program statement, also have their own independent movement ability, which is clearly demonstrated, for example, when the limbs of the bion-body move relative to the rest of the bion-body, such as when I was “walking” or doing that chopping-motion experiment. Apparently, the cell-controlling bions composing my projected bion-body, when away from their cells, will respond to move messages from my mind by calling move_this_bion() as needed to move as my awareness/mind wants.

During all my bion-body projections, my awareness/mind always remained in my bion-body head, and this was done by the learned program LP_maintain_AM_position_close_to_one_bion which was described earlier in this section.


footnotes

[36] As already stated, the raw data for vision during a bion-body projection is provided by one’s mind calling get_relative_locations_of_bions(), and in subsection 3.8.6 I guess that MAX_SEND_DISTANCE_ALLOWED_FOR_LOCATING_BIONS is less than 10 feet (about 3 meters). I describe in section 10.1 a bion-body projection I had in 2012 that involved my pet cat, during which I saw that cat’s projected bion-body move rapidly around my own bion-body, always keeping about a foot distant from my bion-body as it moved around me. That cat’s projected bion-body was most distant from me—furthest from my awareness/mind which was in my bion-body head—when it was about a foot away from the bottom of my bion-body feet: which was a distance I estimate at about 6½ to seven feet, which means MAX_SEND_DISTANCE_ALLOWED_FOR_LOCATING_BIONS is probably at least seven feet.

Regarding how the image is constructed from a call of get_relative_locations_of_bions(): Assume that get_relative_locations_of_bions() has three additional parameters, a parameter named return_an_image whose value is either true or false, and, when return_an_image is true, two other added parameters: a vector that points in the direction of view; and an exclusion distance so that replies from bions whose computed distance from the calling bion is less than this exclusion distance, will, in effect, be ignored and not put in the image being constructed (in my case, the calling bion was whichever of my mind bions called get_relative_locations_of_bions() to form the image; and, since I never saw any of my bion-body head—nor any of my bion-body neck—this exclusion distance for my bion vision was probably set at about six inches). Also, when return_an_image is true, get_details_for_this_many_nearest_recipients is set to zero, and the image will be constructed piecemeal in the process_a_location_reply_from_a_bion() routine after each reply’s replier’s_XYZ_relative_to_000 is computed. The image plane that each replier’s_XYZ_relative_to_000 is projected onto, will depend on the given direction-of-view vector. At the end of the wait time for all the replies to be received, get_relative_locations_of_bions() will return the constructed image.

Also, assuming subsection 3.8.6, to get replies from all nearby cell-controlling bions that are not currently with their cells, which is the case with the bions in a projected bion-body that is away from its physical body, the user_settable_identifiers_block parameter for the get_relative_locations_of_bions() call would have its USID_2 set to NOT_WITH_MY_CELL, and the other values of that parameter would be set to null. And, to get the appearance of continuous vision, my guess is that the learned program that provides this vision makes about 30 calls per second of get_relative_locations_of_bions() to generate a sequence of constructed images, and, after further processing in one’s mind, the processed images are sent to one’s soliton so that, in my own case, I was able to consciously see my own bion-body—excluding my bion-body head and neck for the reason given in the previous paragraph—and its movements, as well as seeing any other nearby projected bion-body and its movements (assuming that other bion-body is in my current field of view, and its bions are within range and are recipients of the GET_LOCATIONS_OF_BIONS message sent by the image-generating call of get_relative_locations_of_bions()). And all this seeing was always relative to myself (myself being my soliton/mind in my bion-body head).


5.2.3 How One’s Projected Bion-Body Maintains its Human Shape

For us humans, one’s projected bion-body always maintains the same shape and size as one’s physical body. That wasn’t just my own experience, that was also the experience of many others who have had bion-body projections and have had their projections written about. A bion-body projection involves both one’s mind and also cell-controlling bions in one’s physical body. Thus, there is a learned program in one’s mind, and also a different learned program in cell-controlling bions, that work together to bring about a bion-body projection. The actual procedure for a bion-body projection probably looks like the following procedure which details this interaction between one’s mind and the cell-controlling bions in one’s physical body, and this procedure also results in a projected bion-body that has the same shape and size as one’s physical body (in this procedure: “one’s mind” refers to the learned program in one’s mind that manages a bion-body projection; BB is short for bion-body; when a message is being sent, user_settable_identifiers_block is the parameter for a call of send() that sends the specified message):

  1. In this procedure, wherever user_settable_identifiers_block is set, although not mentioned explicitly, assume that USID_1 is set to MY_CELL_IS_ACTIVE if this is a bion-body projection while one is still alive (this will form a bion-body whose bions will have MY_CELL_IS_ACTIVE as their USID_1 value). If instead, one’s mind is running this procedure to form the afterlife bion-body (my guess is this will typically happen about five minutes after one’s heart has stopped), then assume USID_1 is set to MY_CELL_IS_IN_STASIS (this will form the afterlife bion-body whose bions will have MY_CELL_IS_IN_STASIS as their USID_1 value; the big advantage of forming the afterlife bion-body from bions whose USID_1 is MY_CELL_IS_IN_STASIS instead of MY_CELL_IS_ACTIVE, is that the MY_CELL_IS_IN_STASIS bions will not return to their cells after a short time as happens when MY_CELL_IS_ACTIVE). Also, if one’s mind is running this procedure to form the afterlife bion-body, then assume step 4 will send BB_PROJECTION_REQUEST messages for many non-skin-cell types so as to get a bion-body projection that is dense enough to activate the mind’s third-eye and third-ear, so that the physical world can be seen and heard during that afterlife bion-body projection (likewise, if one has a sufficiently dense bion-body projection while still alive, one’s mind’s third-eye and third-ear will be activated; see section 5.4 for details regarding the third-eye and third-ear).

    Assume that for cell-controlling bions, the possible values for USID_5 include the value SKIN, which represents all skin-cell types including the cells under our fingernails and toenails.

    To begin the bion-body projection, one’s mind sends a BB_PROJECTION_REQUEST message to all the skin-cell bions in its physical body (user_settable_identifiers_block has USID_4 set to the unique identifier of one’s multicellular body, USID_5 set to SKIN, and the other integers in this parameter are set to null).

    Each bion recipient of the BB_PROJECTION_REQUEST message checks to see if it can join a bion-body projection (presumably this would depend on the current state of that bion’s cell and what that bion is currently doing with its cell, if anything), and if this bion, in effect, decides that it can join a bion-body projection, then this bion runs a learned program whose steps follow (this_bion is the bion running this learned program); the remaining steps in this procedure also include additional actions, where specified, by one’s mind:

  2. For this_bion, first stop running all learned programs for manipulating and maintaining its cell, but keep running the learned program LP_keep_this_bion_close_to_this_physical_atom so that this_bion continues to remain with its cell for the time being. After all the learned programs for manipulating and maintaining its cell have been stopped, then start a timer named elapsed_time_away_from_my_cell, which is the elapsed time since this_bion stopped running all those learned programs.

    Then save this_bion’s user-settable identifiers block, so that it can be restored in later steps where indicated, and then change its USID_2 to NOT_WITH_MY_CELL, and its USID_3 to AWAY_FROM_MY_CELL.

  3. After completing step 2, this_bion then waits a short time, probably a fraction of a second, so as to allow time for other skin-cell bions that got the BB_PROJECTION_REQUEST message and are going to join the bion-body projection, to complete step 2.

    Indented below is the description of the learned-program statement get_relative_locations_of_bions_distance_distributed(). The rest of step 3 follows after this description of get_relative_locations_of_bions_distance_distributed().

    Assume there is a learned-program statement get_relative_locations_of_bions_distance_distributed(). This statement works the same way that get_relative_locations_of_bions() does, in that it returns the relative locations of one or more bions, but instead of returning details of the nearest replying bions as get_relative_locations_of_bions() does, get_relative_locations_of_bions_distance_distributed() returns details of the most distant bion in each distance interval, as well as a count of all replying bions in each distance interval. The distance intervals are defined further below.

    For get_relative_locations_of_bions_distance_distributed(), assume its MAX_SEND_DISTANCE_ALLOWED_FOR_LOCATING_BIONS_DD (DD: distance distributed) has the same value as MAX_SEND_DISTANCE_ALLOWED_FOR_LOCATING_BIONS.

    In the same way that get_relative_locations_of_bions() has two supporting routines, get_relative_locations_of_bions_distance_distributed() also has two supporting routines, reply_to_this_location_request_bions_for_DD() and process_a_location_reply_from_a_bion_for_DD(). And add the following code to the examine_a_message_instance() routine in subsection 3.8.5 to call these two supporting routines:

    if (message_instance.special_handling_locate is either GET_LOCATIONS_OF_BIONS_FOR_DD or LOCATION_REPLY_FROM_BION_FOR_DD)
    and this_CE is currently holding a bion that is not asleep
    and that bion qualifies as a recipient of the message  /* Examine the message_instance and also that bion’s identifier block to determine this. */
    then
    if message_instance.special_handling_locate is LOCATION_REPLY_FROM_BION_FOR_DD
    then
    process_a_location_reply_from_a_bion_for_DD(message_instance)
    else
    reply_to_this_location_request_bions_for_DD(message_instance)
    end if
    return  /* exit this routine */
    end if

    Regarding reply_to_this_location_request_bions_for_DD(), other than the name of the routine and the message_instance.special_handling_locate which is set to LOCATION_REPLY_FROM_BION_FOR_DD, the code for reply_to_this_location_request_bions_for_DD() is identical to the code for reply_to_this_location_request_bions().

    Regarding the parameters of get_relative_locations_of_bions_distance_distributed(), it has two of the same parameters as get_relative_locations_of_bions(), namely user_settable_identifiers_block and use_this_send_distance, but instead of the get_details_for_this_many_nearest_recipients parameter that get_relative_locations_of_bions() has, get_relative_locations_of_bions_distance_distributed() has the integer parameter number_of_intervals.

    For get_relative_locations_of_bions_distance_distributed(), its use_this_send_distance parameter must have a value that is not less than 1 and not more than MAX_SEND_DISTANCE_ALLOWED_FOR_LOCATING_BIONS_DD, and its number_of_intervals parameter must have a value that is at least 2 and not more than the rounded-down value of (½ × use_this_send_distance) (in practical use, because memory must be allocated for each interval, and because, in general, the distance unit for all learned-program statements is the side-width of a computing element which is estimated at 10−16 centimeters wide, the value of the number_of_intervals parameter will typically be extremely small compared to the value of the use_this_send_distance parameter).

    Regarding the initialization of the global variables that get_relative_locations_of_bions_distance_distributed() makes available to process_a_location_reply_from_a_bion_for_DD(), some of these global variables are the same as in get_relative_locations_of_bions(). But the differences are these: nearest_recipients_count and requested_nearest_count are not set nor used. Also, instead of the following lines in get_relative_locations_of_bions():

    allocate enough memory for a list that can hold as many elements as specified by requested_nearest_count. Each element in this list has three components: the replying bion’s identifier block; the replier’s_XYZ_relative_to_000 that is computed in the process_a_location_reply_from_a_bion() routine; and the computed distance between (0, 0, 0) and replier’s_XYZ_relative_to_000.

    set pointer_to_nearest_recipients_list to point at the location in memory of the just-allocated list

    get_relative_locations_of_bions_distance_distributed() has these lines:

    set the integer max_subscript to the number_of_intervals parameter

    allocate enough memory for a list that can hold as many elements as specified by max_subscript. Each element in this list has four components: 1) The integer replies_count, initialized to zero, that counts all the replies for this distance interval. 2) The identifier block of the most distant replying bion in this distance interval. 3) The replier’s_XYZ_relative_to_000 that is computed in the process_a_location_reply_from_a_bion_for_DD() routine for the most distant replying bion in this distance interval. 4) its_distance, computed in process_a_location_reply_from_a_bion_for_DD(), for the most distant replying bion in this distance interval.

    set pointer_to_distance_intervals_list to point at the location in memory of the just-allocated list

    /*
    Compute the interval_size.

    For example, if use_this_send_distance is 1335 and number_of_intervals is 19, then interval_size is (1335 ÷ 19) which is 70.2631579.
    */
    set interval_size to (use_this_send_distance ÷ number_of_intervals)

    Another difference between get_relative_locations_of_bions_distance_distributed() and get_relative_locations_of_bions(), is that the returns of the two routines are different as follows:

    /*
    Returns for get_relative_locations_of_bions():
    */
    return ret_total_replies, centroid_XYZ_relative_to_000, ret_nearest_recipients_count, ret_pointer_to_nearest_recipients_list

    /*
    Returns for get_relative_locations_of_bions_distance_distributed():
    */
    return ret_total_replies, centroid_XYZ_relative_to_000, ret_interval_size, ret_pointer_to_distance_intervals_list

    The difference between process_a_location_reply_from_a_bion_for_DD() and process_a_location_reply_from_a_bion(), is that instead of the following comment and if-test in process_a_location_reply_from_a_bion():

    /*
    If conditions are met, insert the reply—more specifically, insert together three relevant details regarding the replying bion—into the current nearest-recipients list.
    */
    if requested_nearest_count is greater than 0
    then

    end if

    process_a_location_reply_from_a_bion_for_DD() has these lines:

    set distance to (use the distance formula to compute the distance between (0, 0, 0) and replier’s_XYZ_relative_to_000)

    /*
    Compute the integer list_subscript. For example, if distance is 113.7 and interval_size is 5,039.3, then division_result is 0.022562 (accurate to six decimal places), and rounding division_result up to the nearest integer gives 1 as the list_subscript, and pointer_to_distance_intervals_list[1] is the first element in the distance-intervals list.
    */
    set division_result to (distance ÷ interval_size)
    set the integer list_subscript to (division_result if the value of division_result is an integer greater than 0; otherwise, round division_result up to the nearest integer)

    /*
    This if-test is included for completeness, because floating-point math, which has finite precision, is used to compute interval_size, distance, and division_result. Another separate consideration is how replier’s_XYZ_relative_to_000 is computed, which is then used to compute distance. So, this if-test covers the worst case where division_result has a value slightly more than the integer value of max_subscript.
    */
    if list_subscript is greater than max_subscript
    then
    set list_subscript to max_subscript
    end if

    /*
    The list_subscript identifies the distance interval for this replying bion. After incrementing the replies_count, save the detail of this bion if it is either the first replying bion for this distance interval, or it is currently the most distant bion for this distance interval.
    */
    add 1 to pointer_to_distance_intervals_list[list_subscript].replies_count

    if pointer_to_distance_intervals_list[list_subscript].replies_count is 1  /* This is the first replying bion for this distance interval. */
    or pointer_to_distance_intervals_list[list_subscript].its_distance is less than distance
    then
    set the other three components of the list element at pointer_to_distance_intervals_list[list_subscript] as follows: set the second component to the replying bion’s identifier block which is in the message_instance, set the third component to replier’s_XYZ_relative_to_000, and set the fourth component its_distance to distance.
    end if

    Indented above is the description of the learned-program statement get_relative_locations_of_bions_distance_distributed(). The rest of step 3 follows:

    After the wait at the beginning of step 3, this_bion then calls get_relative_locations_of_bions_distance_distributed() with its user_settable_identifiers_block parameter set as follows: USID_2 is NOT_WITH_MY_CELL, USID_3 is AWAY_FROM_MY_CELL, USID_4 is the unique identifier of one’s multicellular body, USID_5 is SKIN, and the other integers in this parameter are set to null. Also for this call, set the number_of_intervals parameter to 3, and set the use_this_send_distance parameter to a short distance of 1/4th of an inch (0.635 centimeters) which I believe is a good compromise because there is a reason to make use_this_send_distance smaller and a reason to make use_this_send_distance larger: The smaller the use_this_send_distance value is, the less likely skin-cell bions from nearby separate physical structures—two adjacent fingers, for example—will be, in effect, tied together, given step 7 for skin-cell bions. The larger the use_this_send_distance value is, the more quickly the dragging effect of a single skin-cell bion will spread across the length and width of a limb (see “Moving my Projected Bion-Body’s Limbs” at the end of this subsection).

    If the call of get_relative_locations_of_bions_distance_distributed() failed to return a most distant bion in any of the three distance intervals (if ret_pointer_to_distance_intervals_list[1].replies_count is zero, or ret_pointer_to_distance_intervals_list[2].replies_count is zero, or ret_pointer_to_distance_intervals_list[3].replies_count is zero), then this_bion ends its attempt to join the bion-body projection: this_bion restores its user-settable identifiers block to its values before step 2, and then resumes running all learned programs for manipulating and maintaining its cell, and then exits (stops running) this procedure for this_bion.

    If instead the call of get_relative_locations_of_bions_distance_distributed() succeeds, then for each of the three bions in ret_pointer_to_distance_intervals_list[1], ret_pointer_to_distance_intervals_list[2], and ret_pointer_to_distance_intervals_list[3], save both the bion’s unique identifier and its_distance, into bion1, bion2, and bion3, respectively. (Assuming a large number—such as millions—of skin-cell bions in the projected bion-body, and assuming a somewhat even distribution of these skin-cell bions along the surface of the projected bion-body, and assuming that for the above call of get_relative_locations_of_bions_distance_distributed() its use_this_send_distance parameter has the suggested distance of 1/4th of an inch, then for the typical skin-cell this_bion, its bion1, bion2, and bion3 will be at a distance from this_bion of nearly 1/12th of an inch, nearly 1/6th of an inch, and nearly 1/4th of an inch, respectively.)

    After setting its bion1, bion2, and bion3, this_bion then sends a SKIN_CELL_BION_READY message to the same mind bion that sent the BB_PROJECTION_REQUEST message to this_bion in step 1, and then waits for a reply from one’s mind.

  4. One’s mind, after first sending the BB_PROJECTION_REQUEST message in step 1 requesting participants from among the skin-cell bions, for a bion-body projection, then waits a short time, perhaps about a second, for all the SKIN_CELL_BION_READY messages to be received (one SKIN_CELL_BION_READY message from each skin-cell bion that is ready to be a part of the bion-body projection). If the total number of received SKIN_CELL_BION_READY messages during that wait time is too low (not enough skin-cell bions will participate in the wanted bion-body projection), then one’s mind sends a BB_PROJECTION_CANCEL message to all the cell-controlling bions waiting in this step for a reply from one’s mind (user_settable_identifiers_block has USID_2 set to NOT_WITH_MY_CELL, USID_3 set to AWAY_FROM_MY_CELL, USID_4 set to the unique identifier of one’s multicellular body, and the other integers in this parameter are set to null).

    If the waited-for reply is BB_PROJECTION_CANCEL, then restore this_bion’s user-settable identifiers block to its values before step 2, and then resume running all learned programs for manipulating and maintaining its cell, and then exit (stop running) this procedure for this_bion.

    At this point one’s mind has enough skin-cell bions for the projection to proceed, but one’s mind may want to now add more bions to the projection, so let’s assume that to get a more dense bion-body projection, one’s mind has the option to send additional BB_PROJECTION_REQUEST messages with USID_5 values other than SKIN. The user_settable_identifiers_block parameter for each of these sent messages would have the wanted USID_5 value, USID_4 would be set to the unique identifier of one’s multicellular body, and the other integers in this parameter would be set to null. After sending as many of these additional BB_PROJECTION_REQUEST messages, if any, that it is going to send, one’s mind then waits a short time, perhaps about a second, so as to allow time for each recipient not-a-skin-cell bion to, in effect, decide if it will join the bion-body projection, and if so, then do the following sub-procedure (in this sub-procedure, this_bion is a not-a-skin-cell bion that has decided to join the bion-body projection):

    1. This first step is not an action step; instead, it describes the learned-program statement get_relative_locations_of_bions_near_line_segment(), which is used in step III of this sub-procedure.

      Assume there is a learned-program statement get_relative_locations_of_bions_near_line_segment(). This statement works the same way that get_relative_locations_of_bions() does, in that it returns the relative locations of one or more bions, but instead of returning details of the replying bions nearest to the bion calling get_relative_locations_of_bions(), get_relative_locations_of_bions_near_line_segment() returns details of the replying bions nearest to the calling bion, that are also sufficiently close to a specific line segment. This line segment is defined below where the parameter line_segment_type is described.

      (NOTE: My motivation for assuming the existence of this get_relative_locations_of_bions_near_line_segment() statement is for the sake of being able to get the bion_B value that I want in step III of this sub-procedure, with the ultimate aim of being able to construct a confinement algorithm for the non-skin-cell bions in the projected bion-body (this confinement algorithm is given in step 7), that can account for the swirling interior bions that I both felt and saw within my projected bion-body during the one dense bion-body projection that I had (described in subsection 10.1.1). However, besides this specific use here in this sub-procedure, get_relative_locations_of_bions_near_line_segment() has many potential uses during the development and growth of a multicellular physical body. Cell-controlling bions having this learned-program statement get_relative_locations_of_bions_near_line_segment() in their toolkit, is roughly equivalent to a human builder having a ruler and a straight-edge in his toolkit when constructing a house. END NOTE)

      Regarding parameters, get_relative_locations_of_bions_near_line_segment() has the same three parameters as get_relative_locations_of_bions()—namely user_settable_identifiers_block, get_details_for_this_many_nearest_recipients, and use_this_send_distance—and three additional parameters:

      • bion_uid: the unique identifier of a bion.

      • line_segment_type: the value of this parameter is either START_AT_BION_UID or START_OPPOSITE_BION_UID.

        In either case, regardless of whether START_AT_BION_UID or START_OPPOSITE_BION_UID is specified, the line that the line segment is a part of, is the line that passes thru point (0, 0, 0) and the computed point replier’s_XYZ_relative_to_000 for the bion identified by the bion_uid parameter.

        If START_AT_BION_UID is specified, then the starting point of the line segment is the computed point replier’s_XYZ_relative_to_000 for the bion identified by the bion_uid parameter, and the end point of the line segment extends off into infinity in the direction away from point (0, 0, 0). For example, if the bion identified by bion_uid has its replier’s_XYZ_relative_to_000 value computed as (2, −3, 8), then (2, −3, 8) is the start of the line segment.

        If START_OPPOSITE_BION_UID is specified, then the starting point of the line segment is the opposite of the computed point replier’s_XYZ_relative_to_000 for the bion identified by the bion_uid parameter, and the end point of the line segment extends off into infinity in the direction away from point (0, 0, 0). For example, if the bion identified by bion_uid has its replier’s_XYZ_relative_to_000 value computed as (2, −3, 8), then the opposite—reverse the signs of X, Y, and Z—is (−2, 3, −8), and this (−2, 3, −8) is the start of the line segment.

      • max_allowed_distance_from_line_segment: the maximum allowed distance from the line segment.

      For get_relative_locations_of_bions_near_line_segment(), assume its MAX_SEND_DISTANCE_ALLOWED_FOR_LOCATING_BIONS_NLS (NLS: near line segment) has the same value as MAX_SEND_DISTANCE_ALLOWED_FOR_LOCATING_BIONS.

      In the same way that get_relative_locations_of_bions() has two supporting routines, get_relative_locations_of_bions_near_line_segment() also has two supporting routines, reply_to_this_location_request_bions_for_NLS() and process_a_location_reply_from_a_bion_for_NLS(). And add the following code to the examine_a_message_instance() routine in subsection 3.8.5 to call these two supporting routines:

      if (message_instance.special_handling_locate is either GET_LOCATIONS_OF_BIONS_FOR_NLS or LOCATION_REPLY_FROM_BION_FOR_NLS)
      and this_CE is currently holding a bion that is not asleep
      and that bion qualifies as a recipient of the message  /* Examine the message_instance and also that bion’s identifier block to determine this. */
      then
      if message_instance.special_handling_locate is LOCATION_REPLY_FROM_BION_FOR_NLS
      then
      process_a_location_reply_from_a_bion_for_NLS(message_instance)
      else
      reply_to_this_location_request_bions_for_NLS(message_instance)
      end if
      return  /* exit this routine */
      end if

      Note that the determination of the line segment and whether or not a replying bion is sufficiently close to that line segment, takes place in the process_a_location_reply_from_a_bion_for_NLS() routine, and not in the reply_to_this_location_request_bions_for_NLS() routine. Thus, other than the name of the routine and the message_instance.special_handling_locate which is set to LOCATION_REPLY_FROM_BION_FOR_NLS, the code for reply_to_this_location_request_bions_for_NLS() is identical to the code for reply_to_this_location_request_bions().

      Before get_relative_locations_of_bions_near_line_segment() sends the GET_LOCATIONS_OF_BIONS_FOR_NLS message, it initializes additional globals (compared to get_relative_locations_of_bions()) that are needed by process_a_location_reply_from_a_bion_for_NLS(): globals for saving the begin point and end point of the line segment (initialized to null), and globals for showing to process_a_location_reply_from_a_bion_for_NLS() the values of get_relative_locations_of_bions_near_line_segment()’s three added parameters (bion_uid, line_segment_type, and max_allowed_distance_from_line_segment).

      In process_a_location_reply_from_a_bion_for_NLS(), immediately after the replier’s_XYZ_relative_to_000 is computed and added to the centroid sums, the algorithm for determining whether or not to include a replying bion in the nearest-recipients list follows:

      1. if the line segment is null
        then
        if the replying bion’s unique identifier is bion_uid
        then
        set the begin and end points of the line segment, as stated above in the description of the line_segment_type parameter
        else
        do not add this reply to the nearest-recipients list  /* nothing is added to the nearest-recipients list until we have the line segment */
        end if
        end if

      2. Beginning with the next reply after we have the line segment, this is done: Check if the replier’s_XYZ_relative_to_000 is close enough to the line segment, and if it’s computed shortest distance to that line segment is less than max_allowed_distance_from_line_segment, only then will that replying bion, in the code of process_a_location_reply_from_a_bion_for_NLS(), be subjected to the same code given in process_a_location_reply_from_a_bion() that determines whether or not that replying bion will be inserted into the nearest-recipients list:

        /*
        If conditions are met, insert the reply—more specifically, insert together three relevant details regarding the replying bion—into the current nearest-recipients list.
        */
        if requested_nearest_count is greater than 0
        then

        end if

        Note: It is already known how to compute the shortest distance between a point and a line segment in 3D space. To compute the shortest distance between a point and a line in 3D space, see, for example, Point-Line Distance — 3-Dimensional at http://mathworld.wolfram.com/Point-LineDistance3-Dimensional.html. To compute the shortest distance between a point and a line segment in 3D space, see, for example, Determine the distance from a line segment to a point in 3-space at http://math.stackexchange.com/questions/322831/determing-the-distance-from-a-line-segment-to-a-point-in-3-space.

    2. For this step and the next step in this sub-procedure, define for the human body this constant: MAX_BODY_THICKNESS, and give it a value of 4 feet (1.2 meters), which should be enough for everyone.

      For this_bion, we want two anchors, bion_A and bion_B, selected from among the skin-cell bions of step 3, that currently compose the skin-cell-bion part of what will be the projected bion-body. For bion_A and bion_B, save that bion’s unique identifier.

      For bion_A, selecting from among the skin-cell bions that currently compose the skin-cell-bion part of what will be the projected bion-body, we want the closest skin-cell bion to this_bion, which is gotten by calling get_relative_locations_of_bions() with its user_settable_identifiers_block parameter set as follows: USID_2 is NOT_WITH_MY_CELL, USID_3 is AWAY_FROM_MY_CELL, USID_4 is the unique identifier of one’s multicellular body, USID_5 is SKIN, and the other integers in this parameter are set to null. Also for this call, set the get_details_for_this_many_nearest_recipients parameter to 2, and set the use_this_send_distance parameter to MAX_BODY_THICKNESS. When the call returns with the details of the two nearest replying bions, save the nearest bion’s unique identifier in bion_A, and save the next-nearest bion’s unique identifier in bion_B.

      Anchor bion_A is now complete, and anchor bion_B has its default value, in case the next step, step III, fails to set a different value for anchor bion_B.

    3. Regarding get_relative_locations_of_bions_near_line_segment(): For bion_B, selecting from among the skin-cell bions that currently compose the skin-cell-bion part of what will be the projected bion-body, we want the nearest skin-cell bion to this_bion, that is also sufficiently close to the line segment whose begin point is opposite the computed point replier’s_XYZ_relative_to_000 for the bion identified by bion_A.

      To get the wanted bion_B, call get_relative_locations_of_bions_near_line_segment() with the following parameters: user_settable_identifiers_block (USID_2 is NOT_WITH_MY_CELL, USID_3 is AWAY_FROM_MY_CELL, USID_4 is the unique identifier of one’s multicellular body, USID_5 is SKIN, and the other integers in this parameter are set to null); get_details_for_this_many_nearest_recipients is set to 1; use_this_send_distance is set to MAX_BODY_THICKNESS; bion_uid is set to the value of bion_A; line_segment_type is set to START_OPPOSITE_BION_UID; max_allowed_distance_from_line_segment is set to a distance of 1 millimeter (about 0.04 inches), assuming this distance is more than enough so that it is very likely that at least one skin-cell bion in what will be the projected bion-body, is within this distance of the line segment assuming that line segment passes thru a skin-cell-bion layer in what will be the projected bion-body.

      If the returned ret_nearest_recipients_count is 1: If that nearest recipient bion is the same bion in either bion_A or bion_B, then discard that nearest recipient bion and leave the values of bion_A and bion_B unchanged; otherwise, save that nearest recipient bion’s unique identifier in bion_B, replacing the default value for bion_B set in the previous step II.

      At this point we have the final values for this_bion’s two skin-cell anchors bion_A and bion_B. In practice, if this_bion’s not-a-skin-cell cell is anywhere in a layer of skin cells (perhaps, for example, a nerve cell, or a blood-vessel cell, or a blood cell currently in the skin), then it is probably a certainty that the two skin cells of bion_A and bion_B are very close together. Similarly, if this_bion’s not-a-skin-cell cell is somewhere in the interior of the physical body but is closer to the nearest skin than the value of max_allowed_distance_from_line_segment, then it is very likely that the two skin cells of bion_A and bion_B are separated from each other by a distance less than the value of max_allowed_distance_from_line_segment.

      If this_bion’s not-a-skin-cell cell is somewhere in the interior of the physical body and is farther away from the nearest skin than the value of max_allowed_distance_from_line_segment, then, assuming a short distance for max_allowed_distance_from_line_segment like the 1 millimeter set above, most of the non-skin-cell cells in one’s physical body are in this group of interior cells that are farther away from the nearest skin than the value of max_allowed_distance_from_line_segment, and for these cells’ bions that are joining the projected bion-body, most of them will have their two skin-cell anchors bion_A and bion_B on opposite sides of the skin that wraps around whatever part of one’s physical body a given not-a-skin-cell bion is in, whether it be in a finger or toe, palm or foot, arm or leg, or in one’s head, neck, or trunk. For example, if this_bion’s not-a-skin-cell cell is in the middle of one’s hand, and is also closer to the skin on the back of one’s hand than the skin on the palm of one’s hand, and is also more than max_allowed_distance_from_line_segment distant from the closest skin cell in that back-of-hand skin, then bion_A’s skin cell will be in the skin on the back of one’s hand and bion_B’s skin cell will be in the skin on the palm of one’s hand.

    4. Do step 2 for this_bion, and then send a NON_SKIN_CELL_BION_READY message to the same mind bion that sent the BB_PROJECTION_REQUEST message to this_bion in step 4, and then wait for one’s mind to send the BB_PROJECTION_SEPARATE message.

  5. At this point one’s mind has finished waiting for bions to be a part of the bion-body projection, and sends the BB_PROJECTION_SEPARATE message to all the cell-controlling bions waiting for this reply (user_settable_identifiers_block parameter has USID_2 set to NOT_WITH_MY_CELL, USID_3 set to AWAY_FROM_MY_CELL, USID_4 set to the unique identifier of one’s multicellular body, and the other integers in that parameter are set to null).

    For this procedure one’s mind has counted all the NON_SKIN_CELL_BION_READY messages, if any, sent to it in step 4, and if this count is large enough to represent a dense bion-body, then activate during this bion-body projection the mind’s third-eye and third-ear so that one’s awareness can see and hear the physical world while in one’s projected bion-body. (Note that the number of cell-controlling non-skin-cell bions needed to activate the mind’s third-eye and third-ear during a bion-body projection has nothing to do with how the mind’s third-eye and third-ear work. Instead, it is simply a high barrier that has evolved to greatly limit when this hidden ability of our minds can consciously appear during a bion-body projection, and there is apparently a similar high barrier against activation of the mind’s third-eye and third-ear during a lucid dream, because my third-eye and third-ear never activated during any of my approximately 400 lucid dreams. Also, the third-eye and third-ear cannot operate when we are in our physical bodies, because of the surrounding physical matter (see section 5.4). Most people will not experience their third-eye and third-ear until they are in their afterlife bion-body.)

    After sending the BB_PROJECTION_SEPARATE message, one’s mind waits a very short time (perhaps at most a few milliseconds) to allow time for all the recipient bions to stop running LP_keep_this_bion_close_to_this_physical_atom as stated in the next step, and after this very short wait, one’s mind can then send move messages as wanted to those bions: If one’s mind sends a move message to all the bions in its projected bion-body, then user_settable_identifiers_block has USID_2 set to NOT_WITH_MY_CELL, USID_3 set to AWAY_FROM_MY_CELL, USID_4 set to the unique identifier of one’s multicellular body, and the other integers in this parameter are set to null, and in this case that entire projected bion-body will move in the specified direction.

    Besides being able to move the entire projected bion-body as a whole by sending move messages whose recipients are all the bions currently composing the projected bion-body, one’s mind can also send messages to specific skin-cell bions in the projected bion-body, and, given step 7 below for skin-cell bions, and depending where those skin-cell bions are in the projected bion-body, one’s mind, among other things, can move the limbs of the projected bion-body. See “Moving my Projected Bion-Body’s Limbs” at the end of this subsection for more detail.

  6. At this point, this_bion has waited for a reply from one’s mind, and that reply is BB_PROJECTION_SEPARATE. In response, this_bion stops running its learned program LP_keep_this_bion_close_to_this_physical_atom and also enables a flag that means, in effect, that any move message received by this_bion from one’s mind will be followed and not ignored as it otherwise would be if received when LP_keep_this_bion_close_to_this_physical_atom is running.

    Among other things, once the bions in the projected bion-body are no longer running LP_keep_this_bion_close_to_this_physical_atom and will now move as one’s mind messages them to move, one’s projected bion-body can move away from one’s physical body and move independent of one’s physical body. And one’s awareness/mind will be along for the ride, using the learned program LP_maintain_AM_position_close_to_one_bion to stay close to one of the skin-cell bions that is a part of the head of one’s projected bion-body (presumably the skin-cell bion selected to stay close to would be at the front of the head, probably selected from the skin between one’s physical eyes).

  7. After step 6, this_bion is no longer, in effect, tied down to its cell. With regard to movement of this_bion during this bion-body projection, other than responding to any move messages received from one’s mind, this_bion will also do the following:

    First assume there is a learned-program statement get_relative_location_of_each_bion_in_list() that is essentially the same as the learned-program statement get_relative_location_of_bion_uid() defined in subsection 5.2.1. The only difference is that get_relative_location_of_bion_uid() has as its first parameter bion_uid which is the unique identifier of a single bion, and get_relative_location_of_each_bion_in_list() has as its first parameter list_of_bions which is a short list of the unique identifiers of two or more bions. Both of these learned-program statements have the same value for their respective MAX_SEND_DISTANCE_ALLOWED_FOR_….

    if this_bion’s USID_5 is SKIN (this_bion’s cell is a skin cell)

    Set list_of_bions to the unique identifiers of the three bions in bion1, bion2, and bion3. Then many times per second call get_relative_location_of_each_bion_in_list() (if necessary, adjust the call’s use_this_send_distance as needed until one gets a reply from all three of those bions), and do the following after each successful call:

    begin ACTION_7A  /* naming this action ACTION_7A because it is referenced elsewhere in this subsection */

    With the returned distance and direction to each of those three bions relative to this_bion (note: the also returned identifier block of each of those three bions is not used in this procedure), use as needed move_this_bion() to move this_bion so that it remains at about the same distances from those three bions as the original distances that were saved in bion1, bion2, and bion3 when both this_bion and those other three skin-cell bions were all still with their cells in the physical body (for example, if the original distances in bion1, bion2, and bion3 are 8, 4, and 16, respectively, then after each successful call of get_relative_location_of_each_bion_in_list(), this_bion—in accordance with whatever algorithm is computing how to move—moves as needed so that it remains at a distance from bion1 of about 8, at a distance from bion2 of about 4, and at a distance from bion3 of about 16).

    However, because bion1, bion2, and bion3 may have changed their separation distances relative to each other, it may not be possible for this_bion to move so as to remain at about the same distances from those three bions as the original distances that were saved in bion1, bion2, and bion3. For this reason, after each successful call of get_relative_location_of_each_bion_in_list(), in addition to having the returned distances between this_bion and bion1, bion2, and bion3, use the distance formula to compute the three current separation distances between bion1, bion2, and bion3 (the distance between bion1’s replier’s_XYZ_relative_to_000 and bion2’s replier’s_XYZ_relative_to_000, the distance between bion1’s replier’s_XYZ_relative_to_000 and bion3’s replier’s_XYZ_relative_to_000, and the distance between bion2’s replier’s_XYZ_relative_to_000 and bion3’s replier’s_XYZ_relative_to_000), and also copy the original distances saved in bion1, bion2, and bion3 to wanted_distance_to_bion1, wanted_distance_to_bion2, and wanted_distance_to_bion3 respectively, and then whatever algorithm is computing how to move this_bion will have to take into account the three current separation distances between bion1, bion2, and bion3 and adjust as needed the three wanted_… distances, and then use these three adjusted wanted_… distances and the returned relative locations of bion1, bion2, and bion3 to compute how far to move this_bion, and in what direction, so as to be at those adjusted wanted_… distances from bion1, bion2, and bion3, and then move this_bion that far and in that direction.

    end ACTION_7A

    Given the presumably great number of awareness/mind beings in our galaxy, and the probable rarity of planets like our Earth that have organic life, I think it is very likely that most of the awareness/mind beings in our galaxy that have a body, have a bion-body without any physical component (the Caretakers, section 7.6, are an example of awareness/mind beings that have a bion-body that has no physical component). These bion bodies need a way to hold together. Thus, because of this widespread need, there is probably a learned-program statement that takes as input one, two, or three different bions, along with the wanted distances between the calling bion and those one, two, or three input bions, and then adjusts those wanted distances if necessary when there are two or three input bions, and then moves the calling bion so that it is close enough to being at those wanted possibly-adjusted distances from the input bions (in the case of three input bions, this learned-program statement would do what was described above in this step 7 for skin-cell bions, beginning with successfully calling get_relative_location_of_each_bion_in_list() with the three input bions and wanted distances in bion1, bion2, and bion3, and then doing ACTION_7A). Aside from mentioning that this learned-program statement likely exists, it is not considered further in this book.

    else  /* this_bion’s USID_5 is not SKIN (this_bion’s cell is not a skin cell) */

    Referring to this_bion’s two anchors bion_A and bion_B (see step 4), set list_of_bions to the two unique identifiers bion_A and bion_B. Then many times per second call get_relative_location_of_each_bion_in_list() (if necessary, adjust the call’s use_this_send_distance as needed until one gets a reply from both of these bions), and do the following after each successful call: With the returned bion_A’s replier’s_XYZ_relative_to_000 and bion_B’s replier’s_XYZ_relative_to_000, which are the locations of bion_A and bion_B relative to this_bion, use the distance formula to compute their distances from this_bion and set current_distance_to_bion_A and current_distance_to_bion_B respectively. Also, use the distance formula to compute the distance between the two points bion_A’s replier’s_XYZ_relative_to_000 and bion_B’s replier’s_XYZ_relative_to_000, and set current_distance_between_bions_A_and_B. After computing these three distances, do the following small block of code:

    /*
    PART ONE

    This PART ONE isn’t really needed, but I’m adding it both for efficiency reasons and because it will do a better job of keeping non-skin-cell bions that were within or near the skin during step 4, from possibly straying a little bit outside of the, in effect, outer shell of the projected bion-body which is composed of skin-cell bions.
    */
    /*
    “1 centimeter” in the below if is an arbitrary choice, but should give good results.
    */
    if current_distance_between_bions_A_and_B is less than 1 centimeter (about 0.4 inches)
    then
    /*
    “half a millimeter” in the below if is an arbitrary choice, but should give good results.
    */
    if current_distance_to_bion_A is greater than half a millimeter (about 0.02 inches)
    then
    move this_bion so that it is within half-a-millimeter distance from bion_A.
    end if
    exit this small block of code.
    end if

    /*
    PART TWO
    */
    set sphere_radius to (h × current_distance_between_bions_A_and_B)  /* h is a constant that is greater than ½ and less than 1. */

    /*
    Confine this_bion to the convex-lens-shaped intersection of two equal-sized spheres of radius sphere_radius, with one sphere centered on bion_A and the other sphere centered on bion_B. For convenience, call this convex-lens-shaped intersection of the two spheres the confinement lens.

    Note that the reason constant h must have a value greater than ½ is because if it were less than ½ then there is no intersection of the two spheres (at h = ½, the two spheres intersect at a single point). Likewise, if h is greater than 1, this would make it too likely for this_bion to often be outside of the interior of the projected bion-body.
    */
    if current_distance_to_bion_A is greater than sphere_radius
    or current_distance_to_bion_B is greater than sphere_radius
    then
    /*
    this_bion is currently outside of its confinement lens, so move this_bion so that it is within its confinement lens.
    */
    Move this_bion so that it is not greater than sphere_radius distant from bion_A, and not greater than sphere_radius distant from bion_B. This move places this_bion back within its confinement lens.

    After this_bion has been moved back within its confinement lens, use the move_this_bion() statement to give this_bion a small velocity of a few inches per second (1 inch is 2.54 centimeters), because this is my estimate of the speed of the swirling interior bions that I saw during my one dense bion-body projection. Assume that this small velocity is in a direction relative to the confinement lens that will have the effect over a short time—combined with the possibly many-times-per-second movement of this_bion back within its confinement lens when it is outside of its confinement lens—of having this_bion moving along the perimeter of its confinement lens.

    exit this small block of code.
    end if

    Regarding the mathematics of the intersection of two spheres, see, for example, Sphere-Sphere Intersection at http://mathworld.wolfram.com/Sphere-SphereIntersection.html: A formula is given for the radius a of the circle where the two spheres intersect. This circle is also the perimeter of the confinement lens. Because here the two spheres have the same radius, and we want to know how changing h changes radius a, we can simplify the given formula for radius a to (½ × square_root_of((4 × h2) − 1)). For example, a value for h of 0.559 gives radius a = 0.25, which means that the confinement lens for this_bion has a diameter that is half of current_distance_between_bions_A_and_B. As a few more examples, a value for h of 0.55 gives radius a = 0.229 and a confinement-lens diameter of (0.458 × current_distance_between_bions_A_and_B), and a value for h of 0.6 gives radius a = 0.332 and a confinement-lens diameter of (0.664 × current_distance_between_bions_A_and_B).

    Because my one dense bion-body projection was when I was about 24½ years old, and I am 60 years old as I write this paragraph, I no longer have a clear memory of exactly what I saw in the interior of my upper bion-body chest when I looked there during that dense bion-body projection, other than that I saw multiple circular flows of interior particles, including one near my left armpit, and my estimate is that the particles in those circular flows were moving at a speed of a few inches per second. Assuming the confinement algorithm above in PART TWO for those interior particles (bions) that I saw in those circular flows, I can’t say with any confidence what the h value was, although my guess is an h value at or near 0.559, giving a confinement-lens diameter for this_bion at or near half of current_distance_between_bions_A_and_B.

    Regarding any specific pair of skin-cell bions in bion_A and bion_B to which PART TWO applies, all the non-skin-cell bions in the projected bion-body that have those same two skin-cell bions as their bion_A and bion_B—which of these two specific skin-cell bions is in bion_A and which is in bion_B doesn’t matter here—will all at any given point in time have the same confinement lens in 3D space, regardless of where in the physical body—whether closer to bion_A or bion_B and by how much—those non-skin-cell bions were when step 4 was being done for them, and this concentration of what will be swirling bions will make them more visible to one’s vision during a dense bion-body projection, assuming that the more bions in one’s line of sight to what will be a pixel in one’s vision, the more likely that the algorithms in one’s mind that produce the images that are sent to one’s awareness will make that pixel dark representing more bions. Regarding what is consciously seen, there is also the effect of all the complex post-processing of raw images and their sequence that happens that, among other things, emphasizes motion in what is finally sent to the awareness, and this post-processing probably played a role in making a few of the many swirls in my upper bion-body chest stand out and be more noticeable to my awareness. Note that there are about 50 trillion cells (5 × 1013 cells) in an adult human body, and during my one dense bion-body projection that I had, my dense bion-body probably had at least billions of bions in the interior of my upper bion-body chest, if not actually several trillions of bions. Thus, to see a dark pixel in my bion-body during that dense bion-body projection, may have required at least many thousands of bions if not many millions of bions in the line of sight to that pixel.

    end if

    Regarding this step 7 as a whole: The end result of this step 7 is that the projected bion-body has, in effect, an outer shell that is composed of skin-cell bions, and this shell has the same human shape and size as one’s physical body from which those skin-cell bions came. Also, if the projected bion-body has additional bions that are not skin-cell bions (USID_5 is not SKIN), then at least most of these non-skin-cell bions are, in effect, confined within that outer shell of the projected bion-body, and for those non-skin-cell bions that are sometimes outside of that outer shell, it won’t be by much in terms of distance from that outer shell.

  8. This step 8 discusses the return of the cell-controlling bions that compose the projected bion-body to their cells in the physical body. The discussion in this step 8 assumes that all these cell-controlling bions have USID_1 value MY_CELL_IS_ACTIVE (see step 1). For a discussion of the afterlife bion-body, whose cell-controlling bions have USID_1 value MY_CELL_IS_IN_STASIS, see section 6.3.

    Regarding how my bion-body projections ended, they all ended the same way: my projected bion-body moved back into my physical body and quickly reintegrated into my physical body, and without any break in my consciousness I was fully back in my physical body. After I was back in my physical body, as a rule I then thought about that projection experience, and after thinking about it for a while, I then went back to sleep. To end the bion-body projection, one’s mind sends a BB_END_THE_PROJECTION message (user_settable_identifiers_block has USID_2 set to NOT_WITH_MY_CELL, USID_3 set to AWAY_FROM_MY_CELL, USID_4 set to the unique identifier of one’s multicellular body, and the other integers in that parameter are set to null), which causes each of the recipient bions to stop doing step 7 and then change its USID_3 to RETURNING_TO_MY_CELL, and then resume running its learned program LP_keep_this_bion_close_to_this_physical_atom that it had stopped running in step 6. Then, after that cell-controlling bion has moved close enough to the specified atom and is thereby back with its cell, that cell-controlling bion then restores its user-settable identifiers block to its values before step 2, and then resumes running all learned programs for manipulating and maintaining its cell, and then exits (stops running) this procedure for that cell-controlling bion. However, note that before one’s mind sends the BB_END_THE_PROJECTION message, some or all of the cell-controlling bions composing one’s projected bion-body may have already returned or be returning to their cells because of time outs, as explained in the next paragraph. Assuming that one’s mind wants to end the current bion-body projection, then assume that it will send the BB_END_THE_PROJECTION message no later than when the projected bion-body is back inside one’s physical body.

    Regarding how long my bion-body projections lasted, my rough estimate is that the longest were at least several minutes long, perhaps at most five minutes long, but those longer-lasting bion-body projections always had during that bion-body projection brief returns to my physical body to do the exchange of used bions for unused bions described in section 5.4. For my bion-body projections that did not have any brief returns to my physical body, those were my shorter-lasting bion-body projections, although as I recall, most of my bion-body projections had one or more brief returns to my physical body before the last return which was also the end of that bion-body projection. Based on my experience, my estimate is that the cell-controlling bions in my physical body with USID_1 value MY_CELL_IS_ACTIVE only allowed about one minute of time to be away from their cells in a bion-body projection. Thus, the timer started in step 2, elapsed_time_away_from_my_cell, is periodically checked by this_bion to see if it is time for its return to its cell, and if so, this_bion does what was already described in the previous paragraph for the recipient bions of the BB_END_THE_PROJECTION message: stop doing step 7 and then change its USID_3 to RETURNING_TO_MY_CELL, and then resume running its learned program LP_keep_this_bion_close_to_this_physical_atom that it had stopped running in step 6. Then, after this_bion has moved close enough to the specified atom and is thereby back with its cell, this_bion then restores its user-settable identifiers block to its values before step 2, and then resumes running all learned programs for manipulating and maintaining its cell, and then exits (stops running) this procedure for this_bion.

    For a cell-controlling bion whose USID_1 value is MY_CELL_IS_ACTIVE: Regarding the time allowed by that bion to be away from its cell in a bion-body projection, perhaps there is some variation in this time allowed depending on the cell type, but even if there is some variation, it is probably the case that a substantial fraction of the bions composing one’s projected bion-body will time out at about the same time and then return to their cells. Given step 7, if the non-skin-cell bions time out first before the skin-cell bions, then their leaving the projected bion-body will not have any effect on the skin-cell bions in that projected bion-body, but when the skin-cell bions time out, the timed-out skin-cell bions will drag whatever remains of the projected bion-body back into the physical body.

    Instead of waiting to be dragged back into one’s physical body because of time outs, one’s mind could send move messages to all the cell-controlling bions in one’s projected bion-body to move one’s projected bion-body back into one’s physical body (user_settable_identifiers_block has USID_2 set to NOT_WITH_MY_CELL, USID_3 set to AWAY_FROM_MY_CELL, USID_4 set to the unique identifier of one’s multicellular body, and the other integers in that parameter are set to null), and then when the bion-body is inside or otherwise close enough to being inside one’s physical body one’s mind sends the BB_END_THE_PROJECTION message to those same bions. I believe this is what happened in the case of my one dense bion-body projection, and also in the case of my less-dense bion-body projection in 2012 that involved my pet cat (both described in chapter 10), because in both of those cases my bion-body was motionless approximately two feet above my physical body and then moved slowly back down into my physical body. But in all my other bion-body projections (approximately 100), and regardless of what happened after my bion-body had returned to my physical body (either continuing with the bion-body projection after first exchanging used bions for unused bions and then leaving my physical body again, or, after returning, ending the bion-body projection), when my bion-body was returning to my physical body, my bion-body moved fast, and straight into my physical body with no prior positioning or slow movement of my bion-body when it was close to my physical body: therefore, for those bion-body projections, and given step 7, I believe my bion-body was dragged back into my physical body by skin-cell bions that had timed out.

    Regarding the exchange of used bions for unused bions because one’s mind wants to continue with the bion-body projection if it can—and regardless of whether one’s bion-body was dragged back by its bions into one’s physical body or one’s mind directed one’s bion-body back into one’s physical body—the simplest way to do the exchange of used bions for unused bions, given the steps in this procedure, is after one’s projected bion-body is back in one’s physical body and one’s mind has sent the BB_END_THE_PROJECTION message, is to wait a short time—perhaps a few milliseconds for all those bion-body bions, if any, that haven’t already done so, to return to their cells—and then start this procedure over again with step 1. And with this simple approach, the exchange of used bions for unused bions is more specifically a complete replacement of all the cell-controlling bions in one’s projected bion-body with, after returning to one’s physical body, a completely new group of cell-controlling bions in one’s projected bion-body (among other things, this complete replacement avoids the complication of having to, in effect, stitch together the new skin-cell bions with any old skin-cell bions still remaining in the projected bion-body; and also this complete replacement avoids being dragged back to one’s physical body prematurely because any non-replaced skin-cell bions still in the projected bion-body that have yet to time out will time out sooner than the newly added skin-cell bions).

Based on my own experience with out-of-body projections, they most commonly occurred on a night where before going to sleep I first did Om meditation for five or ten minutes, and then within a few hours after I had fallen asleep, either I became fully conscious in a lucid dream or I became fully conscious in my physical body but I then avoided moving my physical body because I wanted to try to have a bion-body projection, and then in my mind (not speaking out loud) I mentally repeated slowly, over and over again, the word Om—this frequent Om-meditation usage was all before my 25th birthday and my kundalini injury on that date—with the purpose of triggering a bion-body projection, and with that repeated mentally saying Om, before long I would often feel a vibration in my body, and continuing with that mentally repeating of Om, within a few seconds I would then be able to move away from my physical body in my projected bion-body (back then, and still today, I always go to sleep while lying on my side, but my physical body was always lying flat on its back whenever I became fully conscious in my physical body before any bion-body projection that I had, so my unconscious mind had always first moved my physical body onto its back before making me conscious so that I could then proceed with the Om meditation in an attempt to bring about a bion-body projection). Much less common for me during those years of Om-meditation use was to become fully conscious when I was already projected in a bion-body. (Let me just note in passing that I have no idea nor explanation for why mentally saying Om worked for me, resulting in lucid dreams and bion-body projections. It doesn’t work for everyone who tries Om meditation, but I know that besides myself it has worked for at least some people who have tried it as a meditation method, because of what is said about Om meditation in the Upanishads. Let me also note that with the sole exception of the one dense bion-body projection that I had, all the bion-body projections that I had as a result of Om meditation always consisted of a low-density bion-body with no noticeable swirling of bions in the interior of that bion-body. Given step 7 above, all those low-density bion-body projections that I had, had mostly or only skin-cell bions composing my projected bion-body.)

Moving my Projected Bion-Body’s Limbs

Given step 7 above for skin-cell bions, how was my mind able to direct the movement of my projected bion-body’s limbs, specifically my moving my bion-body legs as if I was walking, and my moving my bion-body forearms in that up-and-down chopping-motion experiment that I did (both are described in subsection 5.2.2). The physical structures for moving my limbs in my physical body—neurons, muscles, tendons, bones, and joints—were not present in my projected bion-body. In the case of that bion-body projection where I experimented with how fast I could move my bion-body forearms in up-and-down chopping motions, my bion-body forearms were moving as if they were bending at the elbow like how my physical forearms move when I’m in my physical body. I remember that shortly after that bion-body projection had ended, I then did the same up-and-down chopping motions in my physical body for comparison, and I concluded that doing those up-and-down chopping motions in my projected bion-body were about twice as fast as I could do those same chopping motions in my physical body. Remembering this, and testing myself with a stopwatch at the time of this writing in 2016, for each forearm in my physical body I can do about 2½ of those up-and-down chopping motions per second, so that means in that bion-body projection I was able to do those up-and-down chopping motions at about 5 per second. Given step 7 for skin-cell bions, if one skin-cell bion moves, that skin-cell bion, in effect, drags after itself the other skin-cell bions that have that skin-cell bion as its bion1, bion2, or bion3, and those dragged skin-cell bions in turn drag other skin-cell bions, and so on, in a chain reaction of movement. To get those up-and-down chopping motions of my bion-body forearms while my bion-body upper arms remained unmoved, my mind probably only needed to do the following for each of my two bion-body arms:

  • To a single skin-cell bion in the elbow area of that bion-body arm:

    My mind sends a message to this bion saying, in effect, to temporarily stop doing step 7 so that this bion stops maintaining its distances to the three bions in its bion1, bion2, and bion3. This will prevent this bion from being dragged by its bion1, bion2, or bion3, and, in effect, make this bion an anchor against any dragging that reaches it by chain reaction.

    After the up-and-down chopping motions are finished, my mind sends a message to this bion saying, in effect, to resume doing step 7.

  • To a single skin-cell bion in that bion-body forearm near its hand:

    My mind sends a message to this bion saying, in effect, to temporarily stop doing step 7 so that this bion stops maintaining its distances to the three bions in its bion1, bion2, and bion3. By stopping step 7 for this bion, this will avoid conflicts with the move messages my mind will then send to this bion.

    My mind then sends a sequence of move messages to this bion so as to move this bion in the up-and-down chopping motions that I did. My mind, in effect, told this bion to move at a speed in up-and-down arcs that, by the chain-reaction dragging along of the other bions in my bion-body forearm and hand, resulted in the approximately 5 up-and-down chopping motions per second that I saw.

    After the up-and-down chopping motions are finished, my mind sends a message to this bion saying, in effect, to resume doing step 7.

And similarly with how my mind made walking movements with my bion-body legs: For each leg, to three different skin-cell bions in that leg—one near that leg’s hip area, one near that leg’s knee, and one near that leg’s foot—first send a message to each of these three bions to temporarily stop doing step 7, and then to the latter two bions (the one near the knee and the other near the foot), send a sequence of move messages that result in moving each leg as if I were walking. When finished with these walking movements, send a message to each of these three bions saying, in effect, to resume doing step 7.

Given step 3 above for skin-cell bions, each skin-cell bion has an average of three other skin-cell bions that have that skin-cell bion as its bion1, bion2, or bion3. Assuming a single skin-cell bion starts receiving move messages from my mind and begins dragging other skin-cell bions, regarding how much the patch of skin-cell bions being dragged will widen after n executions by each of the skin-cell bions in the projected bion-body of step 7’s (call get_relative_location_of_each_bion_in_list() successfully and then do ACTION_7A), a rough approximation is n × (the average distance from this_bion to its bion1, bion2, and bion3 when step 3 was done), which, for the suggested use_this_send_distance value of 1/4th of an inch given in step 3, gives an average distance of 1/6th of an inch, and the rough approximation then reduces to (n × 1/6th of an inch). Measuring from my elbow to my wrist is 11 inches, so n = 66 to spread that far. Regarding step 7 for each skin-cell bion, my rough estimate is that if step 7’s (call get_relative_location_of_each_bion_in_list() successfully and then do ACTION_7A) is done one-thousand times per second, then this would be more than fast enough to allow the speed at which I was able to move my bion-body forearms in those up-and-down chopping motions that I did, with, as I saw it, my bion-body forearm and hand holding together and moving smoothly as one, assuming a single skin-cell bion in my forearm near the hand, receiving move messages from my mind, by chain reaction dragged after it the other skin-cell bions in my bion-body forearm and hand.

Although I did that up-and-down chopping-motion experiment with my bion-body forearms, if, during one of my approximately 100 bion-body projections I had done a similar experiment with one of my bion-body hands, I’m sure I would have remembered it, but I never tried to do anything with my bion-body hands. Perhaps, given steps 3 and 7 for skin-cell bions, my bion-body fingers—depending on how my physical hands were lying on my bed at the beginning of my bion-body projection, and depending on the actual value of use_this_send_distance in step 3—were typically, in effect, stitched together because one or more skin-cell bions in one finger along the length of that finger each had for its bion1, bion2, or bion3 a skin-cell bion in an adjacent finger, and as a result each finger was not capable of independent movement because of step 7. Also, ignoring for a moment what was just said about my projected bion-body fingers possibly being stitched together, perhaps my mind simply didn’t have any programming to move my bion-body fingers independently of each other, or to move them at all, and this lack of programming is reasonable because my projected bion-body’s hands, being composed of cell-controlling bions, are essentially useless during a bion-body projection, and cannot touch or handle the physical objects that our physical hands can handle.

The consideration stated in the previous paragraph about adjacent physical structures (fingers) being, in effect, stitched together, makes me think that to guarantee that the limbs in the afterlife bion-body are not stitched together, nor to one’s side in the case of one’s arms, it would be best in the case of an elderly person who is known to be dying to do the following shortly after his breathing has stopped (after the last breath, the heart will typically stop a few minutes later, and then by my guess, probably about five minutes after the heart has stopped, that person’s mind will run its procedure to form its afterlife bion-body): After his last breath, lay that person flat on his back with his feet about 12 inches (30 centimeters) apart from each other, and the arms laid at that person’s side but separated from the body’s side by at least an inch. The person’s head should also be turned if needed to face upward toward the ceiling (or sky if outside). Doing all this will probably give that person an afterlife bion-body that he will be the most psychologically comfortable with inhabiting. However, if a person’s physical body when that person’s afterlife bion-body formed was positioned in such a way that that person’s afterlife bion-body has its legs stitched together and/or its arms stitched to the bion-body’s sides, then, although not ideal, my guess is that this won’t have too large an impact on that person’s experience of the bion-body stage of the afterlife, because, assuming the third-eye and third-ear are activated, a person in his afterlife bion-body, after he gets used to the fact that he can see and hear the physical world, and is in a ghost-like body that cannot make contact with anything in the physical world, that person when awake during his bion-body stage of the afterlife is going to be more focused on where he can go and what he can see and hear in the physical world, than focused on whether or not he can move his bion-body limbs which cannot make contact with anything in the physical world anyway. See section 6.3 for more discussion of the bion-body stage of the afterlife.