This is an in-progress document, however I feel it contains enough information to justify “premature publishing”

The Theory Of Everything: God’s Program, Written in C

 

 

By Marty Wollner

08-Dec-2012 (a)

 

discflicker.com

 

This easy-to-read book:

 

·        Explains how the Universe works on its most fundamental levels

 

·        Answers all unknown questions about physics, infinity, reality, and creation

 

·        And by using “The Holy Grail of Science” as a simple programming example,

Teaches the reader the basics of C Programming Language Development under Windows

 

 

 


 

 

 

 


Learn C entirely for FREE! This book teaches C programming under Windows by utilizing the very cool and totally free-of-charge open-source development software package known as Pelles C IDE.

 

 

 

 

 

 

 

 

Alternative media:

 

This document is freely available in the following formats:

 

 

 

The Theory of Everything: God’s Program, Written in C

Presented as a Web Page  a.k.a. a Hyper Text Markup

(a .htm   file)

These files may also be type .html for Hyper Text Markup Language.

 

 

Due to the size of this document, I recommend DOWNLOADING one of these FILE TYPES by right-clicking the link and “Saving as” a LOCAL COPY, then viewing the local copy.

 

Ya see, you’re already learning!

 

 

 

 

 

 

 

 

 

 

Scientists in a hurry:

Click HERE and follow these links for a condensed summary of the Theory-Of-Everything, including a one-page Pseudo-code rendition.

 

 

 

Table of Contents

 

 

The table of contents itself is a concise overview of this book.

 

The Glossary (included at the end of this book) also provides an overview wherein the TERMS introduced in this book, in the order in which they’re introduced, provide a reading pathway for anyone to learn this stuff starting with zero computer programming skills.

 

Click HERE to skip the Table of Contents

 

 


The Theory Of Everything: God’s Program, Written in C.............. 1

 Alternative media:................................................................................................ 2

 Scientists in a hurry:........................................................................................... 4

 Table of Contents.................................................................................................. 5

 Colors and fonts used in this book:......................................................... 23

 Brief overview:...................................................................................................... 24

 Reading this book................................................................................................ 26

 Background required….................................................................................. 26

 Hyperlinks, footnotes, and humor…....................................................... 27

 This book is stand-alone and “100% Scientific”???............................ 28

 Clarification of my use of the term “100% scientific”..................... 29

 Implications and Fanatical Expectations............................................ 30

 Seriously, though …............................................................................................ 31

 *** The book starts here ***........................................................................... 31

1 The Current State of Scientific Discovery........................................ 32

2 Computational algorithms........................................................................ 33

2.1 Marty’s qualifications, Part 1............................................................... 33

2.2 Simple lists and ordered lists................................................................ 34

2.2.1 Bagels and lox:................................................................................................. 34

2.2.2 Cat of the week:............................................................................................... 36

2.3 Computer list records, array lists and data tables................. 37

2.4 Introduction to God’s Program’s VP list......................................... 40

2.5 Have a drink on me........................................................................................ 42

2.5.1 The Offer:......................................................................................................... 42

2.5.2 Organization of algorithms like TheOffer:....................................................... 46

2.5.3 Notes on TheOffer:........................................................................................... 47

2.5.4 TheDrinkOrder:................................................................................................ 48

2.5.5 A complete rendition of TheDrinkOrder:......................................................... 50

2.5.6 A more structured rendition of TheDrinkOrder:.............................................. 51

2.5.7 Notes about TheDrinkOrder:............................................................................ 52

2.5.8 Math Operators:............................................................................................... 54

2.5.9 Comparison Operators:.................................................................................... 55

2.5.10 Constructions and Renditions:........................................................................ 56

2.5.11 Program line counting:................................................................................... 58

2.5.12 Your first Spot Quiz:....................................................................................... 59

2.5.13 Are we OK?.................................................................................................... 60

2.6 Back to the point!.......................................................................................... 63

2.7 An IF statement in Visual Basic: DontDvideByZero....................... 64

2.7.1 Notes on DontDivideByZero:............................................................................ 65

2.8 A Second rendition of DontDivideByZero, using a GOTO........... 67

2.8.1 Notes on DontDivideByZero, second rendition:............................................... 68

2.8.2 DontDivideByZero, second rendition showing line numbers:........................... 69

2.8.3 Notes on DontDivideByZero, second rendition showing line numbers:........... 70

2.9 A Third rendition of DontDivideByZero… OOPS!............................ 71

2.9.1 Notes on DontDivideByZero, third rendition:.................................................. 72

2.9.2 Code reviews, code segment walkthroughs:.................................................... 74

2.10 Division by zero, infinite looping....................................................... 79

2.11 Programming digital simulations of a Universe........................ 80

2.12 Programming digital simulations of our Universe.................. 81

3 Marty’s Contentions About the Universe:.......................................... 83

3.1 Emergence of ALL behaviors arises from the sub-atomic level:           83

3.2 Virtual Reality:............................................................................................... 84

3.2.1 Proof of VR #1… Instantaneous connectivity between disparate particles:.... 85

3.2.2 Proof of VR #2 … the size, mass, and locations of fundamental particles:...... 87

3.2.3 Bonus proof #3 … Jumping and multiple-concurrent locations:...................... 88

3.2.4 My Virtual Reality RANT:................................................................................. 89

3.3 The Universe IS DIGITAL:................................................................................ 90

3.4 Infinity is Impossible.................................................................................... 93

3.5 The “Fabric of Space” IS the Virtual Grid of Integer Locations 94

3.6 The “Fundamental Particles” are NUMBERS!..................................... 95

3.6.1 This, right here, marks the boundary between classical physics and virtual reality.        95

3.7 One Algorithm Operates the Entire Universe.................................. 96

3.8 The algorithm is VERY SIMPLE................................................................... 97

3.8.1 How can it be so simple?.................................................................................. 98

3.8.2 My answers to how also involve an understanding of the why:..................... 100

3.8.3 Why?............................................................................................................... 101

3.8.4 Why = How and How = Why:........................................................................ 102

3.9 Real Matter Comes from the Assignment of MASS to Atoms When They’re Constructed from “Fundamental Particles”..................................... 103

3.10 1-2-3 Summary of a Digital Approach to Understanding the Universe:        104

3.10.1 The fabric of space is the grid itself.............................................................. 104

3.10.2 The content of “matter” in this space (at its most fundamental level) is numerical information in a list.................................................................................................................................. 104

3.10.3 The motion of this content occurs according to a simple algorithm enacting upon all the information in the list from step to step.......................................................................................... 104

4 Introduction to Simple Digital Universes....................................... 105

4.1 God’s Program’s VP list............................................................................ 105

4.1.1 Quick review:.................................................................................................. 105

4.2 Visualizing the Virtual Universe Represented by a VP list.... 106

4.3 Notes about this example........................................................................ 107

4.4 Visualizing Motion Through Time in a Virtual Universe......... 108

4.5 Example of Motion: M4P1DPOU:1 and M4P1DPOU:2........................... 109

4.6 Visualizing the Example of Motion: M4P1DPOU:1 -> M4P1DPOU:2 110

4.7 Believing in Virtual Reality................................................................... 111

4.8 The Algorithm of Motion for Example M4P1DPOU....................... 112

4.9 Assignment # 1................................................................................................ 113

5 Introduction to programming simple Universes: LEARN C IN any case!!      114

5.1 An Algorithm is a List of Instructions............................................ 114

5.2 Statements: Comments and Actual Instructions;..................... 115

5.3 Multiple Algorithms and a Beef Jerky-Run.................................... 117

5.4 Modularization:........................................................................................... 119

6 Emergence............................................................................................................ 120

6.1 Top-Down approach:................................................................................... 120

6.1.1 Estimates: all we can do with what we have.................................................. 120

6.2 Emergence from basic Causality:....................................................... 121

6.3 Working from the bottom –> UP!......................................................... 122

6.4 Everything emerges from the bottom; Marty’s qualifications, Part 2         123

7 WaterFetch; a Water Bottle Fetch Example .................................. 124

7.1 Back to programming!.............................................................................. 124

7.2 Spot Quiz #2...................................................................................................... 126

8 A C-language program for M4P1DPOU:1->2.......................................... 129

8.1 Our first C-code example … Z_OctoC_1.c......................................... 129

8.2 Notes and lessons about the example Z_OctoC_1.c:.................. 131

8.2.1 The opening statements:................................................................................. 131

8.2.2 Notes about accessing the example files presented in this book:................... 132

8.2.3 C Standards and Portability:.......................................................................... 135

8.2.4 C-Standards for naming algorithms, modules and files:................................ 136

8.2.5 More C Standards:......................................................................................... 137

8.2.6 How the DECLARATION statements work in M4P1DPOU:1->2 :.............. 138

8.2.7 How the EXECUTABLE statements in work in M4P1DPOU:1->2 :............ 139

9 Alternative Approaches to Programming M4P1DPOU:1->2....... 142

