I only claim to have proven this: A computable logic that arises from how connections are made and/or broken over time. That is a complete description of everything about this logic. This is not Lambda Calculus, this does not use numeric values, this only uses pointers. The models I created use one command to perform logic, “alias” that only allows you to create a command or rewrite a created command to execute a string of commands. In my models that string only calls other alias created commands, basically looping around itself in essence only using connections. I have built if-thens, sophisticated do-whiles, a randomizer, a relational database and math emulators.

The simple calculator is easiest to understand, it works like an automated abacus – it is simple enough for a child to comprehend but is yet almost nonconceptual in how it works with its simplicity. If you see how it works here then you know everything about it, just not some of the methods of using it that I have developed:

//Copyright All Rights Reserved 2024
//this script was built in Counter-Strike GO but will work in any QuakeWorld engine derivative game, including the original Quake.
//this script binds the KeyPad keys 0 through 9 along with - + and Enter
//This is limited to sums of -20 to 20, each number needs to be mapped and limits the system. This is also limited to single digit input.
//Starts in add mode. You can enter numbers in add or subtract mode without repeatedly hitting - or +
//list of system commands used (already built into the QuakeWorld engine): 
//bind - input (for linking keys to commands - all of which in this example are user made commands) 
//echo - output: for text output to the console (make sure you have the console turned on in settings, and use ~ in game to bring it down) 
//alias - the connection creator: for linking a string of commands, both user and system commands, together into one new callable user command
//all of the rest of the commands in this particular script are user created, here, with alias

//input binds
//bind physical KeyPad numbers to adding/subtracting function
bind KP_END calc1
bind KP_DOWNARROW calc2 
bind KP_PGDN calc3
bind KP_LEFTARROW calc4
bind KP_5 calc5 
bind KP_RIGHTARROW calc6
bind KP_HOME calc7 
bind KP_UPARROW calc8
bind KP_PGUP calc9
bind KP_INS calc0 
bind KP_MINUS minus //bind physical KeyPad key - to the minus mode function
bind KP_PLUS plus //bind physical KeyPad key + to the plus mode function
bind KP_ENTER sum //bind physical KeyPad key Enter to output sum function

//increment or decriment based upon mode with input from a number key
alias calc0 "echo 0"
alias calc1 "rotate; echo 1" 
alias calc2 "rotate; rotate; echo 2"
alias calc3 "rotate; rotate; rotate; echo 3"
alias calc4 "rotate; rotate; rotate; rotate; echo 4"
alias calc5 "rotate; rotate; rotate; rotate; rotate; echo 5"
alias calc6 "rotate; rotate; rotate; rotate; rotate; rotate; echo 6"
alias calc7 "rotate; rotate; rotate; rotate; rotate; rotate; rotate; echo 7"
alias calc8 "rotate; rotate; rotate; rotate; rotate; rotate; rotate; rotate; echo 8"
alias calc9 "rotate; rotate; rotate; rotate; rotate; rotate; rotate; rotate; rotate; echo 9"

//set mode
alias plus "alias rotate sumrotateup; echo PLUS"
alias minus "alias rotate sumrotatedown; echo MINUS"

//performing of the logic - echo is the output
//map of rotation
alias sumnegative20 "alias sum sumn20; alias sumrotatedown sumnegative20; alias sumrotateup sumnegative19" //sumnegative20 bounces back to itself in sumrotatedown rather than going to an unmapped -21
alias sumnegative19 "alias sum sumn19; alias sumrotatedown sumnegative20; alias sumrotateup sumnegative18"
alias sumnegative18 "alias sum sumn18; alias sumrotatedown sumnegative19; alias sumrotateup sumnegative17"
alias sumnegative17 "alias sum sumn17; alias sumrotatedown sumnegative18; alias sumrotateup sumnegative16"
alias sumnegative16 "alias sum sumn16; alias sumrotatedown sumnegative17; alias sumrotateup sumnegative15"
alias sumnegative15 "alias sum sumn15; alias sumrotatedown sumnegative16; alias sumrotateup sumnegative14"
alias sumnegative14 "alias sum sumn14; alias sumrotatedown sumnegative15; alias sumrotateup sumnegative13"
alias sumnegative13 "alias sum sumn13; alias sumrotatedown sumnegative14; alias sumrotateup sumnegative12"
alias sumnegative12 "alias sum sumn12; alias sumrotatedown sumnegative13; alias sumrotateup sumnegative11"
alias sumnegative11 "alias sum sumn11; alias sumrotatedown sumnegative12; alias sumrotateup sumnegative10"
alias sumnegative10 "alias sum sumn10; alias sumrotatedown sumnegative11; alias sumrotateup sumnegative9"
alias sumnegative9 "alias sum sumn9; alias sumrotatedown sumnegative10; alias sumrotateup sumnegative8"
alias sumnegative8 "alias sum sumn8; alias sumrotatedown sumnegative9; alias sumrotateup sumnegative7"
alias sumnegative7 "alias sum sumn7; alias sumrotatedown sumnegative8; alias sumrotateup sumnegative6"
alias sumnegative6 "alias sum sumn6; alias sumrotatedown sumnegative7; alias sumrotateup sumnegative5"
alias sumnegative5 "alias sum sumn5; alias sumrotatedown sumnegative6; alias sumrotateup sumnegative4"
alias sumnegative4 "alias sum sumn4; alias sumrotatedown sumnegative5; alias sumrotateup sumnegative3"
alias sumnegative3 "alias sum sumn3; alias sumrotatedown sumnegative4; alias sumrotateup sumnegative2"
alias sumnegative2 "alias sum sumn2; alias sumrotatedown sumnegative3; alias sumrotateup sumnegative1"
alias sumnegative1 "alias sum sumn1; alias sumrotatedown sumnegative2; alias sumrotateup sumzero"

