  wedge-product

[Joe Monzo]

Wedge-product calculations are useful in tuning theory in two ways:

• calculating the wedge-product of a set of monzos (or vectors) gives a multimonzo (multivector), which shows a temperament's prime-mapping.
• calculating the wedge-product of a set of vals (or breeds) gives a wedgie (multival, multibreed), which shows the vanishing unison-vector which any set of temperaments shares in common.

Both multimonzos and wedgies show common traits shared by different tunings belonging to the same family, and thus are a great aid in tuning taxonomy.

. . . . . . . . .
[Dave Keenan, Yahoo tuning-math, message 8009 (Wed Nov 26, 2003 9:28 am)]

[how to calculate a wedge-product:]

Lets first take the simplest case worth considering. The wedge product of two 3-limit (2D) vectors.

```[a1 a2> ^ [b1 b2>
```

The procedure is to first list every product of a coefficient from A with a coefficient from B, i.e. their ordinary scalar products. So with 2 coefficients in each there will be 2x2 = 4 products to consider,

```a1*b1, a1*b2, a2*b1, a2*b2
```
.

As you calculate each product, combine the indices of the two coefficients to make a compound index for it. It is important to keep the indices in their original order at this stage. So we have

```product index

a1*b1   11
a1*b2   12
a2*b1   21
a2*b2   22
```

There are certain rules about what to to with each product now, depending on its compound index. There are 3 possibilities:

1. If the indexes have a digit in common then ignore it. Just throw the product away. So we throw away a1*b1 and a2*b2.
2. Otherwise if the digits in the compound index are already in alphabetical order, do nothing. So a1*b2 is just fine as it is.
3. Otherwise if they are not in alphabetical order, then put them in alphabetical order. But first, look at each digit of the compound index in turn, and count how many larger digits are to the left of it. Add up all these left-and-larger counts as you go, or just keep counting so their counts accumulate. If the result is an odd number then negate the product, otherwise leave it as it was. Consider the index 21. There are zero larger digits to the left of the 2 (because there are _no_ digits to the left of it), and there is one larger digit to the left of the 1, namely the 2. So the total of the left-and-larger counts is 1, an odd number. So a2*b1 becomes -a2*b1. We now have
```product index

a1*b2   12
-a2*b1   12
```

Now find any products that have the same index and add them together. So we have only

```-- product --  index

a1*b2 - a2*b1   12.
```

Now list all these sums in alphabetical order of their indices, inside as many brackets as the sum of the number of brackets in the two arguments, and pointing in the same direction. The wedge product is only defined for values having their brackets pointing the same way.

```[[a1*b2-a2*b1>>
```

Now lets try something more messy. A 7-limit (4D) vector wedged with a 7-limit bivector. This might represent combining a third comma with two that have already been combined, as an intermediate result on the way to finding the ET mapping where these all vanish.

```[a1 a2 a3 a4> ^ [[b12 b13 b14 b23 b24 b34>>
```

We first make the list of products of all pairs, with their compound indices.

```product index

a1*b12   112
a1*b13   113
a1*b14   114
a1*b23   123
a1*b24   124
a1*b34   134
a2*b12   212
a2*b13   213
a2*b14   214
a2*b23   223
a2*b24   224
a2*b34   234
a3*b12   312
a3*b13   313
a3*b14   314
a3*b23   323
a3*b24   324
a3*b34   334
a4*b12   412
a4*b13   413
a4*b14   414
a4*b23   423
a4*b24   424
a4*b34   434
```

Now we get rid of all those with two digits the same. Of course once you've got the idea, you wouldn't even bother writing them down in the first place. This leaves.

```product index left-and-larger count

a1*b23  123
a1*b24  124
a1*b34  134
a2*b13  213     1
a2*b14  214     1
a2*b34  234
a3*b12  312     2
a3*b14  314     1
a3*b24  324     1
a4*b12  412     2
a4*b13  413     2
a4*b23  423     2
```

And we do the left-and-larger counts on the indices that aren't already in alphabetical order (shown above), and negate the product if this is odd. And we end up with:

```product index

a1*b23  123
a1*b24  124
a1*b34  134
-a2*b13  123
-a2*b14  124
a2*b34  234
a3*b12  123
-a3*b14  134
-a3*b24  234
a4*b12  124
a4*b13  134
a4*b23  234
```

Now we sum the products having the same index.

```------- product --------   index

a1*b23 + a3*b12 - a2*b13    123
a1*b24 - a2*b14 + a4*b12    124
a1*b34 - a3*b14 + a4*b13    134
a2*b34 - a3*b24 + a4*b23    234
```

Now we list them in alphabetical (also numerical) order of index inside the correct number of brackets.

```[[[a1*b23+a3*b12-a2*b13 a1*b24-a2*b14+a4*b12 a1*b34-a3*b14+a4*b13 a2*b34-a3*b24+a4*b23>>>
```

Voila!

. . . . . . . . .

The tonalsoft.com website is almost entirely the work of one person: me, Joe Monzo. Please reward me for my knowledge and effort by choosing your preferred level of financial support. Thank you.

 support level donor: \$5 USD friend: \$25 USD patron: \$50 USD savior: \$100 USD angel of tuning: \$500 USD microtonal god: \$1000 USD 