9.1 Multiple renditions:................................................................................... 142

9.2 Clarifying the term Functionality................................................... 143

9.3 Hardware independence:.......................................................................... 144

9.4 Scientific definitions for accomplishing the same thing in a number of ways:  145

9.5 Most concise vs. readability:................................................................ 146

10 Executing M4P1DPOU under Processing (for the JAVA version of this book)        147

11 Executing M4P1DPOU under Pelles C IDE............................................ 148

11.1 IMPORTANT NOTE: NO COMPUTER IS NEEDED!....................................... 148

11.2 What is an I.D.E.?.......................................................................................... 149

11.3 Pelles C IDE..................................................................................................... 149

11.4 Installation directions for Pelles C IDE:...................................... 150

11.5 How Pelles C IDE controls multiple source files and multiple program creations:.............................................................................................................. 151

11.6 Building Z_OctoC_1 in Pelles C IDE..................................................... 152

11.6.1 Creating a new project in Pelles C IDE named Z_OctoC_1:...................... 152

11.6.2 Loading the example Z_OctoC_1.c source code file into Pelles C IDE:...... 153

11.7 File types used in building a .exe program from a .c source code file        155

11.8 Building an executable program (a .exe file) from a .c source code module:     156

11.8.1 COMPILING:............................................................................................... 156

11.8.2 LINKING:..................................................................................................... 157

11.9 Building Z_OctoC_1.exe from Z_OctoC_1.c under Pelles C IDE: 158

11.10 Executing Z_OctoC_1.exe on your computer:............................ 159

11.11 Summarizing the 4 steps to create and execute a C program from start to finish:........................................................................................................................ 161

11.12 Program development cycles.......................................................... 163

11.13 Review of what we’ve accomplished thus far......................... 164

11.14 HEY! WHAT HAPPENED WHEN M4P1DPOU:1->2 WAS RUN, ANYWAY? 165

12 Program Output.............................................................................................. 167

12.1 Is observing optional?............................................................................ 167

12.2 Do you have to actually SEE IT to know that it occurred? 168

12.3 Is observing interfering?...................................................................... 169

12.4 Adding output statements to M4P1DPOU:1->2............................... 170

12.4.1 Another rendition of M4P1DPOU:1->2 … Z_OctoC_1_A:........................ 170

12.4.2 Notes about Z_OctoC_1_A.c:...................................................................... 173

12.5 Loading, building and running Z_OctoC_1_A on Pelles C IDE 176

12.5.1 Create a new project named Z_OctoC_1_A:............................................... 177

12.5.2 Load the example Z_OctoC_1_A.c source code file:................................... 178

12.5.3 Building Z_OctoC_1_A.exe from Z_OctoC_1_A.c :.................................... 179

12.5.4 Executing Z_OctoC_1_A.exe :..................................................................... 180

12.5.5 About Application Program Files................................................................. 181

12.5.6 Running the .exe application file via the file explorer:................................. 182

12.5.7 Using an operating system Command Prompt Window:............................. 184

12.5.8 Running the .exe application file directly from an operating system Command Prompt Window:        186

12.6 Handling the output from Z_OctoC_1_A.exe................................ 187

12.6.1 Old-world ways:............................................................................................ 187

12.6.2 Program output re-direction:....................................................................... 189

12.6.3 Using .bat files to save typing and aid testing:............................................ 191

12.7 How Z_OctoC_1_A_TEST_1.bat works................................................. 192

12.7.1 Z_OctoC_1_A_TEST_1.bat.......................................................................... 192

12.7.2 Command procedures are like programming language algorithms............. 194

12.7.3 Using Z_OctoC_1_A_TEST_1.bat to avoid using Command Prompt Windows entirely           196

12.8 REVIEW of program creation, testing, releasing, execution, and output examination:......................................................................................................... 197

12.8.1 Create the program under Pelles C IDE:..................................................... 197

12.8.2 Re-Edit, Re-Run and Re-Test the program under Pelles C IDE until its exactly what we want to Release................................................................................................................................. 198

12.8.3 Executing the application............................................................................. 199

12.9 Accessing the output file Z_OctoC_1_A_Test_1.txt :................. 201

13 Backing up two steps… Hello World, and how C FUNCTION calls work      202

13.1 Hello, world !.............................................................................................. 203

13.2 Spot Quiz #3.................................................................................................... 205

13.2.1 On your own, build and run Z_HelloWorld.exe using Pelles C IDE :.......... 205

13.2.2 Spot Quiz #3 Solutions:................................................................................. 206

13.3 Operating system commands to run applications and command procedures:  208

13.4 Spot Quiz #3 Extra Credit Solution:.................................................. 209

13.5 Notes about Z_HelloWorld.c:.............................................................. 211

13.6 Examining the file’s contents … how the printf statement works: 213

14 How C VARIABLES work................................................................................. 216

14.1 Binary expansion of number capacity in computer variables            217

14.2 Expressions in C.......................................................................................... 218

14.2.1 Spot quiz #4:................................................................................................. 220

14.3 Using expressions in the executable statements in M4P1DPOU:........... 222

14.3.1 Another rendition of M4P1DPOU:1->2 … Z_OctoC_1_B:......................... 222

14.3.2 Notes about Z_OctoC_1_B:......................................................................... 225

14.3.3 Spot quiz #5:................................................................................................. 226

14.4 Arrays in C..................................................................................................... 227

14.4.1 Another rendition of M4P1DPOU:1->2 … Z_OctoC_1_C:........................ 227

14.4.2 Notes about Z_OctoC_1_C:......................................................................... 230

14.4.3 Spot quiz #6:................................................................................................. 234

14.5 Constants in C............................................................................................. 235

14.5.1 Another rendition of M4P1DPOU:1->2 … Z_OctoC_1_D:........................ 236

14.5.2 Notes about Z_OctoC_1_D:......................................................................... 239

15 Program Control.......................................................................................... 240

15.1 Conditional and “GO TO” Statements.............................................. 240

15.1.1 GOTO statements:........................................................................................ 241

15.1.2 Conditional branching statements… Decision-making:............................... 241

15.1.3 Using a conditional branching statement in the beer-fetch example:.......... 242

15.2 The concept of LOOPING.......................................................................... 243

15.2.1 Looping constructs:...................................................................................... 244

15.2.2 How the do-loop works in C:........................................................................ 245

15.2.3 Another rendition of M4P1DPOU:1->2 … Z_OctoC_1_E:........................ 246

15.2.4 Notes about Z_OctoC_1_E:......................................................................... 249

15.3 Light at the end of the tunnel?.......................................................... 250

16 Errors in art of programming............................................................. 251

16.1 Building the Great Pyramids of Egypt............................................ 251

16.2 What, no recourse?................................................................................... 252

16.3 A good clean start – do it right the FIRST time.......................... 253

16.4 Classes of programming errors....................................................... 254

16.5 Compile-time errors................................................................................. 255

16.6 Troubleshooting compile-time errors:.......................................... 256

16.6.1 Error messages from the compiler............................................................... 256

16.6.2 Spot Quiz #7:................................................................................................ 256

16.6.3 Error messages in general............................................................................ 257

16.6.4 Error messages from the linker.................................................................... 257

16.7 Run-time errors.......................................................................................... 258

16.8 Troubleshooting Run-time errors:................................................... 259

16.9 Run-Time Trouble Runs Deep.................................................................. 260

16.10 Spot quiz #8:................................................................................................. 261

17 Completing Assignment #1........................................................................ 262

17.1 Z_OctoC_2_10000_A.c................................................................................... 262

17.2 Notes about Z_OctoC_2_10000_A.c....................................................... 265

17.2.1 Nesting of Looping Constructs..................................................................... 265

17.2.2 Use of the nested loops:................................................................................ 266

17.3 Testing Z_OctoC_2_10000_A.c.................................................................. 268

17.3.1 Build Z_OctoC_2_10000_A.exe on Pelles C IDE:....................................... 268

17.4 Altering code for testing purposes................................................ 269

17.4.1 EDITING the source code............................................................................ 269

17.4.2 An unexpected lesson to be learned – CODE CONTROL............................ 271

18 Source Code Control................................................................................... 272

18.1 The Accidental introduction of BUGS due to loss of Source Code Control       272

18.2 BE CAREFUL WITH YOUR CODE!.................................................................. 273

18.2.1 My more-than-obvious point:....................................................................... 273

18.2.2 In this particular case:.................................................................................. 273

18.3 Source Code Control Libraries.......................................................... 274

18.3.1 Odds are: things get mixed up...................................................................... 274

18.3.2 For example:................................................................................................ 275

18.4 ACCOUNTABILITY = A good thing.......................................................... 276

19 Arrays of STRUCTURES: Using Relational Analysis to add ATTRIBUTES to the VP list................................................................................................................................ 277

19.1 HeatLevel, Mass, and the underlying theme by which the Universe operates     277

19.2 Adding HeatLevel and Mass attributes to the VP list............ 278

