Qu-Qu

This is still a work in progress. It may be changed in the future.

Not to be confused with Q nor Q 1.0

Qu-Qu is an esoteric programming language made by User: A(). It uses functions like Q and U to duplicate and/or simplify expressions.

Qu-Qu

Paradigm(s)	Functional
Designed by	User: A()
Appeared in	2026
Computational class	Turing Complete
Reference implementation	Unimplemented
Influenced by	Lambda Calculus, Lazy-K

Functions

Functions

Functions	Disc
Q()	duplicate/ apply to self
U()	simplify expression/ identity
X()	Not gate
∅()	null/ empty set

Syntax

A function that has no inputs can be written like this:

Q

Also Qx and Q(x) are the same. Functions are defined this way:

f(a,b): a

Functions take input right to left, and will be expanded by the interpreter:

Q(x) -> x(x)
U(Q(x)) ->  Q(x) -> x(x)

x(x) can be written as this:

x2

But not like this:

x2

or

2x

Because that shows that x is being feed into 2 or 2 is being feed into x. To see why this is a problem see #Building Numbers. Null is defined like this:

∅(x): ∅(x)

Programs

Duplicate forever

Q(Q) 

Q(Q), or Q² , duplicates itself forever.

Building Numbers

1 can be written like this:

∅(∅)

or

∅∅

let's define a successor function:

S(n, f, x): f(n(f(x)))

1(x) isn't x:

1(x) -> ∅(∅(x)) 

Simplification

U(∅∅) -> ∅2

So ∅ⁿ⁺¹ = n.

True & False

We can define true as a function that always returns the first value:

K(t,y): t

And false is the opposite of true:

X(K) -> K'

Which could also be defined as:

K'(t,y): y

And by that we can define X:

X(y): y(K',K)

Y comb

i(f,x): f(Q(x))
Y(f): i(f)(i(f))

Which can define ∅:

∅(x): Y(U)

And Gate

&(x,y): x(y(x))

Or Gate

#(x,y): x(x(y))

Additon

+(x,y): x(S(y))

Multiplication

*(x,y): x(+(y(∅)))

If-statement/Pair

C(a, b, c): a(b,c)

Exponents

^(n,e): e(n)

Binary-Qu-Qu

Q(x) - 0001...10
U(x) - 0010...11
X(x) - 0011...00
∅(x) - 0100...01
10000100100101 // addition

Trees

Back to syntax! Every program is a tree; a function will branch out on its inputs.

x(y(x))

Lower-case x will check for y, and y will check for x. So y(x) is solved first, then x(y(x)) is solved.