Introduction. A yagba is an ordered triplet of real numbers where each number is between negative one and positive one, and the sum of all three numbers is zero.

One way to write a yagba is to list its components, separated by commas, between shallow angle brackets. Examples are ⟨ −0.3, +0.5, −0.2 ⟩, ⟨ 0.0, 0.0, 0.0 ⟩ and ⟨ 0.0, +1.0, −1.0 ⟩. The three components can be denoted by the subscripts a, b and c respectively, so that if Y is a yagba, Y ≡ ⟨ Y_a, Y_b, Y_c ⟩. In the ensuing discussion, yagbas will frequently be denoted by majuscules from the latter part of the Roman alphabet.

For the yagba Y, the essential constraints can now be listed this way:

−1 ≤ Ya ≤ +1

−1 ≤ Yb ≤ +1

−1 ≤ Yc ≤ +1

Ya + Yb + Yc = 0

Immediate consequences are:

−1 ≤ (Ya + Yb) ≤ +1

−1 ≤ (Yb + Yc) ≤ +1

−1 ≤ (Yc + Ya) ≤ +1

The sum-equals-zero constraint means that while the triple has three numbers, it has only two degrees of freedom; this redundancy is worthwhile because it effects a useful symmetry of notation which will be revealed as the discussion continues. Since any two components are sufficient to determine the yagba, we sometimes for convenience write in lieu of one component the Greek minuscule rho (ρ), which has the mnenomic remainder. The ρ represents whatever value is required to make the sum of the components equal to zero, and this symbol is used very casually: if ρ appears in each of several yagbas within one expression, it might stand for a different value in each.

As is customary with ordered n-tuples, two yagbas are equal if and only if their respective components are equal.

Six yagbas, representing extreme values, deserve their own names:

PNZ = ⟨ +1, −1, 0 ⟩

PZN = ⟨ +1, 0, −1 ⟩

ZPN = ⟨ 0, +1, −1 ⟩

NPZ = ⟨ −1, +1, 0 ⟩

NZP = ⟨ −1, 0, +1 ⟩

ZNP = ⟨ 0, −1, +1 ⟩

Mnemonics are P for positive, N for negative and Z for zero. These yagbas are called corner constants because if their components are regarded as (x, y, z) coordinates in cartesian 3-space, the constants form the corners of a regular hexagon with an edge of √2. All other yagbas are on the boundary or in the interior of this hexagon, which lies in a plane oblique to the coordinate axes. That plane can be rotated into the (x, y) plane by this transformation:

x2D = x3D ∗ (sqrt (1/12) + 1/2) + y3D ∗ (sqrt (1/12) − 1/2) − z3D ∗ sqrt (1/3)

y2D = x3D ∗ (sqrt (1/12) − 1/2) + y3D ∗ (sqrt (1/12) + 1/2) − z3D ∗ sqrt (1/3)

Unary operators. We use a prefix notation, and omit writing parentheses around the operand if no confusion will result.

Negation is unsurprising:

− Y = ⟨ − Ya, − Yb, − Yc ⟩

Patently,

PNZ = − NPZ

PZN = − NZP

ZPN = − ZNP

Each of six permutative operators has a three-letter name:

ABC Y = ⟨ Ya, Yb, Yc ⟩

ACB Y = ⟨ Ya, Yc, Yb ⟩

CAB Y = ⟨ Yc, Ya, Yb ⟩

BAC Y = ⟨ Yb, Ya, Yc ⟩

BCA Y = ⟨ Yb, Yc, Ya ⟩

CBA Y = ⟨ Yc, Yb, Ya ⟩

It is often convenient to write P, Q and R as "variables" denoting permutation operators.

The negation operator commutes with any permutation operator, so for instance − (CAB Y) = CAB (− Y) and more generally, − (P Y) = P (− Y). By contrast, the permutation operators are noncommutative among themselves. For example, the following are unequal:

CAB (ACB ⟨ d, e, f ⟩) = CAB ⟨ d, f, e ⟩ = ⟨ e, d, f ⟩

ACB (CAB ⟨ d, e, f ⟩) = ACB ⟨ f, d, e ⟩ = ⟨ f, e, d ⟩

One might apply one permutation operator to another, as given in the following table. Relative to each other, P is the operator, and Q is the operand:

P(Q)		Q =						Informal description of how to change Q
		ABC	ACB	CAB	BAC	BCA	CBA
P =	ABC	ABC	ACB	CAB	BAC	BCA	CBA	change nothing
	ACB	ACB	ABC	CBA	BCA	BAC	CAB	exchange the last two letters
	CAB	CAB	BAC	BCA	CBA	ABC	ACB	move the last letter to the beginning
	BAC	BAC	CAB	ACB	ABC	CBA	BCA	exchange the first two letters
	BCA	BCA	CBA	ABC	ACB	CAB	BAC	move the first letter to the end
	CBA	CBA	BCA	BAC	CAB	ACB	ABC	exhange the first and last letters

This manner of combining operators is also noncommutative; for example:

(CAB (ACB)) ⟨ d, e, f ⟩ = BAC ⟨ d, e, f ⟩ = ⟨ e, d, f ⟩

(ACB (CAB)) ⟨ d, e, f ⟩ = CBA ⟨ d, e, f ⟩ = ⟨ f, e, d ⟩

Even without a yagba as operand, ACB (CAB) is a legitimate standalone expression, denoting the operator CBA.

The permutative operators do exhibit associativity, in two senses:

• P (Q (Y)) = (P (Q)) Y. As an example, ACB (CAB ⟨ d, e, f ⟩) = (ACB (CAB)) ⟨ d, e, f ⟩. Unambiguous, then, is to write ACB CAB ⟨ d, e, f ⟩.
• (P (Q)) (R) = P (Q (R)). In some contexts, this could be writen simply as P Q R without confusion.