19.3 Relational Analysis................................................................................. 279

19.3.1 A list index is a Primary Key:....................................................................... 279

19.3.2 Primary keys in database tables:.................................................................. 280

19.3.3 Key data fields vs. attribute data fields:....................................................... 281

19.4 Standardized descriptions for database record structures: 282

19.5 Notes on the above example standardized description for database record structures:............................................................................................................ 283

19.5.1 Database name, field names:........................................................................ 283

19.5.2 Data table FIELD TYPES: Key, Attribute, PK, SAKey, and FK................. 285

19.6 Implementing assignment 1 using an array of structures. 287

19.7 Z_OctoC_2_10000_B.c................................................................................... 287

19.8 Notes about Z_OctoC_2_10000_B.c....................................................... 291

19.8.1 C Structure definitions.................................................................................. 291

19.8.2 Representing the VP_List  as an array of structures:................................... 292

19.8.3 Referencing data from a C record structure................................................ 293

19.8.4 What really happens when Z_OctoC_2_10000_B.exe  gets executed?........ 294

20 Organizing our project by the process of Modularization: Implementing Functionality......................................................................................................... 295

20.1 Issues of module control..................................................................... 295

20.1.1 Control of our source code modules............................................................. 295

20.1.2 Control of the readability of our source code modules................................ 296

20.2 MODULARIZATION TO THE RESCUE!!!........................................................ 297

20.2.1 Modularization will help us in several ways right here:............................... 297

20.2.2 Teaching modularization by example........................................................... 297

21 Tracking the values of Heat and Mass: Z_OctoC_50_A.............. 298

21.1 Upgrade needed:.......................................................................................... 298

21.2 Z_OctoC_2_50_A.c......................................................................................... 298

21.3 Notes about Z_OctoC_2_50_A.c............................................................. 303

21.3.1 Initialization of the new structure members................................................. 303

21.3.2 Z_OctoC_2_50_A.c  Output statements....................................................... 305

21.3.3 Z_OctoC_2_50_A.exe  Output..................................................................... 306

21.3.4 Spot Quiz:..................................................................................................... 307

21.4 Designing reports correctly.............................................................. 308

21.4.1 Reports from program output....................................................................... 308

21.4.2 The rules of report printing.......................................................................... 308

21.4.3 This report sucks........................................................................................... 308

21.5 WHAT ARE WE DOING, Anyway?............................................................... 309

21.5.1 Keeping focus... HERE ARE OUT GOALS................................................... 309

21.5.2 Considering requirements for program output............................................ 310

21.6 Enhancements needed to Z_OctoC_2_50_A..................................... 311

22 MartyBus Protocol:  Z_OctoC_2_50_B.................................................. 312

22.1 Z_OctoC_2_50_B.c......................................................................................... 312

22.2 Notes on  Z_OctoC_2_50_B.c................................................................... 318

22.2.1 Here's the output:......................................................................................... 318

22.2.2 Compare this to the way we did it before:................................................... 318

22.3 Advantages of a self-describing protocol like MartyBus 319

23 Unlimited VP_List size: Z_OctoC_2_50_C............................................... 320

23.1 Z_OctoC_2_50_C.c......................................................................................... 320

23.2 Notes on Z_OctoC_2_50_C.c.................................................................... 326

23.2.1 Transparent changes:................................................................................... 326

23.2.2 Our design as a report still sucks, though.................................................... 326

23.2.3 (6): Fixing our output layout to fit 132 column:.......................................... 327

23.2.4 Make it so?................................................................................................... 327

24 Modularization:  Z_OctoC_2_50_D.......................................................... 328

24.1 “Modularize me, PLEASE!!!” Part 1: Data list initialization functions            328

24.1.1 Primary guideline number one for modularization:..................................... 329

24.2 “Modularize me, PLEASE!!!” Part 2: Printing functions............. 330

24.2.1 Primary guideline number two for modularization:..................................... 331

24.3 Overhead of making function calls.............................................. 332

24.3.1 Functional overhead = 0:............................................................................. 333

24.3.2 Performance overhead = Definitely YES..................................................... 333

24.3.3 Questions: Is it always worth it to modularize?How granular does this get? 334

24.3.4 Answer: Modularization is not derived just by optimizing line counts alone, its about CATEGORIZATION OF FUNCTIONALTITY........................................................ 334

24.4 Z_OctoC_2_50_D.c......................................................................................... 336

24.5 Notes on Z_OctoC_2_50_D.c.................................................................... 344

24.5.1 Stuff got moved around:............................................................................... 344

24.5.2 C function prototypes:.................................................................................. 344

24.5.3 Calling functions........................................................................................... 345

25 Modularization of C-file standards:  Z_OctoC_2_50_E............. 347

26 Levels of Scope:  Planning Z_OctoC_2_50_F....................................... 348

26.1 So far, one level of scope:.................................................................... 348

26.2 Adding more programs at the existing level of scope:......... 349

26.2.1 Cloning programs that used modularized functions:................................... 349

26.2.2 Problems with cloning hog-wild................................................................... 350

26.3 Alternatives to cloning: Using modularization upon the project itself 351

26.3.1 The rules:...................................................................................................... 351

26.3.2 In our Z_OctoC_V1_2_50_F.c, case:........................................................... 351

26.3.3 Sharing common modules “from where they lay”?..................................... 352

26.3.4 Example of cloning, whole-hog:................................................................... 353

26.4 What are we really trying to accomplish? DEFINE LEVELS OF SCOPE  355

27 MartyLib............................................................................................................... 356

27.1 Location in-scope...................................................................................... 356

27.1.1 Make it so? Not right now:........................................................................... 360

28 Levels of Scope:  Z_OctoC_2_50_F............................................................. 361

28.1.1 Executing the For-NEXT loop:.................................................................... 363

29 Assignment #2: Re-do assignment #1 and make it work with double-buffering......................................................................................................................................... 365

30 Standardizing descriptions of digital Universes..................... 366

31 Another example: M7P1DPOU..................................................................... 367

31.1 Important message for C programming language students: 367

31.2 Introduction to M7P1DPOU.................................................................... 368

31.3 A quick review and a 1-2-3 plan.......................................................... 369

31.4 Visualizing the first 4 tics of time in M7P1DPOU......................... 370

31.4.1 Tick 0: The pre-big-bang state… co-occupying plasma:.............................. 370

31.4.2 Tick 1: Nuclear Energy sprays Plasma Apart:............................................. 372

31.4.3 Pseudo-code for the Nuclear rule of motion:............................................... 373

31.4.4 Tick 2: Fusion of Free Hot Plasma into Bound Components:..................... 375

31.4.5 What the FUSION force rule does:.............................................................. 376

31.4.6 Pseudo-code for the FUSION force rule:..................................................... 377

31.4.7 Tick 3: Movement of Bound Components by Momentum:........................... 379

31.4.8 What the NEWTONIAN Force rule does:..................................................... 380

31.5 Intuitions about my description of motion across the digital grid           381

31.6 Selective processing… IF STATEMENTS............................................. 382

31.6.1 I claim that THIS, and thus alone is what imparts RELATIVE STRENGTHS to each of the forces we observe..................................................................................................................... 382

31.6.2 I claim that THIS explains why the various conversion constants are needed. 382

31.6.3 I also claim that from a simple macro examination of these relative strengths, we can determine WHICH FORCE runs first, second, etc… the theory-of-everything program thus designs itself!           382

31.6.4 Converging upon Feynman.......................................................................... 383

31.6.5 Quantum statistical probability fields vs. determination.............................. 384

31.6.6 Marty throws down the gauntlet:................................................................. 386

31.6.7 Right here is the razor-sharp edge of a HUGE difference in opinion between what Quantum theory says and what I say.......................................................................................................... 387

31.6.8 Operational theories derived from mathematical possibilities - the cart is placed directly in front of the horse:....................................................................................................................... 389

31.6.9 I won’t argue with scientific facts, I will try to rebuke the conclusions with explanations that work:   390

31.7 Making relativity work........................................................................ 391

31.7.1 The bottom line on this is the way the motion of light and matter are handled:........... 391

31.7.2 Nothing moves faster than one grid location (GL) per computer processing tick.         391

31.7.3 One GL / TICK. That is the secret to everything!!!....................................... 391

31.8 The motion of matter vs. the traversal of light..................... 392

31.8.1 What is DIGITAL MATTER, anyway?.......................................................... 392

31.8.2 What is “Real-World SOUND”, anyway?.................................................... 393

31.8.3 What is DIGITAL SOUND, anyway?........................................................... 394

31.8.4 “Real-world LIGHT” vs. “DIGITAL LIGHT”:............................................ 395

31.9 DIGITAL RADIATION....................................................................................... 396

31.9.1 Digital Radiation has many similarities to sound:........................................ 396

31.9.2 Visualizing Digital Radiation........................................................................ 397

31.9.3 Implementing Digital Radiation in the Algorithm:....................................... 398

