tastoids

Tastoids (& their ‘Temperate’ Algebra)

It is often said, one can’t compare “apples” to “oranges”, but I daresay.. perhaps you can?

Let me show you how.

On their own, it is hard to figure how one might compare apples to oranges, let alone deign to approach a calculus of taste however, with just enough structure, a Taste can become a Tastoid, along with a curious and powerful Temperate Algebra.

Not unlike a Tropical geometry, where the notion of addition and multiplication are replaced by min(a,b) & add(a,b), I pose that a Temperate Algebra is one whose typical notions of (+,×) are replaced with operations that effectively ‘average’ taste (with commutativity, distributivity and reversibility, no less!)

A Taste (t) Field

“Tastes”, broadly, are any measurable/comparable sentiment about a thing. Something with a unique direction and magnitude. A vector!

Consider if you will, then:

In the context of large-language- and embedding-models, this idea of mapping things (text or otherwise) into a well-defined set of possible indices and probabilities is referred to as an ‘embedding’.

A Taste -> One Tastoid

We’re almost there, I promise. Lets talk about plain numbers for a bit; say I told you knew the average of some set of values was 42. You also know for a fact there was a 13 in there once, somewhere.

Knowing nothing else, how would you un-average 13 from 42?

Were there two values that averaged to 42? Three? More?

Without the cardinality of the original sampling, its (absolutely) impossible to know. But with it… say n=13, in which case, we can merely remove 1/13th of 13 (i.e. 1) from our combined average to find out the average without that 13 was just 41.

Similarly, on their own Taste vectors are comparable, even averagable in some sense, but without a cardinality, their operations aren’t quite lined up to have solutions to previously impossible questions become possible and yield seemingly ‘free’ results.

Attempting to put some formalism to the above,

Then, we may define a handful a tiny, tidy, yet supremely powerful (σ/sigma-) Algebra of Taste_

Values

pub fn bland(
  left: tastoid.Tastoid(space),
  excluding right: tastoid.Tastoid(space),
) -> tastoid.Tastoid(space)

Experimental Return the ‘not-and’-product, letting the maths take the wheel.

Avery’s guess is this will act like a harsh move away the interesected indices, conversely strengthening everything else

Bland : A, B -> (A ⩐ B) - (A ⩍ B)

pub fn blend(
  t: tastoid.Tastoid(index),
  with u: tastoid.Tastoid(index),
) -> tastoid.Tastoid(index)

Blend () two tastoids, producing a larger tastoid congruent to the weighted power mean, aka their average ‘taste’ (via squash).

See also retract - which yields u’ which unblends when blended,

pub fn both(
  tastoid left: tastoid.Tastoid(space),
  and right: tastoid.Tastoid(space),
) -> tastoid.Tastoid(space)

Return the ‘and’-product (), multiplying tastes/cardinalities between left and right; effectively erasing unshared tastes.

pub fn distance(
  covered_by tastoid: tastoid.Tastoid(space),
) -> Float

Returns a Tastoid’s scalar value length, discarding its cardinality

nb. This doesn’t need to be a length(of: tastoid) result, and in fact they yield the same value over distance(covered_by:)

pub fn equal(
  t: tastoid.Tastoid(index),
  u: tastoid.Tastoid(index),
) -> Bool

Returns True iff Tastoids t & u are congruent (weakly equivalent)

pub fn length(
  of tastoid: tastoid.Tastoid(space),
) -> tastoid.Tastoid(set.Set(space))

Project a tastoid into a Length-oid of sorts, condensing it into a 1-d tastoid indexed by the set of its indexes, and a value of its dimensions sum.

pub fn less(
  divisor: tastoid.Tastoid(space),
  from numerator: tastoid.Tastoid(space),
) -> tastoid.Tastoid(space)

Unblend a Tastoid (the divisor), removing it from another (the numerator).

nb. This works even if the divisor tastoid isn’t in the from Tastoid.

pub fn retract(
  taste: tastoid.Tastoid(index),
) -> tastoid.Tastoid(index)

Return the inverse of a taste (over blend)

pub fn smashing(
  t: tastoid.Tastoid(index),
  with u: tastoid.Tastoid(index),
) -> tastoid.Tastoid(index)

Blend, squashing, aka ‘smash’ as it is effectively the smash-product (⨳), or t ⨳ u (see Smash Product)

pub fn squash(
  to_norm tastoid: tastoid.Tastoid(index),
) -> tastoid.Tastoid(index)

Reduce k -> 1, yielding the ‘average’/normalized tastoid of all the tastoids blended/present

Search Document