Talk: ~ATH

http://www.mspaintadventures.com/?s=6&p=004510

http://www.mspaintadventures.com/?s=6&p=004524

Bam, red and blue universes detected and canonically confirmed.

What does this mean for the code?

24.98.98.73 22:28, November 11, 2010 (UTC)The Psychic defective

Wait, that means....That Double Mobius Reacharound Virus (did I spelled that right?) uses the troll universe and ours?...

Is it important in anyway?--Niggy 22:27, November 12, 2010 (UTC)

Yes It's important.

It means that Sollux, who told us that English's server was unhackable, had TWO dream selves, refuses to troll the kids, and INITIATED SGRUB produced a piece of code that ties the death of two universes together.

Wierd plot shit abound, and a possible hint at why Karkat would recoignize english.

Both John and Karkat have the same ~ATH project.

http://www.mspaintadventures.com/?s=6&p=001924 and http://www.mspaintadventures.com/?s=6&p=003925

... Chalking it up as weird plot shit, personally, but it might be worth mentioning on the page. Wasn't sure. 24.15.248.79 06:14, August 15, 2011 (UTC)

~ATH takes it's name form Andrew T. Hussie's initials? 80.220.73.168 11:10, November 10, 2011 (UTC)selfless

Unlikely. It's considerably more likely for the initials to be an accidental outcome of TILDEATH than vice versa -- Sorceror Nobody, 22:18, November 10, 2011 (UTC)

~ath as a programming language has had a more recent appearance, namely the timer for the Cherub's session. ~U, green universe, green sun?

69.110.3.53 08:18, September 29, 2012 (UTC)LucidicUnderstudy

"Formality"

"As Lrd English can travel through time, [...] the program itself is essentially just a formality"

Absolutely not. It's a stable time loop; LE only exists within the universe because of the program and thus if the program wasn't there when U1 ended, he would never enter the universe, which would make it impossible for him to already be there, because he never went there in the first place. The program exists to avoid a paradox that would erase LE's existence from the trolls' universe.200.217.25.217 22:17, September 7, 2017 (UTC)

Wait, so is this how ~ATH works?

Import Test Dummy
 ~ATH (TD)
  Execute (Explode)
 Till.Death

So if the Test Dummy dies, it makes an explosion? I only understood this because Lord English is summoned when a universe dies and the unhackable.ATH says ~ATH (U) Execute (Lord English) Till.Death. Is that how it works? --Marioman2019 (talk) 07:25, March 30, 2019 (UTC)

Sullux's ~ath Program

bifurcate THIS[THIS, THIS];
import universe U1;
import universe U2;

~ATH(U1) {

    ~ATH(!U2) {

} EXECUTE(~ATH(THIS){}EXECUTE(NULL));
 
    } EXECUTE(~ATH(THIS){}EXECUTE(NULL));

[THIS, THIS].DIE();

Sollux seems to have discovered a runtime vulnerability. At the process creation (running the program), the runtime should resolve the execution argument to decide what to execute then load those instructions into automatically generated memory block (i.e. a square on the Turing machine's tape).

~Ath's rules intend those instructions to merely get assembled at that stage, not read nor followed, so the process pointer (i.e. the Turing machine's tape reader) does not read the instructions which the process pointer (i.e. " tape writer) printed, instead moving to some other pre-assigned memory block (decided by ~Ath's runtime). In an unruly "wild west" computing an environment, a programmer may command the process pointer to any imaginable (as well as addressed) memory block read then execute the instructions contained therein.. ~Ath seemingly atleast a somewhat more civilized programming environment, has an out-of-band process (a.k.a. existence or PID 1 [process ID #1]) cycling over a list of everything checking for any noteable state changes (life and death, thereof), which sends an event trigger (a trigger made by [but, not activated by] an event, such as dying, occurring) to the program's process pointer I suppose by simply appending the instructions to the bottom of whatever memory block PID#1 happens to find the program's process pointer reading at the moment [when/if the process pointer reads the event trigger, the trigger activates].

At the 'starting to run' stage, ~Ath's runtime must set aside a separate memory block to supervise any execution requests, check legality, plus decide what to do with any rule-breaking process pointers. Thus, Sollux must not only trick the operating environment giving away a free event trigger. Fortunately, creating an ~Ath loop seems to cause the operating environment to create an event trigger using the contents of the curly-braces "{}" as a payload (the memory block, the process pointer reads then requests permission from the supervisor to execute). ~Ath's rules would intend the runtime to crash any program attempting EXECUTE() within curly-braces without an object actually dying, however ~Ath's runtime seems to assume an EXECUTE() command after a close-curly brace would only receive an event trigger from that loop closing thus by no chance would turn out the first command inside another Ath~ loop's curly braces (why the syntax highlighter actually highlights the text incorrectly representing ownership, even though the supervisor accesses the syntax highlighter to distinguish THIS from THIS..[no.. wait.. wut?]*). The !U2 literally means is("U2 NOT DEAD") which qualifies as legal to the runtime since NOT_DYING wouldn't qualify as an event thus never cause an event trigger, such as an event like dying would.

To exploit the NOT operator, Sollux only needed to pick an object not dead, however in a very ironic fashion (typical for a hacker artist) picked a pre-existing environment variable (thing on the list of everything) describing an object not yet existing (i.e. the reality computer expects to create *wink* *wink*). Thus, Sollux had figured out that ~Ath's operating environment (operating system) expects to create a new universe. The operating environment, of course, always only assigns names for non-deterministicly generated objects "on-the-fly" once the operating environment creates those objects, as only any sane operating environment would.

Once

 } EXECUTE(~ATH(THIS){}EXECUTE(NULL));