alias sumzero "alias sum sum0; alias sumrotatedown sumnegative1; alias sumrotateup sumpositive1"

alias sumpositive1 "alias sum sump1; alias sumrotatedown sumzero; alias sumrotateup sumpositive2"
alias sumpositive2 "alias sum sump2; alias sumrotatedown sumpositive1; alias sumrotateup sumpositive3"
alias sumpositive3 "alias sum sump3; alias sumrotatedown sumpositive2; alias sumrotateup sumpositive4"
alias sumpositive4 "alias sum sump4; alias sumrotatedown sumpositive3; alias sumrotateup sumpositive5"
alias sumpositive5 "alias sum sump5; alias sumrotatedown sumpositive4; alias sumrotateup sumpositive6"
alias sumpositive6 "alias sum sump6; alias sumrotatedown sumpositive5; alias sumrotateup sumpositive7"
alias sumpositive7 "alias sum sump7; alias sumrotatedown sumpositive6; alias sumrotateup sumpositive8"
alias sumpositive8 "alias sum sump8; alias sumrotatedown sumpositive7; alias sumrotateup sumpositive9"
alias sumpositive9 "alias sum sump9; alias sumrotatedown sumpositive8; alias sumrotateup sumpositive10"
alias sumpositive10 "alias sum sump10; alias sumrotatedown sumpositive9; alias sumrotateup sumpositive11"
alias sumpositive11 "alias sum sump11; alias sumrotatedown sumpositive10; alias sumrotateup sumpositive12"
alias sumpositive12 "alias sum sump12; alias sumrotatedown sumpositive11; alias sumrotateup sumpositive13"
alias sumpositive13 "alias sum sump13; alias sumrotatedown sumpositive12; alias sumrotateup sumpositive14"
alias sumpositive14 "alias sum sump14; alias sumrotatedown sumpositive13; alias sumrotateup sumpositive15"
alias sumpositive15 "alias sum sump15; alias sumrotatedown sumpositive14; alias sumrotateup sumpositive16"
alias sumpositive16 "alias sum sump16; alias sumrotatedown sumpositive15; alias sumrotateup sumpositive17"
alias sumpositive17 "alias sum sump17; alias sumrotatedown sumpositive16; alias sumrotateup sumpositive18"
alias sumpositive18 "alias sum sump18; alias sumrotatedown sumpositive17; alias sumrotateup sumpositive19"
alias sumpositive19 "alias sum sump19; alias sumrotatedown sumpositive18; alias sumrotateup sumpositive20"
alias sumpositive20 "alias sum sump20; alias sumrotatedown sumpositive19; alias sumrotateup sumpositive20" //sumpositive20 bounces back to itself in sumrotateup rather than going to an unmapped 21

//end of logic

//initialize the system for first use
sumzero //initialize position of sum
plus //initialize for addition

