BasicNotions.hpp File Reference

Plans on groupoids regarding the most basic notions. More...

Go to the source code of this file.

Detailed Description

Plans on groupoids regarding the most basic notions.

Notions and notations
  • A "groupoid" ("grd") is a pair [V,f] such that V is a set and f: V^2 -> V; thus a groupoid is formally exactly a square combinatorial matrix over V with index set V.
  • A "semigroup" ("sgr") is a groupoid with associative f.
  • A "unital groupoid" ("ugrd") is a triple [V,f,e] such that [V,f] is a groupoid and e is the identity element.
  • A "monoid" ("mon") is a unital groupoid [V,f,e] such that [V,f] is a semigroup.
  • For groups we provide four different signatures:
    • A "group" ("grp") is a semigroup [V,f] such that there exists an identity element and every element has an inverse.
    • A "group with identity" ("grp0") is a monoid [V,f,e] such that every element has an inverse.
    • A "group with inverse" ("grp1") is a triple [V,f,i] such that [V,f] is a semigroup which has an identity element, and where i: V -> V provides for every element an inverse.
    • A "group with identity and inverse" ("grp01") is a quadruple [V,f,e,i] such that [V,f,e] is a group with identity and [V,f,i] is a group with inverse.
  • Quasigroups:
    • A "quasigroup" ("qgrp") is a groupoid [V,f] such that every linear equation a*x = b has a unique solution x.
    • A "quasigroup with solution" ("qgrp2") is a triple [V,f,s] such that [V,f] is a quasigroup and s: V^2 -> V provides the solution, i.e., for all a,b in V we have a*s(a,b) = b.
    • There is the issue of a*x=b and x*a=b ?
  • Promotions are grp2grp0, grp2grp1, grp2grp01, and then we have the down-casts ugrd2grd, grp02grp, grp12grp, etc..
    1. Two consecutive digits don't look good?
      1. We could speak of "ugrp" (unital group, i.e., group with neutral element) and "grpi" (group with inverse), and "ugrpi".
      2. Then we should also use "qgrps".
    2. It seems that for example mon2sem is not needed since we have ugrd2grd, and there are no types attached to the objects.
  • All the above likely should also exist in ordered versions, with prefix "o".
    1. However, an "ordered monoid" for example usually is a monoid with a partial order which is compatible with the composition?!?
    2. Perhaps here we should use something like "listified monoid" ?
  • A fundamental problem is that for example lambda-expressions cannot be put (reliably) into a set (equality would be decided here w.r.t. identicallity of terms):
    1. So besides "set-groupoids" we need other forms of groupoids.
    2. The base-set could be specified by a pair [n,l], where n is a natural number from 0 to inf, specifying the size of the initial segment of NN to be considered, while l is a labelling functions, which assigns a label to each now standardised element.
    3. In this way also certain infinite groups could be handled; but the rational numbers for example only clumsily.
    4. On the other hand we could use "implicit" representations by pairs [p,l], where p is some predicate (the inverse image of true specifies the set), while l is a labelling function defined on the elements of the set).
    5. Perhaps we introduce a module "Sets" in ComputerAlgebra/DataStructures for handling all these different set representations.
    6. On the other hand, the labelling function can be used with arbitrary sets, and this seems preferable.
    7. And the labelling function can be hidden in the other functions which need them (the composition etc.), and perhaps this suffices, at least for the moment.
    8. So we just stick to the naive concepts?
    9. But a problem occurs with automorphism groups, since our morphisms are just maps?!
    10. One solution would be to make the group element then just the corresponding lists-as-permutations, or some other presentation (the index in some standard enumeration, a cycle presentation etc).
    11. The only point in attaching the labelling function to the group presentation would be that then we know how to find it; perhaps we have the convention, that labelling functions are collected into one list, which is attached as the last element of the groupoid-as-list etc.
Partial groupoids, and extensions
  • We need "partial groupoids" ("pargrd").
  • Regarding extensions, we might want to add for example a partial inversion, and a null element; then we have the problem of the ordering of these components?
  • Perhaps such non-standard extensions are always added as a list, which is the final element of the list representing the structure.
Different forms of tests
  • Especially for groups there are different forms of the tests for defining properties, which exploit that the basic "axioms" are not independent.
  • We need to provide these different versions.
  • How to name them?
  • And which version shall be the default?

Definition in file BasicNotions.hpp.