Binary operators. Related by permutation are six important binary operators, whose names are built from the mnemonics G for greater (hence maximum), L for lesser (hence minimum), and R for remainder. Either prefix or infix notation is possible:

GLR (Y, Z) = Y GLR Z = ⟨ max (Ya, Za), min (Yb, Zb), ρ ⟩

GRL (Y, Z) = Y GRL Z = ⟨ max (Ya, Za), ρ, min (Yc, Zc) ⟩

RGL (Y, Z) = Y RGL Z = ⟨ ρ, max (Yb, Zb), min (Yc, Zc) ⟩

LGR (Y, Z) = Y LGR Z = ⟨ min (Ya, Za), max (Yb, Zb), ρ ⟩

LRG (Y, Z) = Y LRG Z = ⟨ min (Ya, Za), ρ, max (Yc, Zc) ⟩

RLG (Y, Z) = Y RLG Z = ⟨ ρ, min (Yb, Zb), max (Yc, Zc) ⟩

For these operators, D and E are the typical "variable" names.

We need to prove that GLR (Y, Z) is in fact a yagba. Although the appearance of ρ in its definition ensures that the sum of the components will be zero, yet unestablished is that ρ has a magnitude that is not greater than unity. This can be resolved by examining four partially overlapping cases:

• If Y_a ≥ Z_a and Y_b ≤ Z_b, then GLR (Y, Z) = ⟨ Y_a, Y_b, ρ ⟩ = Y, which was a yagba to begin with.
• If Y_a ≤ Z_a and Y_b ≥ Z_b, then GLR (Y, Z) = ⟨ Z_a, Z_b, ρ ⟩ = Z, which is also a yagba.
• If Y_a ≥ Z_a and Y_b ≥ Z_b, then GLR (Y, Z) = ⟨ Y_a, Z_b, ρ ⟩.
  • Substituting Z_b ≤ Y_b into Y_a + Y_b ≤ +1 yields Y_a + Z_b ≤ +1.
    Negated, this becomes −Y_a − Z_b ≥ −1; but ρ = −Y_a − Z_b, so ρ ≥ −1.
  • Substituting Y_a ≥ Z_a into Z_a + Z_b ≥ −1 yields Y_a + Z_b ≥ −1.
    Negated, this becomes −Y_a − Z_b ≤ +1; again ρ = −Y_a − Z_b, so ρ ≤ +1.
• If Y_a ≤ Z_a and Y_b ≤ Z_b, then GLR (Y, Z) = ⟨ Z_a, Y_b, ρ ⟩. This is handled in the same way as the previous case.

Since the yagbas are closed under GLR, they will by symmetry be closed under the other five binary operators.

The six binary operators are commutative and associative because min and max are:

Y D Z = Z D Y

(X D Y) D Z = X D (Y D Z)

Not always satisfied, however, are the distributive and absorptive laws:

X D (Y E Z) = (X D Y) E (X D Z) ?

Y D (Y E Z) = Y ?

but if one is satisfied so is the other, as detailed in this table:

Distributive? Absorptive?		L =
		GLR	GRL	RGL	LGR	LRG	RLG
K =	GLR	Yes	No	No	Yes	No	No
	GRL	No	Yes	No	No	Yes	No
	RGL	No	No	Yes	No	No	Yes
	LGR	Yes	No	No	Yes	No	No
	LRG	No	Yes	No	No	Yes	No
	RLG	No	No	Yes	No	No	Yes

These binary operators can be permuted, according to this table:

P(J)		J =
		GLR	GRL	RGL	LGR	LRG	RLG
P =	ABC	GLR	GRL	RGL	LGR	LRG	RLG
	ACB	GRL	GLR	RLG	LRG	LGR	RGL
	CAB	RGL	LGR	LRG	RLG	GLR	GRL
	BAC	LGR	RGL	GRL	GLR	RLG	LRG
	BCA	LRG	RLG	GLR	GRL	RGL	LGR
	CBA	RLG	LRG	LGR	RGL	GRL	GLR

The permutative operators are distributive over an operator invocation. For instance,

BAC (GLR (Y, Z)) = (BAC (GLR)) (BAC (Y), BAC (Z)) = LGR (BAC (Y), BAC (Z))

What happened is that BAC was applied to the operator GLR and each of the operands Y and Z, and then BAC (GLR) was simplified.

	Yagbas	Boolean counterparts
Idempotence	Y GLR Y = Y	B ∧ B = B	B ∨ B = B
Annihilation	Y GLR PNZ = PNZ	B ∧ 0 = 0	B ∨ 1 = 1
Identity	Y GLR NPZ = Y	B ∧ 1 = B	B ∨ 0 = B
Absorption	Y GLR (Y LGR Z) = Y	B ∧ (B ∨ C) = B	B ∨ (B ∧ C) = B
Commutative law	Y GLR Z = Z GLR Y	B ∧ C = C ∧ B	B ∨ C = C ∨ B
Associative law	(X GLR Y) GLR Z = X GLR (Y GLR Z)	(B ∧ C) ∧ D = B ∧ (C ∧ D)	(B ∨ C) ∨ D = B ∨ (C ∨ D)
Distributive law	X GLR (Y LGR Z) = (X GLR Y) LGR (X GLR Z)	B ∧ (C ∨ D) = (B ∧ C) ∨ (B ∧ C)	B ∨ (C ∧ D) = (B ∨ C) ∧ (B ∨ C)

Legend:

• B, C and D are boolean variables, which in fuzzy logic lie between zero and one.
• ∧ denotes the most common definition of the AND (also known as MEET) function: B ∧ C = min (B, C)
• ∨ denotes the most common definition of the OR (also known as JOIN) function: B ∨ C = max (B, C)