1 of 83 Theory Of Structure In AI 2

By

Ian Beardsley

Copyright © 2018 by Ian Beardsley

ISBN: 978-1-387-56352-4

2 of 83

â€Š

Ultimately I came to derive the following,â€Ś

3 of 83 A peak at how that began,…

â€©

4 of 83

â€©

5 of 83

â€©

6 of 83

â€©

7 of 83

â€©

8 of 83

â€©

9 of 83

â€©

10 of 83

â€©

11 of 83

12 of 83 But we notice,..

Which means,â€Ś

13 of 83 The Masculine And Feminine Componentsâ€Š

14 of 83 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 83

â€©

16 of 83

â€©

17 of 83

â€©

18 of 83

â€©

19 of 83

â€©

20 of 83

â€©

21 of 83

â€©

22 of 83

â€©

23 of 83

24 of 83 What Is God?

By

Ian Beardsley

â€©

February 1, 2018

â€©

25 of 83

â€©

26 of 83

â€©

27 of 83

28 of 83 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).â€Š

â€©

29 of 83

â€©

30 of 83

â€©

31 of 83

â€©

32 of 83

â€©

33 of 83

â€©

34 of 83

â€©

35 of 83

â€©

36 of 83

â€©

37 of 83

â€©

38 of 83

â€©

39 of 83

â€©

40 of 83

â€©

41 of 83

â€©

42 of 83

â€©

43 of 83

â€©

44 of 83

â€©

45 of 83

46 of 83

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.â€Š

47 of 83 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.

48 of 83 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 substratelevel 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

49 of 83

â€©

AI and the Human Thought Process

50 of 83

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.â€Š

51 of 83 #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.â€Š

52 of 83 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:

53 of 83 #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.â€Š

â€©

54 of 83

55 of 83 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.

56 of 83 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.

57 of 83 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(" â€œ);

58 of 83

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.â€Š

59 of 83 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.

60 of 83 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); } }

61 of 83 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:

62 of 83

â€Š

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:

â€©

63 of 83

64 of 83 #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");

65 of 83 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"); } } } }â€Š

66 of 83 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â€Š

â€©

67 of 83

68 of 83 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,â€Śâ€Š

69 of 83 The Regular Hexagon, Shadow of Vector Equilibrium, and Closest Packed Spheres

70 of 83 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 twodimensional 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 fourfaced 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,â€Śâ€Š

71 of 83 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:

72 of 83 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,â€Ś

73 of 83 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,..

â€©

74 of 83

75 of 83 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) { int result = 0; System.out.print("Give me a: "); int a=IO.inputInteger(); System.out.print("Give me b: "); int b=IO.inputInteger(); while (b!=0) { result=result+a; b=b-1;

//1// //2// //3// //4// //5// //6// //7// //8// //9// //10// //11//

} IO.outputln("result = " + result);

//12// //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,…

76 of 83 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,…

77 of 83 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));

â€Š

78 of 83 Program in Java Finds Factorial in 13 Lines â€Š

â€©

79 of 83

80 of 83 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);

81 of 83 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.

82 of 83 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; scoop = scoop + 1 bag=bag-1 print(“Bag has %i scoops”, scoop);

//This means put scoop in cup’’ //We add one scoop to the amount of scoops we added// //We subtract one scoop from the bag

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):

83 of 83 The Author

Theory of Structure in AI 2

The author continues his search for structure in AI and its connection to biological life.

Theory of Structure in AI 2

Published on Feb 12, 2018

The author continues his search for structure in AI and its connection to biological life.

Advertisement