31.10 The motion of Light and Matter...................................................... 400

31.11 A simple breakdown: 5 “Speed Limits”, all described as GL / Tick         401

31.11.1 ONE GL / Tick: The Traversal of Digital Light and Radiation:................. 402

31.11.2 Unlimited Speed 1 – Nuclear Force motion:.............................................. 402

31.11.3 Unlimited Speed 2 – Fusion Force motion:................................................ 403

31.11.4 No Motion (a special case)......................................................................... 404

31.11.5 Newtonian motion: the motion of matter................................................... 404

31.12 The motion of matter… this is what I’m calling Newtonian motion.        405

31.12.1 Are we on the same page?.......................................................................... 405

31.12.2 The relationship between the motion of matter and that of light............... 406

31.13 Calculating speed and motion........................................................ 407

31.13.1 C = One GC per tick.................................................................................. 407

31.13.2 Speeds Slower than C are defined as: 1 / N C being 1 GC every N ticks.. 407

31.13.3 How big can N get? In our world of digital addressing, the biggest computable number is 2 ** WordSize. ................................................................................................................ 409

31.13.4 The slowest speed = 1 GC every 2 ** WordSize ticks................................ 409

31.13.5 Next to fastest speed is not that easy to picture…..................................... 411

31.13.6 We need another approach…..................................................................... 411

31.13.7 Working all the way from the slowest forward…....................................... 411

31.14 Implications of the methods for setting speed....................... 415

31.14.1 Does this mean that stuff closer to the fastest needs to be processed differently than the slow stuff? 415

31.14.2 YES IT DOES!............................................................................................. 415

31.14.3 The slow stuff needs to be processed by waiting a number of ticks, then moving the object 1 grid location. That’s really straightforward................................................................... 415

31.14.4 The fast stuff needs to be processed by waiting a numbers of ticks then moving the object that many grid locations. That is NOT straightforward........................................................... 415

31.15 The very core............................................................................................. 421

31.16 Controlling light by a decision process................................... 427

31.16.1 Design by functional requirement............................................................... 428

31.16.2 Multiple possible outcomes......................................................................... 430

31.16.3 Examples of using programmatic decisions in determining photon destination to accomplish functional goals:....................................................................................................................... 431

31.16.4 How can MULTIPLE POSSIBLE OUTCOMES be PRE-determined?....... 432

31.16.5 Here is where the fine art of RECURSION takes place.............................. 433

31.16.6 Recursion makes magic.............................................................................. 434

31.16.7 Recursion explains quantum entanglement................................................ 436

31.16.8 Recursion also explains how the theory of quantum teleportation can work 437

31.16.9 Explaining quantum tunneling................................................................... 438

31.16.10 What did you expect?............................................................................... 439

31.17 Pseudo-code for the NEWTONIAN Force rules:.......................... 440

31.17.1 Terminology:............................................................................................... 440

31.17.2 What the Newtonian force rules do:........................................................... 440

31.17.3 Newtonian force is implemented as a two-step process:............................ 440

31.17.4 Pseudo-code for Newtonian motion by MOMENTUM:............................. 441

31.17.5 Notes on the Pseudo-code for Newtonian motion by MOMENTUM:........ 442

31.17.6 Programming Relativity on purpose:......................................................... 443

31.18 The simple force of Gravity............................................................... 444

31.19 Pseudo-code for M7P1DPOU................................................................. 446

31.20 SCIENTISTS IN A HURRY Navigation:.................................................... 447

31.21 Pseudo-code for the Atomic Collapse handler...................... 454

31.21.1 The new way to traverse radiation, by example:....................................... 458

32 Appendix: The problems with infinitesimal measurements of space and time  467

33 Appendix: Time Frames: Beating a Horse AND a Pony to Death 468

33.1 Virtual Computing ................................................................................... 468

33.2 The King........................................................................................................... 470

33.3 The Chess Game............................................................................................ 471

33.4 Definition: How Computer Simulators Work.............................. 472

33.5 Is there a point?.......................................................................................... 473

33.6 Can We PLEASE Get to the Point?......................................................... 474

33.7 Time Frames................................................................................................... 474

33.8 Relative Terminology of the Chess Game..................................... 475

33.9 A Long Day in My Computer Lab.......................................................... 476

33.10 A Not so Obvious Thing......................................................................... 478

33.11 Dead Yet? NOOO??? OK, One More…................................................... 479

34 Appendix: The Finite Number of Possible Universes................... 480

35 Appendix: How computer GATES work................................................. 481

35.1 Computer hardware instructions................................................... 481

35.1.1 No-Op instructions........................................................................................ 481

35.1.2 And................................................................................................................ 482

35.1.3 OR................................................................................................................. 482

35.1.4 XOR (eXclusive OR)...................................................................................... 482

35.1.5 NOT.............................................................................................................. 482

36 Appendix: Where did the Universe come from to begin with? 483

36.1 Important note to all readers:......................................................... 483

36.2 Important note to religious readers:............................................ 483

36.3 I believe the Universe originally came from the ordering of the prime numbers… it makes a PHYSICAL STRUCTURE!........................................... 484

36.4 The PRIME SPIRAL........................................................................................... 485

36.5 Euler’s Polynomial................................................................................... 486

36.6 Other PHYSICAL STRUCTURES that result from the prime number ordering            487

36.6.1 Klauber’s Triangle:....................................................................................... 487

36.6.2 Sacks’s Sphere:............................................................................................. 488

36.7 All-natural, PHYSICAL shapes and structures........................... 489

36.8 Toys and Widgets....................................................................................... 490

36.9 The physical structures create a “potential for computability”     492

36.10 The likelihood of complexity........................................................... 493

36.11  Is “Computational Potential” Believable? ................................ 494

36.12 Stretch?........................................................................................................ 495

36.13 Help me, but don’t send money......................................................... 496

36.14 Worried about living in a sea of changing numbers?.......... 498

36.14.1 Spheres….................................................................................................... 498

36.14.2 Spiral shapes…........................................................................................... 500

36.14.3 Fibonacci sequences…................................................................................ 500

36.14.4 Golden Ratios….......................................................................................... 501

36.14.5 And snowflakes…....................................................................................... 501

36.14.6 Convergent evolution................................................................................. 502

36.14.7 The Laws of nature are also rock-solid...................................................... 503

36.14.8 We stand safe and alone............................................................................. 504

37 Appendix: The “READ-ONLY” connection to all other Universes           505

37.1 Parallel Universes and Conduits..................................................... 505

37.2 Black holes as the source of Universes....................................... 506

37.3 Madness.......................................................................................................... 507

37.4 Marty’s one-way looking glass into parallel dimensions 508

38 Appendix: My letter to Ray Kurdswield........................................... 510

39 Appendix: My letter to Seth Lloyd....................................................... 514

39.1 Visualizing Motion in this Virtual Universe............................... 515

39.1.1 Tick 0: The pre-big-bang state… co-occupying plasma............................... 516

39.1.2 Tick 1: Nuclear Energy sprays Plasma Apart:............................................. 517

39.1.3 Tick 2: Fusion of Free Hot Plasma into Bound Components...................... 518

39.1.4 Tick 3: Movement of Bound Components by Momentum:........................... 519

40 Appendix: A question on Ask Yahoo, 29-Oct-2012.............................. 527

40.1 I think the Michelson-Morley experiment has explanation that was over-looked, how can I explain it?...................................................................... 527

40.2 First answer to Yahoo question:...................................................... 531

41 Appendix: Computer Word Sizes and Addressing Limitations 533

41.1 Periodic Table of the Elements........................................................... 537

42 Appendix: Setting the resolution at which the Universe operates  538

43 Appendix: A condensed summary of the Theory-Of-Everything           545

43.1 Capacities and Parameters................................................................... 545

43.2 Data Structures......................................................................................... 546

43.2.1 The VP list.................................................................................................... 546

43.2.2 The WFE list................................................................................................. 547

43.2.3 Variables and Arrays:................................................................................... 547

43.3 A 1-Page Pseudo-code Rendition of God’s Program... “The Theory-Of-Everything”:..................................................................................................................................... 548

43.4 Visualizing the motions of the Virtual Fundamental Particles… SEEING THE BIG BANG.......................................................................................................................... 552

43.5 Oops?................................................................................................................. 553

43.6 The Michelson-Morley experiment................................................... 555

43.6.1 What it is:...................................................................................................... 555

43.6.2 The results and the 19th century conclusion:............................................... 556

43.6.3 My conclusions of the Michelson-Morley experiment:................................. 557

43.7 But what about a little thing called “SCIENCE”, Marty?....... 558

43.7.1 Is Marty Full of SHIT???.............................................................................. 558

43.7.2 Grass Roots and Holy Grails, as an Algorithm:........................................... 559

43.7.3 Providing Proof:........................................................................................... 561

44 Appendix: Explanations of behaviors................................................ 562

44.1 My explanation for time-dilation................................................... 562

