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 ≤ Y_{a} ≤ +1 |
−1 ≤ Y_{b} ≤ +1 |
−1 ≤ Y_{c} ≤ +1 |
Y_{a} + Y_{b} + Y_{c} = 0 |
Immediate consequences are:
−1 ≤ (Y_{a} + Y_{b}) ≤ +1 |
−1 ≤ (Y_{b} + Y_{c}) ≤ +1 |
−1 ≤ (Y_{c} + Y_{a}) ≤ +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:
x_{2D} = x_{3D} ∗ (sqrt (1/12) + 1/2) + y_{3D} ∗ (sqrt (1/12) − 1/2) − z_{3D} ∗ sqrt (1/3) |
y_{2D} = x_{3D} ∗ (sqrt (1/12) − 1/2) + y_{3D} ∗ (sqrt (1/12) + 1/2) − z_{3D} ∗ 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 = ⟨ − Y_{a}, − Y_{b}, − Y_{c} ⟩ |
Patently,
PNZ = − NPZ |
PZN = − NZP |
ZPN = − ZNP |
Each of six permutative operators has a three-letter name:
ABC Y = ⟨ Y_{a}, Y_{b}, Y_{c} ⟩ |
ACB Y = ⟨ Y_{a}, Y_{c}, Y_{b} ⟩ |
CAB Y = ⟨ Y_{c}, Y_{a}, Y_{b} ⟩ |
BAC Y = ⟨ Y_{b}, Y_{a}, Y_{c} ⟩ |
BCA Y = ⟨ Y_{b}, Y_{c}, Y_{a} ⟩ |
CBA Y = ⟨ Y_{c}, Y_{b}, Y_{a} ⟩ |
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:
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 (Y_{a}, Z_{a}), min (Y_{b}, Z_{b}), ρ ⟩ |
GRL (Y, Z) = Y GRL Z = ⟨ max (Y_{a}, Z_{a}), ρ, min (Y_{c}, Z_{c}) ⟩ |
RGL (Y, Z) = Y RGL Z = ⟨ ρ, max (Y_{b}, Z_{b}), min (Y_{c}, Z_{c}) ⟩ |
LGR (Y, Z) = Y LGR Z = ⟨ min (Y_{a}, Z_{a}), max (Y_{b}, Z_{b}), ρ ⟩ |
LRG (Y, Z) = Y LRG Z = ⟨ min (Y_{a}, Z_{a}), ρ, max (Y_{c}, Z_{c}) ⟩ |
RLG (Y, Z) = Y RLG Z = ⟨ ρ, min (Y_{b}, Z_{b}), max (Y_{c}, Z_{c}) ⟩ |
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:
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: