1 of 79

The Masculine And Feminine Components of Artificial Intelligence

By

Ian Beardsley

Copyright © 2018 by Ian Beardsley


 2 of 79

Ultimately I came to derive the following,…



 3 of 79

A peak at how that began,…


 4 of 79



 5 of 79



 6 of 79



 7 of 79



 8 of 79



 9 of 79



 10 of 79



 11 of 79



 12 of 79

But we notice,..

Which means,…
 13 of 79

The Masculine And Feminine Components


 14 of 79

In order to understand the male and female biological components and how they are
connected to artificial intelligence (AI) we need to look at the basic chemical theory of
biological molecules that describes testosterone and estrogen.

 15 of 79



 16 of 79



 17 of 79



 18 of 79



 19 of 79



 20 of 79



 21 of 79



 22 of 79



 23 of 79



 24 of 79

I had to develop a way to mathematically represent amino acids. I did it by dividing the amino
group by the acid group, then multiplying that ratio by the R group for each of the 20 standard
amino acids. Two amino acids—serine and glutamine—had near 100% correspondence with
elements, and those elements were carbon and silicon, which is perfect because carbon is at
the heart of artificial intelligence and silicon is at the heart of AI, and we want to explore the
connection of the natural (carbon) with the artificial (silicon) through the amino acids (building
blocks of natural life).

 25 of 79



 26 of 79



 27 of 79



 28 of 79



 29 of 79



 30 of 79



 31 of 79



 32 of 79



 33 of 79



 34 of 79



 35 of 79



 36 of 79



 37 of 79



 38 of 79



 39 of 79



 40 of 79



 41 of 79



 42 of 79

Wikipedia writes,…

Glucose is a simple sugar with the molecular formula C6H12O6, which

means that it is a molecule that is made of six carbon atoms, twelve
hydrogen atoms, and six oxygen atoms. Glucose circulates in the blood of
animals as blood sugar. It is made during photosynthesis from water and
carbon dioxide, using energy from sunlight. It is the most important source
of energy for cellular respiration. Glucose is stored as a polymer, in plants
as starch and in animals as glycogen.

And gives its molar mass as 180.0634 grams/mole

It further writes,…

Oleic acid is a fatty acid that occurs naturally in various animal and
vegetable fats and oils. It is an odorless, colorless oil, though commercial
samples may be yellowish. In chemical terms, oleic acid is classified as a
monounsaturated omega-9 fatty acid, abbreviated with a lipid number of
18:1 cis-9. It has the formula CH3(CH2)7CH=CH(CH2)7COOH.[2] The term
"oleic" means related to, or derived from, olive oil which is mostly
composed of oleic acid.

Fatty acids (or their salts) do not often occur as such in biological systems.
Instead fatty acids like oleic acid occur as their esters, commonly
triglycerides, which are the greasy materials in many natural oils. Fatty
acids can be obtained via the process of saponification.

And gives its molar mass as 282.74 grams/mole

Since olive oil is a healthy, unsaturated oil that has been used by humans
since ancient times in the Middle East, and, since glucose is the primary
sugar in life (circulates in blood, and is the most important source of energy
for cellular respiration) we look at them.

 43 of 79

I wrote in my AI Cookbook,…

Electron Volt: A unit of energy equal to the work done on an electron in accelerating it
through a potential of one volt. It is 1.6E10-19 Joules (Google Search Engine)

Volt: Potential energy that will impart on joule of energy per coulomb of charge that
passes through it. (Wikipedia)

Coulomb: The charge of 6.242E18 protons or 6.242E18 electrons.

Forward Bias: A diode (silicon) must have 0.7 volts across it to turn it on, 0.3 volts
(Germanium). This is called forward voltage. The forward voltage threshold is 0.6 volts.

(0.6 volts)(1.6E-19)=9.6E-20 Joules

This is the energy to turn on a diode, or the threshold of life for artificial intelligence. I
call it a bue (basic unit of energy).

+1.2eV —————|>—————————> out (9.6E-20 J, or 0.6 eV)

|
|
—————|>———|
|
|
R
|
|
—————————

A photon has to have a minimum energy of 1.2 electron volts to impart to an electron for it to
turn on the simplest of logic gates; a one on, one off, OR GATE, for there to be an output of one
“bue” (basic unit of energy electronic) , which 9.6E-20 Joules, as I have calculated it.

Use Planck’s Equation: E=hv where h= 6.626E-34 Joule seconds

v=2(9.6E-20)/(6.626E-34)=3.067E14 cycles per second

wavelength = lambda = c/v where c is the speed of light equal to 3E8 m/s

lambda = (3E8)/(3.067E-14) = 9.78E-7 meters

1 micrometer = 1E-6 meters

lambda ~ 1 micrometer (This is where the visible spectrum begins)

So we see the visible spectrum for one photon of light begins where the energy is 2 bue.

 44 of 79

I further wrote the following in the same book,…

Aerobic respiration requires oxygen (O2) in order to generate ATP. Although

carbohydrates, fats, and proteins are consumed as reactants, it is the preferred method
of pyruvate breakdown in glycolysis and requires that pyruvate enter the mitochondria in
order to be fully oxidized by the Krebs cycle. The products of this process are carbon
dioxide and water, but the energy transferred is used to break strong bonds in ADP as
the third phosphate group is added to form ATP (adenosine triphosphate), by substrate-
level phosphorylation, NADH and FADH2 (Wikipedia)

Simplified reaction:

C6H12O6 (s) + 6 O2 (g) → 6 CO2 (g) + 6 H2O (l) + heat

ΔG = −2880 kJ per mol of C6H12O6
(Wikipedia)

This is the heat (enthalpy) of the combustion of C6H12O6

(2,880,000 J)/(6.02E23 C6H12O6) =4.784E-18 J = basic unit of biological life

(4.784E-18 J)/(9.6E-20 J)=49.8~50

This says the basic energy unit of organic, or biological life, is about 50 times greater
than the basic energy unit of electronic life, or artificial intelligence.

That is 0.6(50)=30 electron volts = basic unit of energy for biological life.

So, we see the visible spectrum for one photon of light begins where the energy of the
photon is 2 “bue” electronic which is 100 “bue” biological and that that photon has a
wavelength of 1.0 micrometers.

This is all about vision in a robot or AI.

I now see we should do the same calculation we did for silicon diodes, for germanium
diodes, which turn on at 0.3 volts. We have,…

(0.3 volts)(1.6E-19 Joules/volt)=4.8E-20 Joules


 45 of 79

AI and the Human Thought Process



 46 of 79

As we progress from the Ancient Greek Mathematician, Pythagoras, to the

twentieth century American thinker, Buckminster Fuller, with his Synergetics, we
can develop a comprehensive theory of artificial intelligence systems.

 47 of 79

#include <stdio.h>
int main (void)
{
int a, b, result=0;
printf("What is a? ");
scanf("%i", &a);
printf("What is b? ");
scanf("%i", &b);
while (b!=0)
{
result=result+a;
b=b-1;
}
printf("result=%i\n", result);
}

a=int(raw_input("What is a? "));
b=int(raw_input("What is b? "));
result=0;
while (b!=0):
result=result+a
b=b-1
print("product= " + str(result));

Notice the program in C is 15 lines long, while in python it is 7

lines long. That is because the declaration of a variable, the scan,
and the prompt are all done in one statement in the python syntax.

 48 of 79

If we break down the program into the set of instructions for it, we
see how it symbolically demonstrates the human thought process for
doing the same thing. We also show what it does when it computes,
which explains the human thought process as well:
 49 of 79

#include <stdio.h>
int main (void)
{
int a, b, result=0;
printf("What is b? ");
scanf("%i", &b);
printf("What is a? ");
scanf("%i", &a);
while (b!=0)
{
result=result+1;
b=b-a;
}
printf("Quotient is %i\n", result);
}

b=int(raw_input("What is b? "));
a=int(raw_input("What is a? "));
result=0;
while (b!=0):
result=result+1;
b=b-a;
print("b divided by a is " + str(result));

Again we see the program takes 15 lines in C, and 7 in python. Reason

is python includes declaration, scan, and print in one line and python
uses an indentation scenario in place of curly brackets.

 50 of 79



 51 of 79

There are an infinite numbers of way to write the same program, but there is one way to do it
best, and that is, for example, if we are going to declare three variables a, b, result, we could do
each one on a separate line,…

int result;
int a;
int b;

But, that would increase the length of the program by three line instead of one,…

int result, a, b;

And, if we do the latter, we can find all the variables for the program in one line making it easier
to analyze. If we use the criteria for above, … with the criteria, for example, a curly bracket
goes on a line to itself, that is, we don't write,…

int main (void) {

but rather,…

int main (void)

{

Then we can compare one program in one language, say in C, to another program in another
language, say python, that does the same thing and say, …

multiplication of integers in C = 15 lines

multiplication of integers in python = 7 lines

Which takes us to analyzing the structure of a language. We find while one language requires
more lines for the same program, both have a common structure that allows us to learn a third
language easier once having learned the other two.

This takes us to learning something profound, what it is to think, or compute, reason, or

compare.

For instance, we have to declare our variables; it is not sufficient to ask the user for a, and b,
until we make it clear that, for example, the width of the triangle is a and b is its height when we
want to write a program that calculates it area. We could choose w and h instead, it does not
matter, as long as we say what w and h represent.

 52 of 79

Only by first looking at simple ideas, can we understand something as deeply complex as what
it is to be a human being. Pythagoras is credited with discovering the formula for the
hypotenuse of a right triangle. I think this formula is as central to mathematics as is Avogadro’s
determination of the mole is to chemistry. The pythagorean theorem allows us to determine the
distance between two points, or the magnitude of a vector; the mole allows us to determine the
mass of an atom of any element or compound, or the number of atoms in any mass of elements
or compounds. Therefore, since Pythagoras thought the most meaningful structure was the
tetractys, then we meet our needs by writing the program that generates it:

y=4;
x=0;
while (x!=4):
x=x+1
y=y-1
print(y*" " + x*"* ");
print(" “);

Running The Program:

We see the program to generate the tetractys is a x!=4 program. Let

us, to find the fundamental unit of our system, write the simplest
x!=4 program:

x=0
while (x!=4):
x=x+1;
print(x*"*");
print(" “);

It generates a 45-45-90 right triangle:

This is perfect because in

Buckminster Fuller’s Synergetics,
the triangle is the fundamental
unit out of which all else is
built. He says “Only the triangle
is inherently stable.” This is a
45-45-90 triangle, which is the
maximum range of a projectile.

 53 of 79

We see pythagoras was right in thinking the tetractys was the key to
the universe because it can be used to generate Buckminster Fuller’s
octahedron for three dimensional space:

y=4;
x=0;
while (x!=4):
x=x+1
y=y-1
print(y*" " + x*"* ");

u=0;
v=4;
while (v!=0):
v=v-1
u=u+1
print(u*" " + v*"* ");
print(" “);
 54 of 79

We see that we achieve the reflection of the tetractys about the

horizontal axis by changing x to y and y to x and x+1 to x-1 and
y-1 to y+1.

 55 of 79

We now have a method of numerically representing synergy. We define synergy of a

program as the lines needed to write a program in C, divided by the lines necessary to
write the same program in python. C is a more archaic language than python, but
outlines the basic structure of almost all other programming languages. Python is a
computational language. Thus,…

Lines In C
———————- = Synergy of Python = 15/7 = 2.41
Lines in Python

We do it like this because synergy means to do more with less.


 56 of 79

We increase the complexities of our programs incrementally starting with

print a statement

prompt and return

loop of a single variable

loop of two variables

looped array.

Print A Statement 5 Lines (prints statement)

#include <stdio.h>
int main(void)
{
printf("hello, world\n");
}

Prompt And Return 10 Lines (adds two numbers)

#include <stdio.h>
int main (void)
{
float a1, a2;
printf("Give me a1: ");
scanf("%f", &a1);
printf("Give me a2: ");
scanf("%f", &a2);
printf("a1+a2=%f\n", a1+a2);
}

Loop of a Single Variable 12 Lines (counts to a number)

#include<stdio.h>
int main (void)
{
int i, x=0;
printf("Give me an integer less than or equal to 20: ");
scanf("%d", &i);
while (x!=i)
{
x=x+1;
printf("%d\n", x);
}
}
 57 of 79

Loop of Two Variables 15 Lines (multiplication)

#include <stdio.h>
int main (void)
{
int a, b, result=0;
printf("What is a? ");
scanf("%i", &a);
printf("What is b? ");
scanf("%i", &b);
while (b!=0)
{
result=result+a;
b=b-1;
}
printf("result=%i\n", result);
}

Looped Array 21 Lines (arithmetic mean data set)

#include <stdio.h>
#include <math.h>
int main(void)
{
int n;
do
{
printf("How many numbers do you want averaged? ");
scanf("%d", &n);
}
while (n<=0);
float num[n], sum=0.0, average;
for (int i=1; i<=n; i++)
{
printf("%d enter a number: ", i);
scanf("%f", &num[n]);
sum+=num[n];
average=sum/n;
}
printf("average of your numbers is: %.2f\n", average);
}

These are the values: 5, 10, 12, 15, 21,…

They can be fit with:
 58 of 79

Thus we notice that as the complexity of a program increases, the

number of lines of it increase as the square root of its cube. Where
have we seen this before? It is Kepler’s Law of Planetary Motion:



 59 of 79



 60 of 79

#include <stdio.h>
int main(void)
{
printf("\n");
printf("\n");
printf("\n");
printf("5 lines, prints statement\n");
{
//#include <stdio.h>//
//int main(void)//
// { //
printf("hello, world\n");
// } //
printf("\n");
printf("\n");
printf("\n");
printf("10 lines, prompt and return, adds two numbers\n");
//#include <stdio.h>//
//int main(void)//
// { //
float a1, a2;
printf("Give me a1: ");
scanf("%f", &a1);
printf("Give me a2: ");
scanf("%f", &a2);
printf("a1+a2=%f\n", a1+a2);
// } //
printf("\n");
printf("\n");
printf("\n");
printf("12 lines, loop of a single variable, counts to a
number\n");
//#include <stdio.h>//
//int main(void)//
{
int i, x=0;
printf("Give me an integer less than or equal to 20: ");
scanf("%d", &i);
while (x!=i)
{
x=x+1;
printf("%d\n", x);
}
printf("\n");
printf("\n");
printf("\n");
 61 of 79

printf("15 lines, loop of two variables, multiplication\n");

//#include <stdio.h>//
//int main(void)//
{
int a, b, result=0;
printf("What is a? ");
scanf("%i", &a);
printf("What is b? ");
scanf("%i", &b);
while (b!=0)
{
result=result+a;
b=b-1;
}
printf("result=%i\n", result);
}
printf("\n");
printf("\n");
printf("\n");
printf("21 lines, loop of array, arithmetic mean\n");
//#include <stdio.h>//
//int main(void)//
{
int n;
do
{
printf("How many numbers do you want averaged? ");
scanf("%d", &n);
}
while (n<=0);
float num[n], sum=0.0, average;
for (int i=1; i<=n; i++)
{
printf("%d enter a number: ", i);
scanf("%f", &num[n]);
sum+=num[n];
average=sum/n;
}
printf("average of your numbers is: %.2f\n", average);
printf("\n");
printf("\n");
}
}
}
}

 62 of 79

5 lines, prints statement

hello, world

10 lines, prompt and return, adds two numbers

Give me a1: 2.32
Give me a2: 7.68
a1+a2=10.000000

12 lines, loop of a single variable, counts to a number

Give me an integer less than or equal to 20: 5
1
2
3
4
5

15 lines, loop of two variables, multiplication

What is a? 3
What is b? 7
result=21

21 lines, loop of array, arithmetic mean

How many numbers do you want averaged? 4
1 enter a number: 2.5
2 enter a number: 3.2
3 enter a number: 2.8
4 enter a number: 2.7
average of your numbers is: 2.80

 63 of 79



 64 of 79

Just as that fundamental unit is a tetrahedron in Synergetics, that is, can generate the other
volumes used in this system of design, as whole number volumes, the crux of synergetics is the
cuboctohedron, also called the vector equilibrium, or truncated cube. Its shadow is the regular
hexagon. This is why it is the crux, because while in three dimensions, the cuboctohedron is the
shape of closest packed spheres, that is, it is generated by packing spheres such that each one
is touching another, the regular hexagon is the closest packing of circles in two dimensions and
is the shadow of the cubeoctahedron. In both cases we mean of circles and spheres of equal
radii.

As synergetic is experiential in its derivations, that is putting together rods with flexible rubber
corners, flex corners, and flexing them in different shapes, we find we can generate the forms in
python with source code experientially, by adjusting the values of our variables,…

Here we generate our tetractys with variables u and v, and remember that to turn it into an
octahedron, we need to reflect it by trading the u value with the x value, the v value with the y
value, and making u=u-1 into its reverse, x=x+1 and v=v+1 into its reverse, y=y-1. Here I have
written the program not as a k!=4 program, but a k!=0. program. We notice in the form below
we need to cut off the tops and bottoms of the octahedron to make them flat, so we adjust the
numbers, accordingly, and we have a regular hexagon,…

 65 of 79

The Regular Hexagon, Shadow of Vector Equilibrium, and Closest Packed Spheres
 66 of 79

Building the Regular Solids

The tetractys, which is an equilateral triangle is our two dimensional

tetrahedron.

The tetractys, with its reflection, is a diamond or our two-

dimensional octahedron.

The tetrahedron with a truncated tetractys (a trapezoid) and an

inverted tetractys (reflection) is a pentagon or two dimensional
dodecahedron.

The square is the two-dimensional hexahedron, or cube.

The hexagon is our two-dimensional cubeoctahedron, or two dimensional

vector equilbrium.

Tetra means four and hedron means face. So, a tetrahedron is a four-
faced solid. Octa means eight. So, an octahedron is an eight-faced
solid. Hexa means six and gon means side. So, a hexagon is a six-sided
polygon. Thus a hexahedron is a six-faced solid, which is a cube. Poly
means many, so a polygon is a many-sided geometry.

The five regular solids are the polyhedrons with faces all made of
equal sided, equal-anguled polygons that are the same. They are the
tetrahedron, the octahedron, the hexahedron, the dodecahedron, and the
icosahedron.

Seen below are the five regular solids with the vector equilibrium,…

 67 of 79

We must now make a pentagon. We start by making the tetractys

(equilateral triangle, or shadow, or silhouette of a tetrahedron).

u=4;
v=0;
while (u!=0):
u=u-1
v=v+1
print(u*" " + v*"* ");

Then we truncate its top,…

u=4;
v=1;
while (u!=0):
u=u-1
v=v+1
print(u*" " + v*"* “);

Then we add in a reflection of the tetractys about the horizontal axis,…and we have a
pentagon:
 68 of 79

u=4;
v=2;
while (u!=0):
u=u-1
v=v+1
print(u*" " + v*"* ");

x=0;
y=6;
while (y!=0):
x=x+1
y=y-1
print(x*" " + y*"* ");

Let us make our square, or cube, or hexahedron,…

 69 of 79

Since the program to do multiplication of two integers has the same number of lines as the
program to do division of a larger integer by a smaller integer that divided evenly, and since
multiplication and division are two of the most fundamental operations upon which a computer is
built, then if we want to compare one language to another, then these programs are perfect to
meet those ends if we use the same idea behind the algorithms in each language. We have,…

In C

#include <stdio.h>
int main (void)
{
int a, b, result=0;
printf("What is a? ");
scanf("%i", &a);
printf("What is b? ");
scanf("%i", &b);
while (b!=0)
{
result=result+a;
b=b-1;
}
printf("result=%i\n", result);
}

In Python

a=int(raw_input("What is a? "));
b=int(raw_input("What is b? "));
result=0;
while (b!=0):
result=result+a
b=b-1
print("product= " + str(result));

We do the following,..
 70 of 79



 71 of 79

Let us introduce a third language — Java

import comp102x.IO;
/**
* multiplies two integers.
*
* @author (Ian Beardsley)
* @version (version 1.0)
*/
public class product
{
// instance variables - replace the example below with your own

/**
* Constructor for objects of class multiplication
*/
public product()
{
// initialise instance variables

public static void main(String[] args) //1//

{ //2//
int result = 0; //3//
System.out.print("Give me a: "); //4//
int a=IO.inputInteger(); //5//
System.out.print("Give me b: "); //6//
int b=IO.inputInteger(); //7//
while (b!=0) //8//
{ //9//
result=result+a; //10//
b=b-1; //11//

} //12//
IO.outputln("result = " + result); //13//
} //14//
} //15//

We see it is a 15 line program like it was in C, therefore java has the same complexity
rating as C. We have,…

 72 of 79

Complexity C = 1
Complexity Java = 1
Complexity Python =0.6

Let’s apply our theory to the next operation up from multiplication and division — The
Factorial,…

 73 of 79

Program in C finds Factorial in 13 Lines

#include <stdio.h>
int main(void)
{
int i=1, fact=1, N;
printf("Find the factorial of what integer? ");
scanf("%i", &N);
while (i!=N)
{
i=i+1;
fact=fact*i;
}
printf("factorial=%i\n", fact);
}

jharvard@appliance (~): cd Dropbox

jharvard@appliance (~/Dropbox): make factorial
clang -ggdb3 -O0 -std=c99 -Wall -Werror factorial.c -lcs50 -lm -o factorial
jharvard@appliance (~/Dropbox): ./factorial
Find the factorial of what integer? 5
factorial=120
jharvard@appliance (~/Dropbox):

Program in Python Finds Factorial in 6 Lines

i=1; fact=1;
N=int(raw_input("Find the factorial of what number: "));
while (i!=N):
i=i+1
fact=fact*i
print("factorial=" + str(fact));



 74 of 79

Program in Java Finds Factorial in 13 Lines



 75 of 79



 76 of 79

We look at how the syntax varies, but the structure remains the same from language to
language.

In C we specify a library that has the object code that our source code will draw upon,…

#include <stdio.h>

We then can specify where the program begins, with…

int main(void)

In python there is no need for specifying a library, or indicating where the program begins.

In C we declare our variables, in python we initialize them. When we declare variables in C, we

specify whether they are integers (int), or floating decimals (float), or characters (chars) such as
letters,…

int i, n, result;
float i, n;
char name[15];

Or in python,…

i=1; fact=1;

Next, in C, we prompt the user and get input to give to the computer. To do this we use prompt
with a printf() function, then tell the computer to wait for input from the user with a scanf()
function. Once that is inputed, it is stored in the computer’s memory for later use. In python
declaring the variable, specifying its type, prompting the user, and telling the computer to wait
for input are all done in one fell swoop. That is why the complexity rating of python is so low. It is
done like this in C,…

printf(“Give me an int: “);

scanf(“%i”, &i);

and in python like this,…

i=int(raw_input(“Give me an int: “));

Next, to loop, we write in C,…

while (i!=0)
{
result=result+1;
i=i-1;
}
printf(“Your result is %i”, result);
 77 of 79

Where we write in python,…

while (i!=0):
result=result+1
i=i-1
print(“Your result is” + str(result));

making use of indentation, thus eliminating the need for a open curly bracket, and, as such
saving a line of code.

 78 of 79

Let’s look at the way we do things, and what we are thinking when we do them. To begin, let’s
say we want to know how many scoops of rice are in a bag. We begin by filling by,…

bag=3;
scoop = 0; //This is where we begin///

while (bag!=0) // This means while bag not empty//

{ //Do the following//

Put scoop of rice in cup; //This means put scoop in cup’’

scoop = scoop + 1 //We add one scoop to the amount of scoops we added//
bag=bag-1 //We subtract one scoop from the bag
print(“Bag has %i scoops”, scoop);

If the bag is not empty the while condition is not met, so we go back and add another scoop,
then add one again to scoop, and subtract another scoop from bag. Let’s say the bag has three
scoops of rice. In this case, the bag is not empty, so the while condition is not met, and we put
another scoop in the cup and subtract another one from the bag. The while condition is now
met, so we can exit the loop and go to the next step, which is print bag has x scoops (%i) and x
is filled with the answer scoop, which was the amount tallied in scoop=scoop+1, in this case
three.

Let’s write the program, and run it,…

#include <stdio.h>
int main(void)
{
int bag=3, scoop=0;
while (bag!=0)
{
scoop=scoop+1;
bag=bag-1;
}
printf("\n");
printf("Bag has %i scoops\n", scoop);
printf("\n");
}

Running the program (./rice) looks like this,…

jharvard@appliance (~): cd Dropbox

jharvard@appliance (~/Dropbox): ./rice

Bag has 3 scoops

jharvard@appliance (~/Dropbox):
 79 of 79

The Author