44.2 My challenges to the theory of Relativity ask:...................... 564

44.3 Now what about explaining quantum mechanics?................. 565

44.3.1 Transparency and concurrency.................................................................... 567

44.3.2 Making a choice among several possible outcomes..................................... 568

44.3.3 Nothing is random; TheTruth machine is still possible in any case.............. 569

44.3.4 How to make a programmatic choice.......................................................... 570

44.3.5 ($$$ I need a chapter explaining the oil-bounce experiments and the Starling flight patterns).            570

44.3.6 Past examinations by recursion.................................................................... 571

44.3.7 Programming recursion in the Theory-Of-Everything algorithm................ 572

45 Appendix: The overall flow of the Universe................................. 574

45.1 The basic model........................................................................................... 575

45.1.1 States and transitions between them............................................................ 575

45.1.2 Here is my latest model:............................................................................... 576

45.1.3 Structure declarations to quantify the basic model...................................... 577

45.2 Initialization processing...................................................................... 579

45.3 First transition: ORDERLINESS < -- > MASS + KINETIC ENERGY... 582

45.3.1 Side note:...................................................................................................... 582

45.3.2 Unique, two-step operation.......................................................................... 582

45.3.3 First Part of First Transition… the mechanism of Nuclear Force............... 583

45.3.4 Plasma-Vapor............................................................................................... 583

45.3.5 Fill Patterns:................................................................................................. 583

45.3.6 Second Part of First Transition… the mechanism of Fusion Force............. 584

45.3.7 (Still in tick 2…)............................................................................................ 585

45.3.8 What, no gravity?......................................................................................... 586

45.3.9 Analytics of the first transition..................................................................... 587

45.4 Quit the tick, eh?......................................................................................... 588

45.5 Tug–O-War...................................................................................................... 589

45.6 Sounds nutty, but,..................................................................................... 592

45.7 Need a little help to “push things along”?................................... 604

45.8 Particle 1 : The Lynchpin of the Universe...................................... 607

45.9 Are you ready to rumble?..................................................................... 610

45.10 Click,.............................................................................................................. 612

45.11 BOOM !!!!......................................................................................................... 612

46 Appendix: Prime Numbers and PrimeDentities.............................. 613

46.1 Terminology definition: Prime Number.......................................... 613

46.2 Marty terminology definition: PrimeDentity............................. 613

47 Appendix: How recursion works........................................................... 615

48 Appendix: Benefits of the technology............................................... 616

48.1 Axis’s of Evil?............................................................................................... 616

48.2 Architectural Sequences...................................................................... 617

48.3 Breaking the Heisenberg Uncertainty Principal...................... 618

48.3.1 Working from the inside-out......................................................................... 619

48.4 Harvesting the knowledge… new machines of the future. 620

48.4.1 Tiny Widgets................................................................................................. 620

48.4.2 Tiny Tools that build Tiny Machines............................................................. 620

48.4.3 Tiny Grid-Snap Perpetual Radiant Energy Machine.................................... 620

48.4.4 Osmosis-Reel Heat-to-Mechanical Energy Conversion Machine................. 620

48.4.5 Ultra Concentrated Data Storage Units...................................................... 621

48.4.6 Ultra Capacity Computers........................................................................... 621

48.4.7 TheTruth machine; our crowning achievement............................................ 621

49 Notes and other to-do’s............................................................................. 623

49.1 The layout of the book is now determined…............................. 623

49.2 Misc. thoughts and to-dos:................................................................... 626

49.2.1 Black holes of electric flow??....................................................................... 626

49.2.2 A version using integers, another using fractional location specifications.. 627

50 Appendix: Three Troubleshooting Nightmares........................... 628

50.1 Preface: HOW COMPUTER HARDWARE WORKS in 1/2 page.............. 628

50.2 Purpose – a taste of real world programming and industrial terminology     629

50.3 (1) Incorrect hardware interfacing documentation: M.S.U. Physiology research Department........................................................................................................... 630

50.4 (2) Bad Hardware: Digital Equipment Corporation, on location at the Oldsmobile plant in Lansing, Michigan:................................................ 632

50.4.1 Medicine to Stacker Cranes.......................................................................... 632

50.4.2 Historical and HUGE................................................................................... 633

50.4.3 Stacker Cranes software re-write................................................................. 634

50.4.4 Mike, clock-cards and SCUDs...................................................................... 635

50.4.5 Next assignment: ECV................................................................................. 639

50.4.6 UAW Electricians:........................................................................................ 640

50.4.7 The Suits:...................................................................................................... 642

50.4.8 The UAW line workers:................................................................................ 643

50.4.9 Real-time programmers:............................................................................... 644

50.4.10 Kanban and more job security:.................................................................. 645

50.4.11 Other groups:.............................................................................................. 646

50.4.12 Changing ECV… Iliad’s hideous program development environment:..... 648

50.4.13 But it gets better:........................................................................................ 649

50.4.14 The “programming development environment” was the biggest joke yet: 650

50.4.15 The program development cycle procedure, by the book:......................... 651

50.4.16 Here’s what I had to work with before I took the assignment:.................. 652

50.4.17 The ECV system:........................................................................................ 653

50.4.18 ECV stations on the assembly line:............................................................ 655

50.4.19 ECV station procedures:............................................................................ 658

50.4.20 ECV’s other system features:..................................................................... 659

50.4.21 The particulars of the hardware:................................................................ 660

50.4.22 A few last things about this assignment:.................................................... 661

50.4.23 Starting out: setting up the development environment:............................. 662

50.4.24 Performing my first development cycle:..................................................... 664

50.4.25 Changing the label formats… a “SIMPLE” job to be done?.................... 665

50.4.26 Reconsideration:......................................................................................... 666

50.4.27 My proposal (this is why I got the big bucks):............................................ 667

50.4.28 Proposal Estimates:.................................................................................... 668

50.4.29 A side-story about transferring knowledge from job to job AND doing whatever it takes:     670

50.4.30 Project management:................................................................................. 673

50.4.31 Cart before horse?...................................................................................... 674

50.4.32 Proposal acceptance:................................................................................. 675

50.4.33 Good Progress through the IMPLEMENTATION phase:.......................... 676

50.4.34 What Ever It Takes:.................................................................................... 677

50.4.35 ECV Installation Begins:............................................................................ 678

50.4.36 Trap to 4:.................................................................................................... 679

50.4.37 Quarks?...................................................................................................... 680

50.4.38 ATP: the Acceptance Test Plan:................................................................. 681

50.4.39 Making sure:............................................................................................... 682

50.4.40 The first HOURLY counts report:............................................................... 684

50.4.41 The first SHIFT counts report: TOTAL DISASTER STRIKES:.................. 685

50.4.42 Oh My GOD!!!............................................................................................. 686

50.4.43 Troubleshooting Trap to 4:......................................................................... 687

50.4.44 First step in any disaster: CONTAINMENT:............................................. 688

50.4.45 Next steps in any disaster; DAMAGE ASSESSMENT and IMMEDIATE WORKAROUNDS:  689

50.4.46 Next step; Investigation of what went wrong:........................................... 690

50.4.47 All-night, every night:................................................................................. 691

50.4.48 Until ONE FINE DAY:............................................................................... 692

50.4.49 John Shockey to the Rescue!....................................................................... 693

50.4.50 John’s ingenious hands-free hardware troubleshooting:........................... 694

50.4.51 The fix:........................................................................................................ 696

50.4.52 Cause and effect:........................................................................................ 698

50.4.53 Lessons learned from this really long story:............................................... 699

50.5 (3) Equipment Sabotage: Mike’s payback at the old Oldsmobile          700

50.5.1 Promotions and old responsibilities:............................................................ 700

50.5.2 Rust never sleeps:......................................................................................... 701

50.5.3 What’s up with #34?..................................................................................... 702

50.5.4 Preliminary investigation:............................................................................ 703

50.5.5 An important side-note on Bullet-Proof Code:............................................. 704

50.5.6 Not good enough:......................................................................................... 705

50.5.7 A special debugger version: taboo in production… usually:........................ 706

50.5.8 Bingo!............................................................................................................ 707

50.5.9 Photo cells and conveyor belts:.................................................................... 708

50.5.10 Sabotage:.................................................................................................... 709

50.5.11 Lessons learned:......................................................................................... 710

50.6 The dreaded multiple-problems-at-once situation:................ 711

50.7 Quirks.............................................................................................................. 712

50.8 (Bonus Bug): In my programming department............................. 713

50.9 One last thing: Grace Under Pressure and Thick Skin........... 715

50.9.1 Thick skin...................................................................................................... 715

50.10 How’s ‘bout a happy ending? Remember the **side story?... 716

50.11 Thanks for reading these horror stories................................. 723

51 Appendix: The Ducks and Geese................................................................ 724

52 Appendix: TheTruth machine.................................................................... 728

53 Appendix: Scientific proofs for my conjectures........................ 740

54 I will have all of this programmed in a few weeks, no problem whatsoever?? Sure, Marty. DREAM ON… REALITY is…....................................................... 741

54.1 ?????? Sure, Marty, GET REAL … (This is my final rant, please hear me out)   741

54.2 OK, but still, ................................................................................................ 742

54.3 What if?........................................................................................................... 743

54.4 Marty's Top 2 Questions of All-Time................................................. 744

54.5 Whoops, again?............................................................................................ 745

54.6 Yes,  BUT STILL,............................................................................................... 746

54.7 And besides, “It Wouldn’t hurt”!......................................................... 747

55 Glossary............................................................................................................... 748

55.1 Glossary, in sequential order of introduction of terms.. 748

55.2 Glossary, in alphabetical order of terms................................... 748

56 References.......................................................................................................... 749

56.1 My reading of work from others..................................................... 749

56.2 Brian Whitworth’s The Physical World as a Virtual Reality 750

56.2.1 Update 02-Nov-2012:................................................................................... 751

56.2.2 Update 07-Nov-2012:................................................................................... 753

57 Parting shots.................................................................................................... 754


 

 

 

 

 

(This page is intentionally left blank)

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

(Just to mess with you)

 

 

 

 

 

Colors and fonts used in this book:

 

 

I’m big on using colors, fonts, footnotes, hyperlinks, and SHOUTING

 

 

 

 

 

 

 

 

 

 

 

 

Hyperlinks are “optional reading”, unless otherwise instructed.

Footnotes are required reading: When encountering a sentence laced with footnotes, its best to read through it first and then go back and examine the footnotes.

 

 

Brief overview:

 

 

This book fully describes the simple computational algorithm that I’m claiming is THE THEORY OF EVERYTHING… a single, unified explanation of how the entire Universe operates… the “Holy Grail of Science” that has yet to be claimed.

 

 

I honestly believe that this algorithm (or one similar to it) IS all there is to the Universe. It’s so simple that it all fits into < 10 pages of C programming code.

 

In subsequent chapters I explain how and why something so simple can result in an entire Universe filled with all of its complexities. I also explain why it needs to be so small and simple.

 

 

 

 

 

 

 

Scientists in a hurry:

To continue following these links for a condensed summary of the Theory-Of-Everything:

1.      Please begin reading the Appendix: A condensed summary of the Theory-Of-Everything.

2.      About 5 pages into it you’ll find a full-size photo of Stone Mountain, Yukon, and be directed to read another chapter named: Another example: M7P1DPOU.

  
(Like this but bigger)

3.      About ¾ of the way through Another example: M7P1DPOU, you’ll again be directed back to Stone Mountain for some summarizing thoughts.

Click HERE RIGHT NOW to continue following these links …

 

 

 

 

 

 

 

Reading this book

 

Background required…

 

You don’t need too much of a technical or a deep scientific background to understand this book, as I attempt to introduce new concepts on top of those previously explained.

 

Reading this book in sequential order from start to finish is thus recommended.

 

 

I introduce readers to all computer terms in this same step-by-step manner, and so, even if you walk away not believing what I’m saying here, at least you will have learned some programming skills in the C programming language!

 

 

 

 

Hyperlinks, footnotes, and humor…

 

 

Hyperlinks are usually “optional reading”, unless otherwise instructed. Footnotes are required reading.

 

Many include new glossary terms being introduced. Some are just for humor and/or unrelated editorializing/bragging. So, if you’re humor-less and in a big frickin’ hurry, you can skip my jokes[2].

 

 

                

 

Seriously, the humor and the photographs are there to help get you through the dry subject matter. Just ask any of these distinguished scientists!

 

 

Try to not get lost jumping around within the footnotes and hyperlinks.

 

 

 

 

This book is stand-alone and “100% Scientific”???

 

 

This book provides a complete, stand-alone explanation of the theory-of-everything algorithm. For more background you can follow the external hyperlinks or browse at the e-books I’ve written on these subjects[3].

 

Recently, whilst explaining my theories to a group of real live credentialed scientists, it was pointed out that my work is NOT scientific at all… that I have made the most fundamental error of any scientist; I offer no real proof of what I claim.

 

 

Although I feel that I’ve done a lot of genuine hard work and research, I MUST ADMIT these scientists are correct (by scientific method, in any case).

 

I realize that I need to back-down from my hard-and-fast claims and also to clarify what I mean by “100% scientific”.

 

 

 

 

 

 

Clarification of my use of the term “100% scientific”

 

 

  1. Everything I’m suggesting is based upon concepts of computer science that I know to be correct; some of the scientists on the forum agreed, and a few were intrigued by my postulations. Click HERE for a short list of references about Virtual Reality.

 

 

  1. The basis of all my theories rests solidly upon the believability of VIRTUAL REALITY.

    I didn’t invent the concept of virtual reality
    . As science progresses, more and more respected scientists believe these ideas are not only possible, there are aspects of our contemporary understanding of the Universe that DEMAND it.

 

 

  1. In any case, the scientific basis of my work has nothing to do directly with any religion.

    When I claim “100% scientific”, THIS is how 90% of the readers interpret it… on whether it involves shape-shifting, fork-bending, voodoo, blue Gods, aliens, forces of evil, Mayan calendars, the “official story” of 9-11, the Hebrew Torah, the Catholic bible, or any other doctrines of faith.


    Although some of my books do mention religion (or the lack there of), faith, creation, evolution, and religious oppression of scientific discovery, THIS BOOK FOCUSES ONLY ON THE SCIENCE.

 

 

 

 

 

Implications and Fanatical Expectations

 

 

Some these virtual reality ideas introduce the possibility that the Universe is 100% DETERMINISTIC, and thus, it is 100% REPRODUCIBLE.

 

Based upon these concepts I dreamed up a few “neat inventions” and one really cool idea… I call it TheTruth machine:

 

1.     Here is a simple explanation.

 

  1. Admittedly it’s a total boatload of wishful fanaticism.

 

  1. However, there is a very slight[4] chance that it might actually work!

 

  1. And thus, this book provides a very thin thread of credibility to the even thinner possibility of TheTruth machine being built and utilized within our lifetimes.

 

 

Regardless of whether TheTruth machine is an unrealistic fantasy or not[5], this explanation of the operation of a Universe is based upon a computational approach that is realistically achievable upon realistic hardware.

 

 

IN ANY CASE, the Theory-Of-Everything ALGORITHM is simple enough to use as an example for learning C-language programming on windows!

 

 

 

 

 

 

Seriously, though …

 

 

Please excuse my repeating certain topics, SHOUTING, poor use of grammar, and repeating myself.

 

Please excuse my repeating certain topics, SHOUTING, poor use of grammar, and repeating myself.

 

 

 

SERIOUSLY, though … PLEASE try to keep an open mind to these suggestions; every day, the scientific community is more and more accepting ideas like these!

 

 

 

 

 

Most important; in any case, please read the URGENT MESSAGE about TheTruth machine.

 

 

 

 

 

ENJOY!

 

Marty… discflicker.com

 

 

 

 

*** The book starts here ***

 

 

 

 

 

 

 

1         The Current State of Scientific Discovery

 

 

On its most fundamental levels, what we consider to be “solid matter” is actually composed of a set of newly discovered sub-atomic particles that seem to elude all of the previous laws of physics we have established for hundreds of years.

 

These sub-atomic particles appear to operate more on a numeric (or a computational) basis, rather than by physical aspects of mass, acceleration, spin, and magnetism, as the old ways would have predicted, leaving a huge gap in our understanding of the way the universe really operates on its most basic levels.

 

Scientists have gone bonkers looking for answers to these new questions, and new QUANTUM THEORIES developed about these newly discovered sub-atomic particles seemed to provide them by way of real-world inventions based upon them. The best example is digital circuitry, implemented upon the digitized locations of electrons by energy level, as predicted (correctly) by quantum mechanics theory.

 

Still, the new theories seem to clash with the old, leaving a mystery to figure out how they can co-exist in the same Universe. It is in this gap between the old and new where many consider awaits the most cherished prize in all of science… a SINGLE, UNIFIED EXPLANATION of how the universe really operates…a “theory of everything”… it is known as “The holy grail of physics”.

 

Many of the scientists on this quest have looked to the skies to try to figure out how matter got created in the first place in order to help figure it all out. Many have invested in huge atomic-colliers and similar multimillion dollar devices to help them uncover more clues about the behavior of sub-atomic particles.

 

And nearly all of these scientists use a lot of mathematics for help… some use math to derive new problems to unanswered questions, some use math to try to answer old questions, taking into account new observations, etc., etc. Most of this math is VERY THICK.

 

Please click HERE for a more detailed explanation of these issues[6].

 

 

 

 

 

2         Computational algorithms

 

 

2.1  Marty’s qualifications, Part 1

 

 

I’m Marty Wollner  of Livonia, Michigan, and I’m NOT a qualified physicist, cosmologist or mathematician, however, I am a nice guy and a qualified computer programmer.

 

