UnCompetition

UnCompetition is an esolang created by User:Yayimhere, with the focus of trying to have an undecidable question, instead of actually being a programming language, however there is no proof that it has any so far.

Description

UnCompetition consists of a tree, where each node is a program IN UnCompetition. these programs, are all "solutions" to another program, specifically, the one they branch from. Every UnCompetition is a set of conditions, for which all programs "generated" from it must follow these. as such, it becomes similar for finding the variable X within a set of conditions. On ever iteration, this process is done for every node on the tree, and then the tree is saved for the next iteration.

There is a limit on how many node's each node gets to generate. if it is of the first level of the tree(so the user program), then it will be allowed to generate 1000 programs. if more than 1000 are possible, then generation must stop on the 1000'th. this limit increases on every next level of the tree by a value of 1000. The order of program generation here matters, so different programs arent uncut by the limit in, different interpreters. This is solved, by having the order of nodes being calculated being based off of how many different conditions each node has, with the one having the least, being the first generated. this is also how most interpreters would work, off of intuition.

these are all the commands(each is on its own line). P1 represents the current program(which would in the start be the actual user written program), and P2 represents all the generated programs branching from it, within the tree:

Command	Meaning
!	P1 and P2 will be different
[x]	P2 will have x number of lines(from 1-9)
:x	If there's x many node's in the current level of the tree, then include the below indented code in P2(without the indentation), else, do not(from 1-100)
#	P2 will not create any more node's
{x}	the command x is excluded from P2
(x)	oppesite of {x}
~x	a not. when used on a command x, thats command condition will become "negated" in a sense. for example, ~! becomes "P1 and P2 will NOT be different". basically, place a not before the actual condition for P2.

All numbers must be integers.
P2 solutions are not allowed to have repeating commands, and order doesn't matter. this includes having both a [x] and a [y], no matter the number(this only counts for [x]). They must also not have any errors.
If there is a [x] and a [y] in P1, the larger will always be chosen.
in {x} and (x), if multiple commands are wanted, then the same indentation as in :x can be used.
` can be used to represent a generic number for operations like :x and [x] when referenced in the {} and () operations (ex. {:`} )

Computational class

Currently, UnCompetition's computational class is unknown, and would be quite the challenge to prove or disprove it Turing complete. however, there are a few things that we can go of off that may be useful:

• UnCompetition is basically just a large function, where inputs are passed in, and then out, only to be passed in again. this is in some ways highly similar to Lambda-calculus, however only with one function, and an infinite amount of inputs, which is quite similar to Preface.
• Another way to look at it, is that each program is a function of its own, that when interpreted, (nearly) always returns another function. this is interesting, as it means each function has a sort of "inertia", where they even without input(which is just another wording for a single universal input), give an output.
• Both of the above, and the language, at its core, is functionally pure.

The reason I, the creator of UnCompetition, believe UnCompetition is TC, is because of its massive difference in tree sizes, even though there isnt much difference between programs.

(Surprisingly enough) a short list of examples(WIP)

i have only a single program to show for now:

[1]

now all generated programs are listed here(all on an individual line)

[1]
[2]
[3]
[4]
[5]
[6]
[7]
[8]
[9]
#
!
([1])
([2])
([3])
([4])
([5])
([6])
([7])
([8])
([9])
(#)
(!)
{[1]}
{[2]}
{[3]}
{[4]}
{[5]}
{[6]}
{[7]}
{[8]}
{[9]}
{#}
{!}
~[1]
~[2]
~[3]
~[4]
~[5]
~[6]
~[7]
~[8]
~[9]
~#
~!
~([1])
~([2])
~([3])
~([4])
~([5])
~([6])
~([7])
~([8])
~([9])
~(#)
~(!)
~{[1]}
~{[2]}
~{[3]}
~{[4]}
~{[5]}
~{[6]}
~{[7]}
~{[8]}
~{[9]}
~{#}
~{!}

as you see, even though it doesnt reach the cap of 1000 programs.

See also

• Unrepetition