Hashtags | Darflen

PkmnQ⁧⁦ is cool⁩⁦ 9 months ago (edited) • 5 views •

August 24->25

--:--

1

... 9 months ago • 7 views

can someone make an average of likes natan has

6

... 9 months ago (edited) • 9 views

2 teenagers from the Phillipines vs. the world: who wins?

3

... 9 months ago (edited) • 9 views

It's hilarious to think Meower has not banned the 2 people who love to spread nsfw everywhere, yet when 1 new users says the n word once they get instantly terminated

5

PkmnQ⁧⁦ is cool⁩⁦ 9 months ago (edited) • 6 views

you know what who cares anymore i'm going tagposting

Tag systems are a very simple system of computation that works as follows:
During runtime, a string of symbols are kept. Depending on what the first symbol is, a different production is appended to the end, then the first m symbols are removed. If the string is empty, it halts. There are slight differences in this definition depending on what's convenient, but the main idea of appending and removing stays the same.
m=2 is known to be Turing-complete and is, as far as I know, the most oftenly used value of m. If you inspect any m=2 tag system, you'll notice that not only is data stored in the symbols themselves, but also in the even/odd-ness of their positions. For example, take this Collatz example:

a -> bc
b -> a
c -> aaa

Let's run this with the starting string being aaaaa. (the --'s are just for spacing)

aaaaa
--aaabc
----abcbc
------cbcbc
--------cbcaaa
----------caaaaaa
------------aaaaaaaa

Because the amount of a's was odd, it skipped over the b, and only ran the c's. Now let's continue.

aaaaaaaa
--aaaaaabc
----aaaabcbc
------aabcbcbc
--------bcbcbcbc
----------bcbcbca
------------bcbcaa
--------------bcaaa
----------------aaaa

Since it was even this time, the b's ran and skipped over the c's. "bc" acts as a single unit that does different things depending on the parity of the a's.
It also helps to think of tag systems in terms of generations, starting with the initial string (e.g. aaaaa) to the string generated by the initial string (e.g. cbcbc) to the string generated by that (e.g. aaaaaaaa) etc. A better example for this kind of thing is UT19, which is split into three separate generations forming a single cycle. The specifics of what UT19 accomplishes will not be noted here.
As an example, here are two "inverters", which are used to flip the parity from even to odd and odd to even during the Command generation:

Relevant productions:
a -> bc
b -> dd
c -> rd
d -> aas
r -> r
s -> (nothing)

aasaas (Command generation)
--saasbc
----asbc
------bcbc (Parity generation)
--------bcdd
----------dddd (Reset generation)
------------ddaas
--------------aasaas (Command generation)

More complicated parts of UT19 change every cycle, such as the counters. They can either double or halve their length each generation:

Relevant productions:
a -> bc
b -> dd
c -> rd
d -> aas
l -> nnnn
m -> o
n -> pp
o -> pq
p -> lm
q -> llll
r -> r
s -> (nothing)

lmlm (Command generation)
--lmnnnn
----nnnnnnnn (Parity generation)
------nnnnnnpp
--------nnnnpppp
----------nnpppppp
------------pppppppp (Reset generation)
--------------pppppplm
----------------pppplmlm
------------------pplmlmlm
--------------------lmlmlmlm (Command generation)

(The parity each generation is entered is important, so two inverters are used)
aaslmlmaas (Command)
--slmlmaasbc
----mlmaasbc
------maasbco
--------asbcoo
----------bcoobc (Parity)
------------oobcdd
--------------bcddpq
----------------ddpqdd (Reset)
------------------pqddaas
--------------------ddaaslm
----------------------aaslmaas (Command)