//output echos
alias sumn20 "echo sum -20"
alias sumn19 "echo sum -19"
alias sumn18 "echo sum -18"
alias sumn17 "echo sum -17"
alias sumn16 "echo sum -16"
alias sumn15 "echo sum -15"
alias sumn14 "echo sum -14"
alias sumn13 "echo sum -13"
alias sumn12 "echo sum -12"
alias sumn11 "echo sum -11"
alias sumn10 "echo sum -10"
alias sumn9 "echo sum -9"
alias sumn8 "echo sum -8"
alias sumn7 "echo sum -7"
alias sumn6 "echo sum -6"
alias sumn5 "echo sum -5"
alias sumn4 "echo sum -4"
alias sumn3 "echo sum -3"
alias sumn2 "echo sum -2"
alias sumn1 "echo sum -1"
alias sum0 "echo sum 0"
alias sump1 "echo sum 1"
alias sump2 "echo sum 2"
alias sump3 "echo sum 3"
alias sump4 "echo sum 4"
alias sump5 "echo sum 5"
alias sump6 "echo sum 6"
alias sump7 "echo sum 7"
alias sump8 "echo sum 8"
alias sump9 "echo sum 9"
alias sump10 "echo sum 10"
alias sump11 "echo sum 11"
alias sump12 "echo sum 12"
alias sump13 "echo sum 13"
alias sump14 "echo sum 14"
alias sump15 "echo sum 15"
alias sump16 "echo sum 16"
alias sump17 "echo sum 17"
alias sump18 "echo sum 18"
alias sump19 "echo sum 19"
alias sump20 "echo sum 20"

This word problem illustrates what the formulas below say is possible, that the code further below performs. Note that the word problem uses a combination lock instead of throwing grenades as the script was intended to do:

You have a combination padlock with four dials on it. Each dial has the numbers 0 through 4 on them. The lock can have as many 0s as dials, and is set to 0000 by default. The lock does not allow you to use any number between 1 and 4 two or more times in the combination. The following combinations are valid: 0123 1234 0103 0010 4031. The following combinations are invalid: 0113 4014 0202 4444. How many possible combinations are there?

Formulas

209 is the answer. If I had 18 empty slots and 18 different items to place in the empty slots to form a combination it would have 2,968,971,264,021,448,999 possible permutations, each reachable within 18 keystrokes or less.

The below script allows you to select the throwing order of 4 different grenades, and then throw them. The 0 in the combination lock represents an empty slot, which when throwing will be skipped over. The first slot button you push will take high explosive, the second slot button you push even if it is the same button as the high explosive grenade will put a flashbang in the slot, then teargas, then smoke. Pressing any slot a 5th time will reset the slots. Use Mouse2 to simulate throwing the grenades.

//Copyright 2024 All Rights Reserved
//this script was built in Counter-Strike GO but will work in any QuakeWorld engine derivative game, including the original Quake.
//list of system commands used (already built into the QuakeWorld engine): 
//bind - input (for linking keys to commands - all of which in this example are user made commands) 
//echo - output: for text output to the console (make sure you have the console turned on in settings, and use ~ in game to bring it down) 
//alias - the connection creator: for linking a string of commands, both user and system commands, together into one new callable user command
//all of the rest of the commands in this particular script are user created, here, with alias

//bind keys to commands for user input
bind x grnslta //bind the X key to grenade slot 1
bind c grnsltb //bind the C key to grenade slot 2
bind v grnsltc //bind the V key to grenade slot 3
bind b grnsltd //bind the B key to grenade slot 4
bind n grnrt0 //bind the N key to reset the grenade slots
bind MOUSE2 +gtoss //bind mouse2 to the action of throwing the grenades

// Grenade Throwing System
alias null ""
alias gsrst "alias +gs1 null;alias -gs1 gbutrot;alias +gs2 null;alias -gs2 gbutrot;alias +gs3 null;alias -gs3 gbutrot;alias +gs4 null;alias -gs4 gbutrot"
alias gbrst "alias gbutrot gbutrot1;alias +gtoss +gtall;alias -gtoss -gtall"
alias skiprst "alias skip1 skip1rst;alias skip2 skip2rst;alias skip3 skip3rst;alias skip4 skip4rst"

alias skip1rst "alias +gtoss +gs2;alias -gtoss -gs2;alias gbutrot gbutrot3;skip2"
alias skip2rst "alias +gtoss +gs3;alias -gtoss -gs3;alias gbutrot gbutrot4;skip3"
alias skip3rst "alias +gtoss +gs4;alias -gtoss -gs4;alias gbutrot skip4rst;skip4"
alias skip4rst "alias +gtoss +gtall;alias -gtoss -gtall;alias gbutrot null"