I created a COMPUTATIONAL ALGORITHM that I’m calling “God’s program”… my theory-of-everything solution. It’s relatively short and simple (as far as computer programs go), but in order to really understand it, you need to be familiar with programming.

 

 

And so, right, here, right now, let’s ease our way into programming, step-by-step. This is child’s play; please don’t be afraid…

 

 

 

 

 

 

 

2.2  Simple lists and ordered lists

 

 

This stuff is obvious, but it introduces TERMINOLOGY we’ll need later down the pike.

 

 

2.2.1        Bagels and lox:

 

 

Here is an example of a simple, straightforward LIST, numbered from 1 to 6:

 

Ingredients for bagels and lox:

 

1.      Bagels

2.      Lox

3.      Cream cheese

4.      Red Onion

5.      Sliced tomatoes

6.      Capers

 

 

Obviously, in general, lists are always numbered from 1 to N (the Number of list ENTRIES). The numbers from 1 to N shown on the left side of each entry are called INDEX NUMBERS.

 

 

In the Ingredients for bagels and lox list, the order of the entries really doesn’t mater; the list still functions the same when it’s displayed as such:

 

Ingredients for bagels and lox:

 

1.      Red Onion

2.      Lox

3.      Capers

4.      Cream cheese

5.      Bagels

6.      Sliced tomatoes

 

(The positions have been switched around; the former index numbers are now different for each entry. Who cares ??).

 

 

 

 

 

 

 

 

 

 

 

Oy Vey !![7]

 

 

 

 

 

 

2.2.2        Cat of the week:

 

 

Here’s another simple list, numbered from 1 to 8:

 

 

Top prizewinners in last week’s cat of the week contest:

 

1.      Franklin: $500

2.      Caesar: $400

3.      Smokey: $200

4.      Dusty: $100

5.      Nails: $60

6.      Angus: $60

7.      Catcher: $40

8.      Mickey $25

 

 

This list is ORDERED because the assignment of each entry to its associated index number is meaningful; you can’t just switch #8 Mickey for #2 Caesar, Caesar would rip Mickey a new fur-hole!

 

The order is important because, for example, the two entries #5 Nails and #6 Angus both won $60, but Nails came in ahead of Angus in the contest, and that is a significant fact.

 

Because it’s a significant fact, if we mixed up the order of the list entries (as shown in an example, below), this would really mess things up; Angus would never forgive us.

 

 

It has been said    :

 

 

To err is human. But to REALLY mess things up, you need a computer

 

 

That’s funny, but it’s not really true…

 

 

 

 

2.3  Computer list records, array lists and data tables

 

 

In fact, computers are really good at working with lists of information. In computer programmer lingo, the entries in a list are called RECORDS.

 

Another computer-programmer-lingo thang is to call an entire list of records an ARRAY. So an array is a list of records in a computer program. Just to confuse you, another term for records in an array is ”ELEMENTS” of the array.

 

 

When displaying arrays, I like to show them as such:

 

 

Top prizewinners in last week’s cat of the week contest:

Index #

Prize

Cat name

1

500

Franklin

2

400

Caesar

3

200

Smokey

4

100

Dusty

5

60

Nails

6

60

Angus

7

40

Catcher

8

25

Mickey

 

 

 

Here is a bit of basic terminology:

 

  1. This array can also be described as being a DATA TABLE[8].

 

  1. A data table consists of ROWS (horizontal records) and COLUMNS (the vertical groupings; each  is ASSIGNED A TITLE: Index #, Prize, and Cat Name).

 

  1. This data table consists of an ordered set of records.

 

 

 

 

 

 

Because this data table consists of an ordered list from 1 to N, we don’t really need the index numbers in the first COLUMN at all…

 

 

Top prizewinners in last week’s cat of the week contest:

Index #

Prize

Cat name

1

500

Franklin

2

400

Caesar

3

200

Smokey

4

100

Dusty

5

60

Nails

6

60

Angus

7

40

Catcher

8

25

Mickey

 

 

Same as:

 

 

Top prizewinners in last week’s cat of the week contest:

Prize

Cat name

500

Franklin

400

Caesar

200

Smokey

100

Dusty

60

Nails

60

Angus

40

Catcher

25

Mickey

 

 

No indexes, but as long as we don’t mix anything up, no problem-o.

 

 

 

 

 

 

 

If this “index-less” list was hand-written on a blackboard, or maybe constructed of cards thumb-tacked to a corkboard, we would need to be extra careful that we don’t mix-up the order of records.

 

 

      

 

 

 

But in a computer program, that is no problem what so ever.

 

 

     (Unless Mickey has plans of his own)

 

 

Computers are excellent at manipulating huge list of numbers and never mixing anything up.  Good thing, because the list of stuff that makes up our Universe is pretty big. Not infinitely big, but still…

 

 

 

 

 

 

2.4  Introduction to God’s Program’s VP list

 

 

The Theory-Of-Everything (a.k.a. “God’s Program”) manipulates numbers in a list in a sequential series of steps.

 

Each entry in the list represents a “Virtual Particle” or VP for short.

 

 

For example, here is a list named M4P1DPOU representing a very small Universe containing only 4 Virtual Particles:

 

 

M4P1DPOU:

 

1.     0

2.     5

3.     7

4.      8

 

 

This list is the simplest yet... it just a list of INTEGER NUMBERS!

 

Let's go ahead and present this simple list in the form of a data table and assign names to its columns:

 

 

M4P1DPOU:

VP List Index #

Location Pointer

1

0

2

5

3

7

4

8

 

 

 

 

 

 

 

The VP List Index # identifies each particular VP… it’s a list… this never changes. Duh.

 

What can change are the integer values of the Location Pointers.

 

 

 

The process of how the location pointers in this list are manipulated and what it means in the big picture is what this book is all about!

 

It’s really simple, and in any case, you will learn C programming along the way.

 

 

 

But, how am I qualified to discuss these subjects? Let’s think about this over an ice-cold German stein full of Canadian beer …

 

 

 

 

       

 

 

 

 

 

 

2.5  Have a drink on me

 

 

2.5.1        The Offer:

 

 

If this is the very first time you’ve ever seen computer programming code, relax, its really simple!!!   Are you still nervous?

 

I got an offer you can’t refuse…

 

 

 

IF (You’re thirsty) THEN

 

        Have a drink on me

 

END IF

 

 

 

 

 

Well, OK, that wasn’t really actual computer programming code…

 

 

 

 

 

 

 

 

 

 

 

 

 

 

(Keep scrolling down…)

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

        Sorry.

 

 

 

 

 

 

But the meaning should be clear; these LINES OF INSTRUCTIONS express my offer to have a drink on me. You did understand it, right?

 

 

 

If so, we are well under way…

 

 

                        

 

Trust me.

 

 

 

 

The 3-lines of English-like instructions in this example are called Pseudo-code as in:

 

 

 

 

Pseudo-code is your first big-ass cryptic computer-programmer-lingo word that looks scary but is easily defined.

 

Programmers use a lot of cryptic lingo like that, for example, the word ALGORITHM simply means the “entire set of instructions it takes to perform a task”… in this case the “entire” 3-line example:

 

 

 

1) IF (You’re thirsty) THEN

 

2)     Have a drink on me

 

3) END IF

 

 

 

Programmers also like to squeeze multi-word terms down into cryptic one-word expressions, so instead of calling this algorithm “The Offer”, we’ll name it “TheOffer” (no space, one word, CASE SENSITIVE).

 

 

 

Programmers use big words and make things appear cryptic so nobody will think we’re stupid[9].

 

 

2.5.2        Organization of algorithms like TheOffer:

 

 

We programmers are also way uptight about the ORGANIZATION of multiple (possibly thousands of) algorithms, and so we provide a unique NAME (a.k.a., a TITLE) for each algorithm we proudly create.

 

And since we’re so darn proud, we usually include our own name and the date of our masterpiece creation, as shown in this RENDITION of TheOffer:

 

 

 

1. TheOffer

 

2. Proudly written by Marty, 09-Aug-2012

 

 

 

3. IF (You’re thirsty) THEN

 

4.     Have a drink on me

 

5. END IF

 

 

 

6.      All Done!!

 

 

 

2.5.3        Notes on TheOffer:

 

  1. This algorithm is named (titled) TheOffer.

 

  1. TheOffer is now 6 lines long (I’m not counting the blank lines), however, it actually entails only the middle three lines of instructions (the previous rendition); the two green lines on the top and the one green line at the bottom were added to describe the algorithms’ title, its creator, and its date of creation. These are known as COMMENT LINES.

 

  1. Comment lines help keep us programmers sane by providing ANNOTATION as to what we’re trying to accomplish. This in turn, helps us organize our work.

 

  1. We are using green highlighter color to denote comment lines in our examples throughout this book.

 

  1. (IMPORTANT) Comment lines are NOT instructions… they have no impact on the algorithm’s actual function. They’re only there to help us remember what we wrote and why we wrote it, and to let other programmers (who have the misfortune of reading our code) know what we’re thinking, as well.

 

 