executes, EXECUTE() creates a new process with a new red ~Ath loop, then the old red ~Ath loop dies thereby causing an event trigger

* i.e. a terrible programming practice since the program will immediately crash, if run on a computer without that specific syntax highlighter. [..] but wait.. typing ` ~Ath( ` won't change the color for the argument.. wait.. Sullux's lenses... ahhhh.. I see.

.... I wrote all that.. If so, why not simply type EXECUTE(NULL) as the first red ~Ath's exit instruction. I've seen pointer manipulating algorithms like that one.. I believe more exists to potentially rationalize Sullux's program... but alas I've run out of steam... Hopefully this post helps someone in some way at some point..

23.30.146.165 21:55, December 22, 2019 (UTC)

Oh, important note: ` EXECUTE(NULL) ` means exactly the same as ` EXECUTE() `.

NULL doesn't necessarily mean nothing. NULL only means no input. Whatever EXECUTE() does without any instructions would still happen.. in other words, the default behavior of EXECUTE().

23.30.146.165 22:11, December 22, 2019 (UTC)

pretty sure that ~ATH programs can run code in the loops, not just at the EXECUTE. this is because in sollux's program, the EXECUTE line effectively acts like an ~ATH loop. so this would mean that the loop runs code while waiting for the object to die (or while waiting for the object to be born in the case of ~ATH(!object)) and EXECUTE runs code once the condition of death or birth is met. this makes a lot more sense, considering that we dont actually see any unique lines of code in EXECUTE lines that we dont see in ~ATH loops. this also means that you could run a file (such as the cue ball file in the unhackable program) in an actual ~ATH loop. this results in a file being run over and over again until the core object is either killed or born. bifurcation also seems to split things chronologically. so far, weve only seen two colors, blue and red. it seems to me that red comes first chronologically, and then blue comes immediately after. this is supported by U1 (the troll universe) being red and U2 (the human universe) being blue. its also backed up by sollux's code. U1's ~ATH loop is waiting for U2 to be born. its likely that if you bifurcate a program into red and blue, you could have multiple objects in the red bifurcation. the program would likely wait until all red objects are dead, then it would run the blue objects' ~ATH code. this means that ~ATH(U) {} EXECUTE(cue ball file); THIS.DIE(); and ~ATH(!U2) {} EXECUTE(cue ball file); THIS.DIE(); work the same. we already know that U refers to U1, the troll universe. and due to sollux's code, we know that U2 comes immediately after U1. so whether you wait for U1 to die or for U2 to be born, the code in EXECUTE would run at the same moment.

Textbook pages

There are two fragments of pages of the ~ATH handbook visible, in troll-script (but like, rotated 180*, both at the character level and at the page level, I think), on https://www.homestuck.com/images/storyfiles/hs2/05425.gif and https://www.homestuck.com/images/storyfiles/hs2/05428.gif . I'm tempted to transliterate them...but may not get around to it anytime soon. Erhannis (talk) 02:57, 15 March 2022 (UTC)