alias grst1 "alias grnslta grnrta1;alias grnsltb grnrtb1;alias grnsltc grnrtc1;alias grnsltd grnrtd1;gsrst;gbrst;skiprst"
alias grst2 "alias grnslta grnrta2;alias grnsltb grnrtb2;alias grnsltc grnrtc2;alias grnsltd grnrtd2"
alias grst3 "alias grnslta grnrta3;alias grnsltb grnrtb3;alias grnsltc grnrtc3;alias grnsltd grnrtd3"
alias grst4 "alias grnslta grnrta4;alias grnsltb grnrtb4;alias grnsltc grnrtc4;alias grnsltd grnrtd4"
alias grst5 "alias grnslta grnrt0;alias grnsltb grnrt0;alias grnsltc grnrt0;alias grnsltd grnrt0"

alias grnrt0 "grst1;echo FULL RESET of Grenade Slots"
alias grnrta1 "grst2;alias +gs1 +gthe;alias -gs1 -gthe;alias skip1 null;echo Grenade Slot 1 high explosive grenade"
alias grnrta2 "grst3;alias +gs1 +gtfb;alias -gs1 -gtfb;alias skip1 null;echo Grenade Slot 1 flashbang grenade"
alias grnrta3 "grst4;alias +gs1 +gttg;alias -gs1 -gttg;alias skip1 null;echo Grenade Slot 1 teargas grenade"
alias grnrta4 "grst5;alias +gs1 +gtsmk;alias -gs1 -gtsmk;alias skip1 null;echo Grenade Slot 1 smoke grenade"
alias grnrtb1 "grst2;alias +gs2 +gthe;alias -gs2 -gthe;alias skip2 nullv;echo Grenade Slot 2 high explosive grenade"
alias grnrtb2 "grst3;alias +gs2 +gtfb;alias -gs2 -gtfb;alias skip2 null;echo Grenade Slot 2 flashbang grenade"
alias grnrtb3 "grst4;alias +gs2 +gttg;alias -gs2 -gttg;alias skip2 null;echo Grenade Slot 2 teargas grenade"
alias grnrtb4 "grst5;alias +gs2 +gtsmk;alias -gs2 -gtsmk;alias skip2 null;echo Grenade Slot 2 smoke grenade"
alias grnrtc1 "grst2;alias +gs3 +gthe;alias -gs3 -gthe;alias skip3 null;echo Grenade Slot 3 high explosive grenade"
alias grnrtc2 "grst3;alias +gs3 +gtfb;alias -gs3 -gtfb;alias skip3 null;echo Grenade Slot 3 flashbang grenade"
alias grnrtc3 "grst4;alias +gs3 +gttg;alias -gs3 -gttg;alias skip3 null;echo Grenade Slot 3 teargas grenade"
alias grnrtc4 "grst5;alias +gs3 +gtsmk;alias -gs3 -gtsmk;alias skip3 null;echo Grenade Slot 3 smoke grenade"
alias grnrtd1 "grst2;alias +gs4 +gthe;alias -gs4 -gthe;alias skip4 null;echo Grenade Slot 4 high explosive grenade"
alias grnrtd2 "grst3;alias +gs4 +gtfb;alias -gs4 -gtfb;alias skip4 null;echo Grenade Slot 4 flashbang grenade"
alias grnrtd3 "grst4;alias +gs4 +gttg;alias -gs4 -gttg;alias skip4 null;echo Grenade Slot 4 teargas grenade"
alias grnrtd4 "grst5;alias +gs4 +gtsmk;alias -gs4 -gtsmk;alias skip4 null;echo Grenade Slot 4 smoke grenade"

alias gbutrot1 "alias +gtoss +gs1;alias -gtoss -gs1;alias gbutrot gbutrot2;skip1"
alias gbutrot2 "alias +gtoss +gs2;alias -gtoss -gs2;alias gbutrot gbutrot3;skip2"
alias gbutrot3 "alias +gtoss +gs3;alias -gtoss -gs3;alias gbutrot gbutrot4;skip3"
alias gbutrot4 "alias +gtoss +gs4;alias -gtoss -gs4;alias gbutrot skip4rst;skip4"

alias +gthe "echo throw high explosive grenade"
alias -gthe "gbutrot"
alias +gtfb "echo throw flashbang grenade"
alias -gtfb "gbutrot"
alias +gttg "echo throw teargas grenade"
alias -gttg "gbutrot"
alias +gtsmk "echo throw smoke grenade"
alias -gtsmk "gbutrot"
alias +gtall "echo throw any available grenade"
alias -gtall "null"

//initialize the system
grnrt0

I am undeniably performing complex computational logic here. The problem people have when they understand how it works: it is not Turing Complete – it requires an operator.

I call this Logic Geometry.

I built many things, I could not find a limit to this form of logic.