Are you still with me? OF COURSE you are…

 

 

                Trust me.

 

 

 

What’s that? You really ARE thirsty? OK, HERE is $5.00[10], have a drink on me!

 

 

 

2.5.4        TheDrinkOrder:

 

 

All right, here’s another example, titled TheDrinkOrder. I just FICTITIOUSLY gave you $5.00. Now go ahead and fictitiously drive down the street to the bar and order up a frosty one.

 

The bar tender says[11]:

 

 

IF (You have $2.00) THEN

 

    You can have a drink

 

END IF

 

 


But he lives on tips, so what he really means is this:

 

 

IF (You have AT LEAST $2.00) THEN

 

    You can have a drink

 

END IF

 

 

 

Sorry to interrupt your drink order, let me just make a couple more notes about the notation we’re using in these examples:

 

1.      We are using BOLD LUCIDA CONSOLE FONT for our instruction code (including comments).

 

2.        We are using the dark yellow color to denote the changes in these instructions from the previous example. In this case, we’ve inserted AT LEAST in between have and $2.00.

 

 

 

 

And since he’s used to vagrants, he also means this:

 

 

IF (You have LESS THAN $2.00) THEN

 

    Take a hike, pal!

 

END IF

 

[12]

 

 

 

 

2.5.5        A complete rendition of TheDrinkOrder:

 

 

All in all, here’s how Joe, the bartender is instructing you to order up your brew:

 

 

IF (You have AT LEAST $2.00) THEN

 

    You can have a drink

 

END IF

 

 

IF (You have LESS THAN $2.00) THEN

 

    Take a hike, pal!

 

END IF

 

 

 

 

 

2.5.6        A more structured rendition of TheDrinkOrder:

 

 

Here’s another, more structured (and a bit more cryptic) rendition of TheDrinkOrder algorithm.

 

(Fear not, I WILL EXPLAIN EVERYTHING):

 

 

 

TheDrinkOrder

 

Written by Marty, 09-Aug-2012

 

 

 

IF (YourCoinOnHand >= $2.00) THEN

 

    You can have a drink

 

ELSE

 

    Take a hike, pal!

 

END IF

 

 

 

All Done!!

 

 

 

 

($$$ Include photo of Art Carney as a drunk, HERE)

 

 

 

2.5.7        Notes about TheDrinkOrder:

 

 

In this explanation, I’m going to use the terms “OPERATOR”, “CONSTRUCTION”, “IF-THEN-END IF” and “IF-THEN-ELSE-END IF”. Following these notes are definitions for these 4 new terms.

 

 

  1. YourCoinOnHand looks cryptic but makes perfect cents. It’s the amount of money in your pocket (the you have in the previous rendition); Your Coin On Hand is squeezed together into one, cryptic word.


           

 

  1. The  >=  is a replacement for “AT LEAST” from the previous rendition. But this one ain’t as cryptic as it looks;  >=  is an OPERATOR.

    It means GREATER THAN OR EQUAL TO (a more analytical definition of the term “
    AT LEAST”).

 

  1. Because of (1) and (2),


        
    IF (You have AT LEAST $2.00) THEN


    becomes


        
    IF (YourCoinOnHand >= $2.00) THEN

 

 

  1. We also introduced an “IF-THEN-ELSE-END IFCONSTRUCTION here, which works a lot better than the two successive “IF-THEN-END IFconstructions used in the previous rendition.

 

 

Did you understand the use of the terms “OPERATOR”, “CONSTRUCTION”, “IF-THEN-END IF” and “IF-THEN-ELSE-END IF” in these notes?

 

IF not, THEN read the next three sections: Math Operators, Comparison Operators, and Constructions and Rendition, and try these notes again, ELSE keep on reading. END IF.

 

 

 

 

2.5.8        Math Operators:

 

 

An “Operator” is used, for example, in a math formula, where two numbers need to be “operated upon”, like A + B, A - B, etc…

 

 

 

+

 

Addition

 

A + B

 

 

-

 

Subtraction

 

A – B

 

 

*

 

Multiplication

 

A * B

 

 

/

 

Division

 

A / B

 

 

**

 

Exponent

 

A ** B

 

 

Etc…

 

 

 

 

 

These are called MATH operators. We will see working examples of these math operators shortly…

 

 

 

            Trust me.

 

 

 

 

2.5.9        Comparison Operators:

 

 

However, in all of our examples thus far, we’ve only used operators for COMPARISONS:

 

AT LEAST

 

>=

If you have AT LEAST $2.00

A >= B

LESS THAN

 

<

If you have LESS THAN $2.00

A < B

 

 

There are many such “comparison” operators and they’re all useful:

 

 

=

 

Is A EQUAL TO B?

 

A = B

 

 

>=

 

Is A GREATER THAN OR EQUAL TO B?

 

(AT LEAST)

 

 

A >= B

 

<=

 

Is A LESS THAN OR EQUAL TO B?

 

A <= B

 

 

>

 

Is A GREATER THAN B?

 

A > B

 

 

<

 

Is A LESS THAN B?

 

(LESS THAN)

 

 

A < B

 

<>

 

Is A NOT EQUAL TO B?

 

A <> B

 

 

Etc…

 

 

 

 

 

 

2.5.10    Constructions and Renditions:

 

 

I slipped in the term “construction”… this means the layout of the code, and it brings up a good point… an algorithm can be written in several different ways. More on this will be discussed below, a lot more, in fact.

 

We call the various different ways an algorithm can be written:

 

RENDITIONS

 

 

I had also slipped in the terms “IF-THEN-END IF” and “IF-THEN-ELSE-END IF”. To demonstrate how these different CONSTRUCTS[13] can be used, please stare at the following two renditions of TheDrinkOrder algorithm…

 

 

First rendition: TheDrinkOrder algorithm, using two successive “IF-THEN-END IF” constructs:

 

 

 

TheDrinkOrder, First rendition

 

Written by Marty, 09-Aug-2012

 

 

IF (YourCoinOnHand >= $2.00) THEN

 

     You can have a drink

 

END IF

 

 

IF (YourCoinOnHand < $2.00) THEN

 

     Take a hike, pal!

 

END IF

 

 

All done!!

 

 

 

 

 

Second rendition: TheDrinkOrder algorithm, using only one “IF-THEN-ELSE-END IF” construct:

 

 

 

TheDrinkOrder, Second rendition

 

Written by Marty, 09-Aug-2012

 

 

IF (YourCoinOnHand >= $2.00) THEN

 

     You can have a drink

 

ELSE

 

     Take a hike, pal!

 

END IF

 

 

All done!!

 

 

 

Bottom line: These two different renditions of the TheDrinkOrder algorithm let Joe, the bartender perform the exact same FUNCTIONALITY, they just perform them differently by using different constructs.

 

 

2.5.11    Program line counting:

 

It sounds stupid to count lines of code[14], but there are good reasons, as usual, to be understood later.

 

 

 

1.    TheDrinkOrder, First rendition

 

2.    Written by Marty, 09-Aug-2012

 

 

3.    IF (YourCoinOnHand >= $2.00) THEN

 

4.        You can have a drink

 

5.        END IF

 

 

6.    IF (YourCoinOnHand < $2.00) THEN

 

7.        Take a hike, pal!

 

8.    END IF

 

 

  1. All Done!!

 

 

The First Rendition entails 9 total lines of code, but comment lines don’t count for shit. Only the 6 NON-COMMENT LINES have any meaning.

 

 

 

 

1.    TheDrinkOrder, Second rendition

 

2.    Written by Marty, 09-Aug-2012

 

 

3.    IF (YourCoinOnHand >= $2.00) THEN

 

4.        You can have a drink

 

5.    ELSE

 

6.        Take a hike, pal!

 

7.    END IF

 

 

  1. All Done!!

 

 

The Second Rendition entails 8 total lines of code, but only the 5 non-comment lines are considered in PROGRAM LINE COUNTS.

 

 

 

 

2.5.12    Your first Spot Quiz:

 

 

Ho boy!

 

Spot Quiz #1: What are titles and the program line counts for the previous two renditions of TheDrinkOrder? Which rendition has the least number of program lines counted?

 

 

 

                    

 

 

 

 

Answers:

 

  1. The first rendition of the algorithm is titled TheDrinkOrder.
    Its program line count is 6.

 

  1. The second rendition of the algorithm is titled TheDrinkOrder.
    Its program line count is 5.

 

  1. The second rendition has the lesser number of lines counted.

 

 

Well that was a bit confusing… the titles are the same. The reason: these two renditions both perform the same FUNCTION.

 

 

Oh, BTW, I lied in my previous explanations, where I said the 3-line example and the 6-line example (with the 3 green comment lines added) were different renditions. Adding or changing comments doesn’t do shit as far as renditions. Sorry.

 

 

2.5.13    Are we OK?