On 24/12/2021 02:43, sobriquet wrote:
> On Friday, December 24, 2021 at 12:45:52 AM UTC+1, Mike Terry wrote:
>> On 23/12/2021 04:32, sobriquet wrote:
>>> On Thursday, December 23, 2021 at 5:00:01 AM UTC+1, Mike Terry wrote:
>>>> On 23/12/2021 03:46, sobriquet wrote:
>>>>> On Thursday, December 23, 2021 at 4:39:55 AM UTC+1, Mike Terry wrote:
>>>>>> On 23/12/2021 01:42, sobriquet wrote:
>>>>>>> Hi.
>>>>>>>
>>>>>>> Online I can find references to the logical xor operation forming a group
>>>>>>> on boolean values or bitstrings (binary vectors), but how about the xnor operation, is that also a group on the set of bits or the set of binary vectors?
>>>>>> Yes. You can check out that the operation is closed, associative, and (1,1,1,...1) is the identity,
>>>>>> and every element has itself as its own inverse. Also, it's commutative, so we have an abelian
>>>>>> group. (Checking is much like checking for XOR.)
>>>>>>
>>>>>> Mike.
>>>>>
>>>>> Ok, I think I would agree on that. But then I'm confused by the claim that there supposedly
>>>>> is only a single group (up to isomorphism) of order two.
>>>>> So, if we restrict our attention to bits {0,1}, does that mean that the group
>>>>> of (xor, {0,1}) is isomorphic to the group (xnor, {0,1})?
>>>> Exactly - the groups are essentially the same, but with the roles of 0 and 1 reversed.
>>>>
>>>> The isomorphism takes (b0, b1, b2, ...bn) to (b0', b1', b2', ...bn'), where 0' = 1, 1' = 0.
>>>> Mike.
>>>>>
>>>>> https://oeis.org/wiki/Number_of_groups_of_order_n
>>>>>
>>>>>
>>>>>>>
>>>>>>> https://accu.org/journals/overload/20/109/lewin_1915/
>>>>>>>
>>>>>>> "We have already seen that XOR is associative, that the vector (F, … F) is the identity element and that every element has itself as an inverse. It’s easy to see that it is also closed over the set. Hence (S, XOR) is a group."
>>>>>>>
>>>>>>> https://math.stackexchange.com/questions/2599027/is-there-a-logic-gate-nand-or-etc-which-forms-a-group-under-the-set-0-1
>>>>>>>
>>>
>>> I see.. so it would be completely analogous to the abelian group of addition modulo 2 on the set {0,1} being isomorphic to the group of multiplication on the set {-1, 1}? And in fact all four groups being isomorphic.
>>>
>>> 0 + 0 = 0
>>> 0 + 1 = 1
>>> 1 + 0 = 1
>>> 1 + 1 = 0
>>>
>>> -1 * -1 = 1
>>> -1 * 1 = -1
>>> 1 * -1 = -1
>>> 1 * 1 = 1
>>>
>> Yes. Sometimes our knowledge of particular examples (operations like addition/multiplication/other
>> combined with the meanings we already know for particular elements) can get in the way of seeing the
>> underlying structure. In the case of XOR, XNOR perhaps the way to be convinced they are
>> "structurally" the same is to (1) write out the operation in a table, and (2) the further rewrite
>> those tables using a neutral a,b for the elements, with a representing the identity (and b the other
>> element of course):
>>
>> XOR:
>> 0 1
>> --+------
>> 0 | 0 1
>> 1 | 1 0
>>
>> using a=identity=0 , b=1:
>>
>> a b
>> --+------
>> a | a b
>> b | b a
>>
>>
>> XNOR:
>> 0 1
>> --+------
>> 0 | 1 0
>> 1 | 0 1
>>
>> using a=identity=1 , b=0:
>>
>> b a
>> --+------
>> b | a b
>> a | b a
>>
>> (same as for XOR, but just in a different order)
>>
>> Mike.
>
> In general group theory is conceptually very confusing, for instance in the way
> operations that act on the set of elements are themselves elements of that set.
> So there is no clear distinction like you have in traditional arithmetic or algebra where
> expressions like 4 + 6 or (8 - a) * 2b make sense because there is a clear distinction
> between the numbers/constants/variables that operations act on and the operations
> that act on those numbers/constants/variables.
> But it wouldn't make sense to have expressions like (* + /) - -, where
> you add multiplication and division and subsequently subtract subtraction.
>
> xor 00 01 10 11
> 00 00 01 10 11
> 01 01 00 11 10
> 10 10 11 00 01
> 11 11 10 01 00
>
> xnor 00 01 10 11
> 00 11 10 10 00
> 01 10 11 00 10
> 10 01 00 11 10
> 11 00 01 10 11
>
> a b c d
> a a b c d
> b b a d c
> c c d a b
> d d c b a
>
> I dunno.. somehow I can't really see how they are both isomorphic to that abstract
> structure. It seems that if you map (a,b,c,d) to (00,01,10,11), you get xor, but
> if you map (a,b,c,d) to (11,10,01,00) you don't seem to get xnor.
>
> ???? 11 10 01 00
> 11 11 10 10 00
> 10 10 11 00 10
> 01 01 00 11 10
> 00 00 01 10 11

XOR:

xor 00 01 10 11
00 00 01 10 11
01 01 00 11 10
10 10 11 00 01
11 11 10 01 00

xor a b c d
a a b c d
b b a d c
c c d a b
d d c b a

XNOR:

(your XNOR table above has miscalculations, should be: )

xnor 00 01 10 11
00 11 10 01 00
01 10 11 00 01
10 01 00 11 10
11 00 01 10 11

and using (a,b,c,d) for (11,10,01,00) :

xnor d c b a
d a b c d
c b a d c
b c d a b
a d c b a

which is the same as the xor table, but reordered...

Mike.

On Friday, December 24, 2021 at 1:06:35 PM UTC+1, Mike Terry wrote:
> On 24/12/2021 02:43, sobriquet wrote:
> > On Friday, December 24, 2021 at 12:45:52 AM UTC+1, Mike Terry wrote:
> >> On 23/12/2021 04:32, sobriquet wrote:
> >>> On Thursday, December 23, 2021 at 5:00:01 AM UTC+1, Mike Terry wrote:
> >>>> On 23/12/2021 03:46, sobriquet wrote:
> >>>>> On Thursday, December 23, 2021 at 4:39:55 AM UTC+1, Mike Terry wrote:
> >>>>>> On 23/12/2021 01:42, sobriquet wrote:
> >>>>>>> Hi.
> >>>>>>>
> >>>>>>> Online I can find references to the logical xor operation forming a group
> >>>>>>> on boolean values or bitstrings (binary vectors), but how about the xnor operation, is that also a group on the set of bits or the set of binary vectors?
> >>>>>> Yes. You can check out that the operation is closed, associative, and (1,1,1,...1) is the identity,
> >>>>>> and every element has itself as its own inverse. Also, it's commutative, so we have an abelian
> >>>>>> group. (Checking is much like checking for XOR.)
> >>>>>>
> >>>>>> Mike.
> >>>>>
> >>>>> Ok, I think I would agree on that. But then I'm confused by the claim that there supposedly
> >>>>> is only a single group (up to isomorphism) of order two.
> >>>>> So, if we restrict our attention to bits {0,1}, does that mean that the group
> >>>>> of (xor, {0,1}) is isomorphic to the group (xnor, {0,1})?
> >>>> Exactly - the groups are essentially the same, but with the roles of 0 and 1 reversed.
> >>>>
> >>>> The isomorphism takes (b0, b1, b2, ...bn) to (b0', b1', b2', ...bn'), where 0' = 1, 1' = 0.
> >>>> Mike.
> >>>>>
> >>>>> https://oeis.org/wiki/Number_of_groups_of_order_n
> >>>>>
> >>>>>
> >>>>>>>
> >>>>>>> https://accu.org/journals/overload/20/109/lewin_1915/
> >>>>>>>
> >>>>>>> "We have already seen that XOR is associative, that the vector (F, … F) is the identity element and that every element has itself as an inverse. It’s easy to see that it is also closed over the set. Hence (S, XOR) is a group."
> >>>>>>>
> >>>>>>> https://math.stackexchange.com/questions/2599027/is-there-a-logic-gate-nand-or-etc-which-forms-a-group-under-the-set-0-1
> >>>>>>>
> >>>
> >>> I see.. so it would be completely analogous to the abelian group of addition modulo 2 on the set {0,1} being isomorphic to the group of multiplication on the set {-1, 1}? And in fact all four groups being isomorphic.
> >>>
> >>> 0 + 0 = 0
> >>> 0 + 1 = 1
> >>> 1 + 0 = 1
> >>> 1 + 1 = 0
> >>>
> >>> -1 * -1 = 1
> >>> -1 * 1 = -1
> >>> 1 * -1 = -1
> >>> 1 * 1 = 1
> >>>
> >> Yes. Sometimes our knowledge of particular examples (operations like addition/multiplication/other
> >> combined with the meanings we already know for particular elements) can get in the way of seeing the
> >> underlying structure. In the case of XOR, XNOR perhaps the way to be convinced they are
> >> "structurally" the same is to (1) write out the operation in a table, and (2) the further rewrite
> >> those tables using a neutral a,b for the elements, with a representing the identity (and b the other
> >> element of course):
> >>
> >> XOR:
> >> 0 1
> >> --+------
> >> 0 | 0 1
> >> 1 | 1 0
> >>
> >> using a=identity=0 , b=1:
> >>
> >> a b
> >> --+------
> >> a | a b
> >> b | b a
> >>
> >>
> >> XNOR:
> >> 0 1
> >> --+------
> >> 0 | 1 0
> >> 1 | 0 1
> >>
> >> using a=identity=1 , b=0:
> >>
> >> b a
> >> --+------
> >> b | a b
> >> a | b a
> >>
> >> (same as for XOR, but just in a different order)
> >>
> >> Mike.
> >
> > In general group theory is conceptually very confusing, for instance in the way
> > operations that act on the set of elements are themselves elements of that set.
> > So there is no clear distinction like you have in traditional arithmetic or algebra where
> > expressions like 4 + 6 or (8 - a) * 2b make sense because there is a clear distinction
> > between the numbers/constants/variables that operations act on and the operations
> > that act on those numbers/constants/variables.
> > But it wouldn't make sense to have expressions like (* + /) - -, where
> > you add multiplication and division and subsequently subtract subtraction.
> >
> > xor 00 01 10 11
> > 00 00 01 10 11
> > 01 01 00 11 10
> > 10 10 11 00 01
> > 11 11 10 01 00
> >
> > xnor 00 01 10 11
> > 00 11 10 10 00
> > 01 10 11 00 10
> > 10 01 00 11 10
> > 11 00 01 10 11
> >
> > a b c d
> > a a b c d
> > b b a d c
> > c c d a b
> > d d c b a
> >
> > I dunno.. somehow I can't really see how they are both isomorphic to that abstract
> > structure. It seems that if you map (a,b,c,d) to (00,01,10,11), you get xor, but
> > if you map (a,b,c,d) to (11,10,01,00) you don't seem to get xnor.
> >
> > ???? 11 10 01 00
> > 11 11 10 10 00
> > 10 10 11 00 10
> > 01 01 00 11 10
> > 00 00 01 10 11
> XOR:
> xor 00 01 10 11
> 00 00 01 10 11
> 01 01 00 11 10
> 10 10 11 00 01
> 11 11 10 01 00
> xor a b c d
> a a b c d
> b b a d c
> c c d a b
> d d c b a
> XNOR:
>
> (your XNOR table above has miscalculations, should be: )
> xnor 00 01 10 11
> 00 11 10 01 00
> 01 10 11 00 01
> 10 01 00 11 10
> 11 00 01 10 11

Oops, right.

> and using (a,b,c,d) for (11,10,01,00) :
>
> xnor d c b a
> d a b c d
> c b a d c
> b c d a b
> a d c b a
>
> which is the same as the xor table, but reordered...
>
> Mike.

Ah ok, yeah I see it now.. reversing the horizontal
and vertical indexes amounts to a 180 degree rotation of the square part, which
leaves it unchanged because it's symmetrical about the diagonals.

On 24/12/2021 02:43, sobriquet wrote:
<snip>
>
> In general group theory is conceptually very confusing, for instance in the way
> operations that act on the set of elements are themselves elements of that set.
> So there is no clear distinction like you have in traditional arithmetic or algebra where
> expressions like 4 + 6 or (8 - a) * 2b make sense because there is a clear distinction
> between the numbers/constants/variables that operations act on and the operations
> that act on those numbers/constants/variables.
> But it wouldn't make sense to have expressions like (* + /) - -, where
> you add multiplication and division and subsequently subtract subtraction.

The basic idea of a group is very simple - you have a set, an operation on members of the set, and a
few rules the operation has to satisfy. The operation is not itself a member of that set! So there
is a clear distinction between elements of the group and the operation that acts on them. In
arithmetic, it makes no sense to have an expression like "(* + /) - -" and the same is true for
groups. In group theory there are expressions like "a+b-c-c-c+0" or "a+b-3c+0" if we use additive
notation, or "ab(c^-1)(c^-1)(c^-1)1" if using multiplicative notation.

But group theory can get very abstract. We don't just have the groups themselves - we have maps
between groups that preserve aspects of the group structure (homomorphisms), and those maps can be
combined and can themselves make up new groups where the operation is map composition. And groups
can be combined to make the "direct product" of two groups. This is what we're doing when we start
with the boolean group on one single bit (with 2 elements), and use it to create the "n-bit" boolean
group as we've been discussing.

Some maths people just lap up the abstractness, while others are happier with less abstract areas.
For myself, I was always more comfortable with the more concrete real/complex analysis topics, but
algebra can be fun as well. :)

Mike.

On 12/24/2021 6:06 AM, Mike Terry wrote:
> On 24/12/2021 02:43, sobriquet wrote:
>> On Friday, December 24, 2021 at 12:45:52 AM UTC+1, Mike Terry wrote:
>>> On 23/12/2021 04:32, sobriquet wrote:
>>>> On Thursday, December 23, 2021 at 5:00:01 AM UTC+1, Mike Terry wrote:
>>>>> On 23/12/2021 03:46, sobriquet wrote:
>>>>>> On Thursday, December 23, 2021 at 4:39:55 AM UTC+1, Mike Terry wrote:
>>>>>>> On 23/12/2021 01:42, sobriquet wrote:
>>>>>>>> Hi.
>>>>>>>>
>>>>>>>> Online I can find references to the logical xor operation forming a group
>>>>>>>> on boolean values or bitstrings (binary vectors), but how about the xnor operation, is that also a group on the set of bits or the set of binary
>>>>>>>> vectors?
>>>>>>> Yes. You can check out that the operation is closed, associative, and (1,1,1,...1) is the identity,
>>>>>>> and every element has itself as its own inverse. Also, it's commutative, so we have an abelian
>>>>>>> group. (Checking is much like checking for XOR.)
>>>>>>>
>>>>>>> Mike.
>>>>>>
>>>>>> Ok, I think I would agree on that. But then I'm confused by the claim that there supposedly
>>>>>> is only a single group (up to isomorphism) of order two.
>>>>>> So, if we restrict our attention to bits {0,1}, does that mean that the group
>>>>>> of (xor, {0,1}) is isomorphic to the group (xnor, {0,1})?
>>>>> Exactly - the groups are essentially the same, but with the roles of 0 and 1 reversed.
>>>>>
>>>>> The isomorphism takes (b0, b1, b2, ...bn) to (b0', b1', b2', ...bn'), where 0' = 1, 1' = 0.
>>>>> Mike.
>>>>>>
>>>>>> https://oeis.org/wiki/Number_of_groups_of_order_n
>>>>>>
>>>>>>
>>>>>>>>
>>>>>>>> https://accu.org/journals/overload/20/109/lewin_1915/
>>>>>>>>
>>>>>>>> "We have already seen that XOR is associative, that the vector (F, … F) is the identity element and that every element has itself as an inverse.
>>>>>>>> It’s easy to see that it is also closed over the set. Hence (S, XOR) is a group."
>>>>>>>>
>>>>>>>> https://math.stackexchange.com/questions/2599027/is-there-a-logic-gate-nand-or-etc-which-forms-a-group-under-the-set-0-1
>>>>>>>>
>>>>
>>>> I see.. so it would be completely analogous to the abelian group of addition modulo 2 on the set {0,1} being isomorphic to the group of
>>>> multiplication on the set {-1, 1}? And in fact all four groups being isomorphic.
>>>>
>>>> 0 + 0 = 0
>>>> 0 + 1 = 1
>>>> 1 + 0 = 1
>>>> 1 + 1 = 0
>>>>
>>>> -1 * -1 = 1
>>>> -1 * 1 = -1
>>>> 1 * -1 = -1
>>>> 1 * 1 = 1
>>>>
>>> Yes. Sometimes our knowledge of particular examples (operations like addition/multiplication/other
>>> combined with the meanings we already know for particular elements) can get in the way of seeing the
>>> underlying structure. In the case of XOR, XNOR perhaps the way to be convinced they are
>>> "structurally" the same is to (1) write out the operation in a table, and (2) the further rewrite
>>> those tables using a neutral a,b for the elements, with a representing the identity (and b the other
>>> element of course):
>>>
>>> XOR:
>>> 0 1
>>> --+------
>>> 0 | 0 1
>>> 1 | 1 0
>>>
>>> using a=identity=0 , b=1:
>>>
>>> a b
>>> --+------
>>> a | a b
>>> b | b a
>>>
>>>
>>> XNOR:
>>> 0 1
>>> --+------
>>> 0 | 1 0
>>> 1 | 0 1
>>>
>>> using a=identity=1 , b=0:
>>>
>>> b a
>>> --+------
>>> b | a b
>>> a | b a
>>>
>>> (same as for XOR, but just in a different order)
>>>
>>> Mike.
>>
>> In general group theory is conceptually very confusing, for instance in the way
>> operations that act on the set of elements are themselves elements of that set.
>> So there is no clear distinction like you have in traditional arithmetic or algebra where
>> expressions like 4 + 6 or (8 - a) * 2b make sense because there is a clear distinction
>> between the numbers/constants/variables that operations act on and the operations
>> that act on those numbers/constants/variables.
>> But it wouldn't make sense to have expressions like  (* + /) - -, where
>> you add multiplication and division and subsequently subtract subtraction.
>>
>> xor  00 01 10 11
>> 00   00 01 10 11
>> 01   01 00 11 10
>> 10   10 11 00 01
>> 11   11 10 01 00
>>
>> xnor 00 01 10 11
>> 00    11 10 10 00
>> 01    10 11 00 10
>> 10    01 00 11 10
>> 11    00 01 10 11
>>
>>      a b c d
>> a  a b c d
>> b  b a d c
>> c  c d a b
>> d  d c b a
>>
>> I dunno.. somehow I can't really see how they are both isomorphic to that abstract
>> structure. It seems that if you map (a,b,c,d) to (00,01,10,11), you get xor, but
>> if you map (a,b,c,d) to (11,10,01,00) you don't seem to get xnor.
>>
>> ???? 11 10 01 00
>> 11    11 10 10 00
>> 10    10 11 00 10
>> 01    01 00 11 10
>> 00    00 01 10 11

why does 4 inputs give you 2 outputs ?

>
> XOR:
>
>  xor  00 01 10 11
>  00   00 01 10 11
>  01   01 00 11 10
>  10   10 11 00 01
>  11   11 10 01 00

why does 4 inputs give you 2 outputs ?

>
>  xor a b c d
>  a   a b c d
>  b   b a d c
>  c   c d a b
>  d   d c b a

xor is undefined for 4 level input logic

>
> XNOR:
>
> (your XNOR table above has miscalculations, should be: )
>
>  xnor  00 01 10 11
>  00    11 10 01 00
>  01    10 11 00 01
>  10    01 00 11 10
>  11    00 01 10 11

why does 4 inputs give you 2 outputs ? should be one.

>
> and using (a,b,c,d) for (11,10,01,00) :
>
>  xnor  d c b a
>  d     a b c d
>  c     b a d c
>  b     c d a b
>  a     d c b a

>
> which is the same as the xor table, but reordered...
>
> Mike.

On Friday, December 24, 2021 at 3:44:09 PM UTC+1, Mike Terry wrote:
> On 24/12/2021 02:43, sobriquet wrote:
> <snip>
> >
> > In general group theory is conceptually very confusing, for instance in the way
> > operations that act on the set of elements are themselves elements of that set.
> > So there is no clear distinction like you have in traditional arithmetic or algebra where
> > expressions like 4 + 6 or (8 - a) * 2b make sense because there is a clear distinction
> > between the numbers/constants/variables that operations act on and the operations
> > that act on those numbers/constants/variables.
> > But it wouldn't make sense to have expressions like (* + /) - -, where
> > you add multiplication and division and subsequently subtract subtraction.
> The basic idea of a group is very simple - you have a set, an operation on members of the set, and a
> few rules the operation has to satisfy. The operation is not itself a member of that set! So there
> is a clear distinction between elements of the group and the operation that acts on them.

But the elements of the set are often interpreted as actions and the group operation as
consecutively composing actions.
These actions are applied to the actions themselves.
Take for instance the example of dihedral groups shown here:

https://i.imgur.com/HrpCG1s.png

https://www.youtube.com/watch?v=jZCG-ac7I_s

The red arrow in those graphs corresponds with action 'r' and the blue line corresponds
with action 'f', and these actions can be applied to themselves. So for instance r(r) = r^2,
while f(f) = e.

> In
> arithmetic, it makes no sense to have an expression like "(* + /) - -" and the same is true for
> groups. In group theory there are expressions like "a+b-c-c-c+0" or "a+b-3c+0" if we use additive
> notation, or "ab(c^-1)(c^-1)(c^-1)1" if using multiplicative notation.
>
> But group theory can get very abstract. We don't just have the groups themselves - we have maps
> between groups that preserve aspects of the group structure (homomorphisms), and those maps can be
> combined and can themselves make up new groups where the operation is map composition. And groups
> can be combined to make the "direct product" of two groups. This is what we're doing when we start
> with the boolean group on one single bit (with 2 elements), and use it to create the "n-bit" boolean
> group as we've been discussing.
>
> Some maths people just lap up the abstractness, while others are happier with less abstract areas.
> For myself, I was always more comfortable with the more concrete real/complex analysis topics, but
> algebra can be fun as well. :)
>
> Mike.

Abstraction is ok, but it gets a bit confusing at very high levels of abstraction since
there doesn't seem to be a reliable way to distinguish between things that make
sense and things that don't make sense. It would be nice to have some kind of unified
conceptual basis or framework (like set theory or category theory).

On Friday, December 24, 2021 at 3:55:47 PM UTC+1, Serg io wrote:
>[..]
> > XOR:
> >
> > xor 00 01 10 11
> > 00 00 01 10 11
> > 01 01 00 11 10
> > 10 10 11 00 01
> > 11 11 10 01 00
> why does 4 inputs give you 2 outputs ?
>[..]

The basic operation maps a combination of two bits to a single bit.
xor(0,0) = 0
xor(0,1) = 1
xor(1,0) = 1
xor(1,1) = 0

But we can extend the operation to bitstrings of fixed length by consecutively
applying them to each position in the bitstring (bitwise application).

xor(00,00) = 00
xor(00,01) = 01
xor(00,10) = 10
xor(00,11) = 11
xor(01,00) = 01
xor(01,01) = 00
xor(01,10) = 11
xor(01,11) = 10
xor(10,00) = 10
xor(10,01) = 11
xor(10,10) = 00
xor(10,11) = 01
xor(11,00) = 00
xor(11,01) = 10
xor(11,10) = 01
xor(11,11) = 00

Or, another example with bitstrings of length 4:

https://i.imgur.com/bm0DwnT.png

http://easyonlineconverter.com/converters/bitwise-calculator.html

On Friday, December 24, 2021 at 4:29:48 PM UTC+1, sobriquet wrote:
> On Friday, December 24, 2021 at 3:55:47 PM UTC+1, Serg io wrote:
> >[..]
> > > XOR:
> > >
> > > xor 00 01 10 11
> > > 00 00 01 10 11
> > > 01 01 00 11 10
> > > 10 10 11 00 01
> > > 11 11 10 01 00
> > why does 4 inputs give you 2 outputs ?
> >[..]
>
> The basic operation maps a combination of two bits to a single bit.
> xor(0,0) = 0
> xor(0,1) = 1
> xor(1,0) = 1
> xor(1,1) = 0
>
> But we can extend the operation to bitstrings of fixed length by consecutively
> applying them to each position in the bitstring (bitwise application).
>
> xor(00,00) = 00
> xor(00,01) = 01
> xor(00,10) = 10
> xor(00,11) = 11
> xor(01,00) = 01
> xor(01,01) = 00
> xor(01,10) = 11
> xor(01,11) = 10
> xor(10,00) = 10
> xor(10,01) = 11
> xor(10,10) = 00
> xor(10,11) = 01
> xor(11,00) = 00

oops... that should be:

xor(11,00) = 11

> xor(11,01) = 10
> xor(11,10) = 01
> xor(11,11) = 00
>
> Or, another example with bitstrings of length 4:
>
> https://i.imgur.com/bm0DwnT.png
>
> http://easyonlineconverter.com/converters/bitwise-calculator.html

On 12/24/2021 9:29 AM, sobriquet wrote:
> On Friday, December 24, 2021 at 3:55:47 PM UTC+1, Serg io wrote:
>> [..]
>>> XOR:
>>>
>>> xor 00 01 10 11
>>> 00 00 01 10 11
>>> 01 01 00 11 10
>>> 10 10 11 00 01
>>> 11 11 10 01 00
>> why does 4 inputs give you 2 outputs ?
>> [..]
>
> The basic operation maps a combination of two bits to a single bit.
> xor(0,0) = 0
> xor(0,1) = 1
> xor(1,0) = 1
> xor(1,1) = 0
>
> But we can extend the operation to bitstrings of fixed length by consecutively
> applying them to each position in the bitstring (bitwise application).
>
> xor(00,00) = 00
> xor(00,01) = 01
> xor(00,10) = 10
> xor(00,11) = 11
> xor(01,00) = 01
> xor(01,01) = 00
> xor(01,10) = 11
> xor(01,11) = 10
> xor(10,00) = 10
> xor(10,01) = 11
> xor(10,10) = 00
> xor(10,11) = 01
> xor(11,00) = 00
> xor(11,01) = 10
> xor(11,10) = 01
> xor(11,11) = 00

that is non standard notation and not useful, as you still do single bit xor anyway.

single bit for logic gates

the rest are for accumulator size of processor where xor is a operation
8 bite
16 bit,
32 bit
64 bit

the way you wrote it here

>>> xor 00 01 10 11
>>> 00 00 01 10 11
>>> 01 01 00 11 10
>>> 10 10 11 00 01
>>> 11 11 10 01 00

says you give the input 4 bits, and have 2 bits output. (no sequencing of input, nor output)

google Karnaugh map

>
> Or, another example with bitstrings of length 4:
>
> https://i.imgur.com/bm0DwnT.png
>
> http://easyonlineconverter.com/converters/bitwise-calculator.html

On Friday, December 24, 2021 at 5:04:41 PM UTC+1, Serg io wrote:
> On 12/24/2021 9:29 AM, sobriquet wrote:
> > On Friday, December 24, 2021 at 3:55:47 PM UTC+1, Serg io wrote:
> >> [..]
> >>> XOR:
> >>>
> >>> xor 00 01 10 11
> >>> 00 00 01 10 11
> >>> 01 01 00 11 10
> >>> 10 10 11 00 01
> >>> 11 11 10 01 00
> >> why does 4 inputs give you 2 outputs ?
> >> [..]
> >
> > The basic operation maps a combination of two bits to a single bit.
> > xor(0,0) = 0
> > xor(0,1) = 1
> > xor(1,0) = 1
> > xor(1,1) = 0
> >
> > But we can extend the operation to bitstrings of fixed length by consecutively
> > applying them to each position in the bitstring (bitwise application).
> >
> > xor(00,00) = 00
> > xor(00,01) = 01
> > xor(00,10) = 10
> > xor(00,11) = 11
> > xor(01,00) = 01
> > xor(01,01) = 00
> > xor(01,10) = 11
> > xor(01,11) = 10
> > xor(10,00) = 10
> > xor(10,01) = 11
> > xor(10,10) = 00
> > xor(10,11) = 01
> > xor(11,00) = 00
> > xor(11,01) = 10
> > xor(11,10) = 01
> > xor(11,11) = 00
> that is non standard notation and not useful, as you still do single bit xor anyway.

https://en.wikipedia.org/wiki/Bitwise_operation

It's perfectly useful. Your argument is silly, because you might as well claim
that multiplication on integers is not useful because you still do multiplication on
individual decimal digits in the implementation of multiplication of decimal
numbers.

>
> single bit for logic gates
>
> the rest are for accumulator size of processor where xor is a operation
> 8 bite
> 16 bit,
> 32 bit
> 64 bit

That's more or less irrelevant, the concept naturally generalizes to bitstrings
of arbitrary length and in fact, with the convention of dropping preceding zeros,
the bitstrings can also vary in length.

https://i.imgur.com/604ANfr.png

xor(1001,110001) = xor(001001,110001) = 111000

>
> the way you wrote it here
> >>> xor 00 01 10 11
> >>> 00 00 01 10 11
> >>> 01 01 00 11 10
> >>> 10 10 11 00 01
> >>> 11 11 10 01 00
> says you give the input 4 bits, and have 2 bits output. (no sequencing of input, nor output)

It's a table format for a binary operation with the left operand indexed vertically and
the right operand indexed horizontally, so it's simply the xor operation mapping combinations
of two bitstrings of length 2 to a single bitstring of length 2.

https://en.wikipedia.org/wiki/Binary_operation

https://en.wikipedia.org/wiki/Truth_table#Condensed_truth_tables_for_binary_operators

>
> google Karnaugh map
> >
> > Or, another example with bitstrings of length 4:
> >
> > https://i.imgur.com/bm0DwnT.png
> >
> > http://easyonlineconverter.com/converters/bitwise-calculator.html

On Friday, December 24, 2021 at 6:43:26 PM UTC+1, sobriquet wrote:
> On Friday, December 24, 2021 at 5:04:41 PM UTC+1, Serg io wrote:
> > On 12/24/2021 9:29 AM, sobriquet wrote:
> > > On Friday, December 24, 2021 at 3:55:47 PM UTC+1, Serg io wrote:
> > >> [..]
> > >>> XOR:
> > >>>
> > >>> xor 00 01 10 11
> > >>> 00 00 01 10 11
> > >>> 01 01 00 11 10
> > >>> 10 10 11 00 01
> > >>> 11 11 10 01 00
> > >> why does 4 inputs give you 2 outputs ?
> > >> [..]
> > >
> > > The basic operation maps a combination of two bits to a single bit.
> > > xor(0,0) = 0
> > > xor(0,1) = 1
> > > xor(1,0) = 1
> > > xor(1,1) = 0
> > >
> > > But we can extend the operation to bitstrings of fixed length by consecutively
> > > applying them to each position in the bitstring (bitwise application).
> > >
> > > xor(00,00) = 00
> > > xor(00,01) = 01
> > > xor(00,10) = 10
> > > xor(00,11) = 11
> > > xor(01,00) = 01
> > > xor(01,01) = 00
> > > xor(01,10) = 11
> > > xor(01,11) = 10
> > > xor(10,00) = 10
> > > xor(10,01) = 11
> > > xor(10,10) = 00
> > > xor(10,11) = 01
> > > xor(11,00) = 00
> > > xor(11,01) = 10
> > > xor(11,10) = 01
> > > xor(11,11) = 00
> > that is non standard notation and not useful, as you still do single bit xor anyway.
> https://en.wikipedia.org/wiki/Bitwise_operation
>
> It's perfectly useful. Your argument is silly, because you might as well claim
> that multiplication on integers is not useful because you still do multiplication on
> individual decimal digits in the implementation of multiplication of decimal
> numbers.
> >
> > single bit for logic gates
> >
> > the rest are for accumulator size of processor where xor is a operation
> > 8 bite
> > 16 bit,
> > 32 bit
> > 64 bit
> That's more or less irrelevant, the concept naturally generalizes to bitstrings
> of arbitrary length and in fact, with the convention of dropping preceding zeros,
> the bitstrings can also vary in length.
>
> https://i.imgur.com/604ANfr.png
>
> xor(1001,110001) = xor(001001,110001) = 111000
> >
> > the way you wrote it here
> > >>> xor 00 01 10 11
> > >>> 00 00 01 10 11
> > >>> 01 01 00 11 10
> > >>> 10 10 11 00 01
> > >>> 11 11 10 01 00
> > says you give the input 4 bits, and have 2 bits output. (no sequencing of input, nor output)
> It's a table format for a binary operation with the left operand indexed vertically and
> the right operand indexed horizontally, so it's simply the xor operation mapping combinations
> of two bitstrings of length 2 to a single bitstring of length 2.
>
> https://en.wikipedia.org/wiki/Binary_operation
>
> https://en.wikipedia.org/wiki/Truth_table#Condensed_truth_tables_for_binary_operators
> >
> > google Karnaugh map
> > >
> > > Or, another example with bitstrings of length 4:
> > >
> > > https://i.imgur.com/bm0DwnT.png
> > >
> > > http://easyonlineconverter.com/converters/bitwise-calculator.html

https://i.imgur.com/XhUql2a.png

You can use the windows calculator (or any other tool that supports bitwise operations
on bitstrings) to check the entire multiplication table that maps combinations of two bitstrings
of length 4 to a single bitstring of length 4.

That is obviously not a coincidence that they match up perfectly.

On Friday, December 24, 2021 at 1:10:41 PM UTC-5, sobriquet wrote:
> On Friday, December 24, 2021 at 6:43:26 PM UTC+1, sobriquet wrote:
> > On Friday, December 24, 2021 at 5:04:41 PM UTC+1, Serg io wrote:
> > > On 12/24/2021 9:29 AM, sobriquet wrote:
> > > > On Friday, December 24, 2021 at 3:55:47 PM UTC+1, Serg io wrote:
> > > >> [..]
> > > >>> XOR:
> > > >>>
> > > >>> xor 00 01 10 11
> > > >>> 00 00 01 10 11
> > > >>> 01 01 00 11 10
> > > >>> 10 10 11 00 01
> > > >>> 11 11 10 01 00
> > > >> why does 4 inputs give you 2 outputs ?
> > > >> [..]
> > > >
> > > > The basic operation maps a combination of two bits to a single bit.
> > > > xor(0,0) = 0
> > > > xor(0,1) = 1
> > > > xor(1,0) = 1
> > > > xor(1,1) = 0
> > > >
> > > > But we can extend the operation to bitstrings of fixed length by consecutively
> > > > applying them to each position in the bitstring (bitwise application).
> > > >
> > > > xor(00,00) = 00
> > > > xor(00,01) = 01
> > > > xor(00,10) = 10
> > > > xor(00,11) = 11
> > > > xor(01,00) = 01
> > > > xor(01,01) = 00
> > > > xor(01,10) = 11
> > > > xor(01,11) = 10
> > > > xor(10,00) = 10
> > > > xor(10,01) = 11
> > > > xor(10,10) = 00
> > > > xor(10,11) = 01
> > > > xor(11,00) = 00
> > > > xor(11,01) = 10
> > > > xor(11,10) = 01
> > > > xor(11,11) = 00
> > > that is non standard notation and not useful, as you still do single bit xor anyway.
> > https://en.wikipedia.org/wiki/Bitwise_operation
> >
> > It's perfectly useful. Your argument is silly, because you might as well claim
> > that multiplication on integers is not useful because you still do multiplication on
> > individual decimal digits in the implementation of multiplication of decimal
> > numbers.
> > >
> > > single bit for logic gates
> > >
> > > the rest are for accumulator size of processor where xor is a operation
> > > 8 bite
> > > 16 bit,
> > > 32 bit
> > > 64 bit
> > That's more or less irrelevant, the concept naturally generalizes to bitstrings
> > of arbitrary length and in fact, with the convention of dropping preceding zeros,
> > the bitstrings can also vary in length.
> >
> > https://i.imgur.com/604ANfr.png
> >
> > xor(1001,110001) = xor(001001,110001) = 111000
> > >
> > > the way you wrote it here
> > > >>> xor 00 01 10 11
> > > >>> 00 00 01 10 11
> > > >>> 01 01 00 11 10
> > > >>> 10 10 11 00 01
> > > >>> 11 11 10 01 00
> > > says you give the input 4 bits, and have 2 bits output. (no sequencing of input, nor output)
> > It's a table format for a binary operation with the left operand indexed vertically and
> > the right operand indexed horizontally, so it's simply the xor operation mapping combinations
> > of two bitstrings of length 2 to a single bitstring of length 2.
> >
> > https://en.wikipedia.org/wiki/Binary_operation
> >
> > https://en.wikipedia.org/wiki/Truth_table#Condensed_truth_tables_for_binary_operators
> > >
> > > google Karnaugh map
> > > >
> > > > Or, another example with bitstrings of length 4:
> > > >
> > > > https://i.imgur.com/bm0DwnT.png
> > > >
> > > > http://easyonlineconverter.com/converters/bitwise-calculator.html
> https://i.imgur.com/XhUql2a.png
>
> You can use the windows calculator (or any other tool that supports bitwise operations
> on bitstrings) to check the entire multiplication table that maps combinations of two bitstrings
> of length 4 to a single bitstring of length 4.
>
> That is obviously not a coincidence that they match up perfectly.

You study operator theory here through the lens of the group definition; or at least I am trying this.
That some operations are not binary operators; they have n-ary character. This means as well that there is a one-form.
In that the spirit of xor is a matching algorithm its own generality can be established and interpreted at a higher level.
I would think that this allows for :
xor( 1 ) = 1
xor( 0 ) = 1
and this state is as profound as P1 of polysign.
That we could possibly extend to:
xor( 1.23, 1.13 ) = 0
versus
xor( 1.23, 1.13 ) = 1.01
is bizarre and yet straightforward.
As to whether the last answer is a binary code or a base ten value (and presuming the arguments were base ten in the first place) the evaluation is so straightforward as to not even require an understanding of the arguments and their source. This sort of a blindfold judgement is somewhat a concept of interest. These thoughts encompass another frame of the terminology 'identity'. This is the most infantile of judgements. Arguably it is a first intelligence. Without this natural matching evaluator little can be done. Its errancy is as well of interest and should our own fail no doubt it would go beneath conscious awareness, where such assumptions are fully absorbed and our immersion into the study is consciousness itself. Without a matching function the concept of 'study' becomes meaningless. It might as well mean 'to stare blankly'.

As the matching function fruits and branches clearly the translations that ensue, which characterize those branchings, are exactly the structure upon which the being works. A stick is split in two upon a clean branch hole. The pin recovers itself and the holes. All are a match yet their parts are unique. Reinstalling the parts and pivoting yields a set of calipers which now can perform more matching functions. A bit of shaping gets them precise transference: the ability to copy (match) parts. And of course the errancy is of interest. Surprisingly in pine these calipers also can lock immediately thanks to the pitch in the joint. Simply work them a few times, melting the pitch, then settle them upon the object to measure. Let it set and the pitch solidifies in just a few seconds. All this from next to naught. All upon the continuum without ever raising the need of number.

On Saturday, December 25, 2021 at 1:41:54 PM UTC+1, timba...@gmail.com wrote:
> On Friday, December 24, 2021 at 1:10:41 PM UTC-5, sobriquet wrote:
> > On Friday, December 24, 2021 at 6:43:26 PM UTC+1, sobriquet wrote:
> > > On Friday, December 24, 2021 at 5:04:41 PM UTC+1, Serg io wrote:
> > > > On 12/24/2021 9:29 AM, sobriquet wrote:
> > > > > On Friday, December 24, 2021 at 3:55:47 PM UTC+1, Serg io wrote:
> > > > >> [..]
> > > > >>> XOR:
> > > > >>>
> > > > >>> xor 00 01 10 11
> > > > >>> 00 00 01 10 11
> > > > >>> 01 01 00 11 10
> > > > >>> 10 10 11 00 01
> > > > >>> 11 11 10 01 00
> > > > >> why does 4 inputs give you 2 outputs ?
> > > > >> [..]
> > > > >
> > > > > The basic operation maps a combination of two bits to a single bit.
> > > > > xor(0,0) = 0
> > > > > xor(0,1) = 1
> > > > > xor(1,0) = 1
> > > > > xor(1,1) = 0
> > > > >
> > > > > But we can extend the operation to bitstrings of fixed length by consecutively
> > > > > applying them to each position in the bitstring (bitwise application).
> > > > >
> > > > > xor(00,00) = 00
> > > > > xor(00,01) = 01
> > > > > xor(00,10) = 10
> > > > > xor(00,11) = 11
> > > > > xor(01,00) = 01
> > > > > xor(01,01) = 00
> > > > > xor(01,10) = 11
> > > > > xor(01,11) = 10
> > > > > xor(10,00) = 10
> > > > > xor(10,01) = 11
> > > > > xor(10,10) = 00
> > > > > xor(10,11) = 01
> > > > > xor(11,00) = 00
> > > > > xor(11,01) = 10
> > > > > xor(11,10) = 01
> > > > > xor(11,11) = 00
> > > > that is non standard notation and not useful, as you still do single bit xor anyway.
> > > https://en.wikipedia.org/wiki/Bitwise_operation
> > >
> > > It's perfectly useful. Your argument is silly, because you might as well claim
> > > that multiplication on integers is not useful because you still do multiplication on
> > > individual decimal digits in the implementation of multiplication of decimal
> > > numbers.
> > > >
> > > > single bit for logic gates
> > > >
> > > > the rest are for accumulator size of processor where xor is a operation
> > > > 8 bite
> > > > 16 bit,
> > > > 32 bit
> > > > 64 bit
> > > That's more or less irrelevant, the concept naturally generalizes to bitstrings
> > > of arbitrary length and in fact, with the convention of dropping preceding zeros,
> > > the bitstrings can also vary in length.
> > >
> > > https://i.imgur.com/604ANfr.png
> > >
> > > xor(1001,110001) = xor(001001,110001) = 111000
> > > >
> > > > the way you wrote it here
> > > > >>> xor 00 01 10 11
> > > > >>> 00 00 01 10 11
> > > > >>> 01 01 00 11 10
> > > > >>> 10 10 11 00 01
> > > > >>> 11 11 10 01 00
> > > > says you give the input 4 bits, and have 2 bits output. (no sequencing of input, nor output)
> > > It's a table format for a binary operation with the left operand indexed vertically and
> > > the right operand indexed horizontally, so it's simply the xor operation mapping combinations
> > > of two bitstrings of length 2 to a single bitstring of length 2.
> > >
> > > https://en.wikipedia.org/wiki/Binary_operation
> > >
> > > https://en.wikipedia.org/wiki/Truth_table#Condensed_truth_tables_for_binary_operators
> > > >
> > > > google Karnaugh map
> > > > >
> > > > > Or, another example with bitstrings of length 4:
> > > > >
> > > > > https://i.imgur.com/bm0DwnT.png
> > > > >
> > > > > http://easyonlineconverter.com/converters/bitwise-calculator.html
> > https://i.imgur.com/XhUql2a.png
> >
> > You can use the windows calculator (or any other tool that supports bitwise operations
> > on bitstrings) to check the entire multiplication table that maps combinations of two bitstrings
> > of length 4 to a single bitstring of length 4.
> >
> > That is obviously not a coincidence that they match up perfectly.
> You study operator theory here through the lens of the group definition; or at least I am trying this.
> That some operations are not binary operators; they have n-ary character. This means as well that there is a one-form.
> In that the spirit of xor is a matching algorithm its own generality can be established and interpreted at a higher level.
> I would think that this allows for :
> xor( 1 ) = 1
> xor( 0 ) = 1
> and this state is as profound as P1 of polysign.
> That we could possibly extend to:
> xor( 1.23, 1.13 ) = 0
> versus
> xor( 1.23, 1.13 ) = 1.01
> is bizarre and yet straightforward.
> As to whether the last answer is a binary code or a base ten value (and presuming the arguments were base ten in the first place) the evaluation is so straightforward as to not even require an understanding of the arguments and their source. This sort of a blindfold judgement is somewhat a concept of interest. These thoughts encompass another frame of the terminology 'identity'. This is the most infantile of judgements. Arguably it is a first intelligence. Without this natural matching evaluator little can be done. Its errancy is as well of interest and should our own fail no doubt it would go beneath conscious awareness, where such assumptions are fully absorbed and our immersion into the study is consciousness itself. Without a matching function the concept of 'study' becomes meaningless. It might as well mean 'to stare blankly'.
>
> As the matching function fruits and branches clearly the translations that ensue, which characterize those branchings, are exactly the structure upon which the being works. A stick is split in two upon a clean branch hole. The pin recovers itself and the holes. All are a match yet their parts are unique. Reinstalling the parts and pivoting yields a set of calipers which now can perform more matching functions. A bit of shaping gets them precise transference: the ability to copy (match) parts. And of course the errancy is of interest. Surprisingly in pine these calipers also can lock immediately thanks to the pitch in the joint. Simply work them a few times, melting the pitch, then settle them upon the object to measure. Let it set and the pitch solidifies in just a few seconds. All this from next to naught. All upon the continuum without ever raising the need of number.

Ultimately it seems the relationship between permutations and group theory is somewhat
analogous to the relationship between combinations and set theory.
These concepts can also be mixed up, like combinations of permutations or
permutations of combinations.

https://flickr.com/photos/thcganja/49912907817/

They seem like generic conceptual tools that allow for identification and
differentiation in the realm of conceptual structures.
It will be interesting to see what concepts AI systems are able to come up with
from scratch, once they master the skill of processing information to such a level
that we will have an independent source for conceptual structures.
Then we can do some sort of cross-validation with the range of concepts originating
in humanity over the course of history to debug our conceptual framework or identify
important concepts we've been missing or overlooking so far.

On Saturday, December 25, 2021 at 8:02:30 PM UTC-5, sobriquet wrote:
> On Saturday, December 25, 2021 at 1:41:54 PM UTC+1, timba...@gmail.com wrote:
> > On Friday, December 24, 2021 at 1:10:41 PM UTC-5, sobriquet wrote:
> > > On Friday, December 24, 2021 at 6:43:26 PM UTC+1, sobriquet wrote:
> > > > On Friday, December 24, 2021 at 5:04:41 PM UTC+1, Serg io wrote:
> > > > > On 12/24/2021 9:29 AM, sobriquet wrote:
> > > > > > On Friday, December 24, 2021 at 3:55:47 PM UTC+1, Serg io wrote:
> > > > > >> [..]
> > > > > >>> XOR:
> > > > > >>>
> > > > > >>> xor 00 01 10 11
> > > > > >>> 00 00 01 10 11
> > > > > >>> 01 01 00 11 10
> > > > > >>> 10 10 11 00 01
> > > > > >>> 11 11 10 01 00
> > > > > >> why does 4 inputs give you 2 outputs ?
> > > > > >> [..]
> > > > > >
> > > > > > The basic operation maps a combination of two bits to a single bit.
> > > > > > xor(0,0) = 0
> > > > > > xor(0,1) = 1
> > > > > > xor(1,0) = 1
> > > > > > xor(1,1) = 0
> > > > > >
> > > > > > But we can extend the operation to bitstrings of fixed length by consecutively
> > > > > > applying them to each position in the bitstring (bitwise application).
> > > > > >
> > > > > > xor(00,00) = 00
> > > > > > xor(00,01) = 01
> > > > > > xor(00,10) = 10
> > > > > > xor(00,11) = 11
> > > > > > xor(01,00) = 01
> > > > > > xor(01,01) = 00
> > > > > > xor(01,10) = 11
> > > > > > xor(01,11) = 10
> > > > > > xor(10,00) = 10
> > > > > > xor(10,01) = 11
> > > > > > xor(10,10) = 00
> > > > > > xor(10,11) = 01
> > > > > > xor(11,00) = 00
> > > > > > xor(11,01) = 10
> > > > > > xor(11,10) = 01
> > > > > > xor(11,11) = 00
> > > > > that is non standard notation and not useful, as you still do single bit xor anyway.
> > > > https://en.wikipedia.org/wiki/Bitwise_operation
> > > >
> > > > It's perfectly useful. Your argument is silly, because you might as well claim
> > > > that multiplication on integers is not useful because you still do multiplication on
> > > > individual decimal digits in the implementation of multiplication of decimal
> > > > numbers.
> > > > >
> > > > > single bit for logic gates
> > > > >
> > > > > the rest are for accumulator size of processor where xor is a operation
> > > > > 8 bite
> > > > > 16 bit,
> > > > > 32 bit
> > > > > 64 bit
> > > > That's more or less irrelevant, the concept naturally generalizes to bitstrings
> > > > of arbitrary length and in fact, with the convention of dropping preceding zeros,
> > > > the bitstrings can also vary in length.
> > > >
> > > > https://i.imgur.com/604ANfr.png
> > > >
> > > > xor(1001,110001) = xor(001001,110001) = 111000
> > > > >
> > > > > the way you wrote it here
> > > > > >>> xor 00 01 10 11
> > > > > >>> 00 00 01 10 11
> > > > > >>> 01 01 00 11 10
> > > > > >>> 10 10 11 00 01
> > > > > >>> 11 11 10 01 00
> > > > > says you give the input 4 bits, and have 2 bits output. (no sequencing of input, nor output)
> > > > It's a table format for a binary operation with the left operand indexed vertically and
> > > > the right operand indexed horizontally, so it's simply the xor operation mapping combinations
> > > > of two bitstrings of length 2 to a single bitstring of length 2.
> > > >
> > > > https://en.wikipedia.org/wiki/Binary_operation
> > > >
> > > > https://en.wikipedia.org/wiki/Truth_table#Condensed_truth_tables_for_binary_operators
> > > > >
> > > > > google Karnaugh map
> > > > > >
> > > > > > Or, another example with bitstrings of length 4:
> > > > > >
> > > > > > https://i.imgur.com/bm0DwnT.png
> > > > > >
> > > > > > http://easyonlineconverter.com/converters/bitwise-calculator.html
> > > https://i.imgur.com/XhUql2a.png
> > >
> > > You can use the windows calculator (or any other tool that supports bitwise operations
> > > on bitstrings) to check the entire multiplication table that maps combinations of two bitstrings
> > > of length 4 to a single bitstring of length 4.
> > >
> > > That is obviously not a coincidence that they match up perfectly.
> > You study operator theory here through the lens of the group definition; or at least I am trying this.
> > That some operations are not binary operators; they have n-ary character. This means as well that there is a one-form.
> > In that the spirit of xor is a matching algorithm its own generality can be established and interpreted at a higher level.
> > I would think that this allows for :
> > xor( 1 ) = 1
> > xor( 0 ) = 1
> > and this state is as profound as P1 of polysign.
> > That we could possibly extend to:
> > xor( 1.23, 1.13 ) = 0
> > versus
> > xor( 1.23, 1.13 ) = 1.01
> > is bizarre and yet straightforward.
> > As to whether the last answer is a binary code or a base ten value (and presuming the arguments were base ten in the first place) the evaluation is so straightforward as to not even require an understanding of the arguments and their source. This sort of a blindfold judgement is somewhat a concept of interest. These thoughts encompass another frame of the terminology 'identity'. This is the most infantile of judgements. Arguably it is a first intelligence. Without this natural matching evaluator little can be done. Its errancy is as well of interest and should our own fail no doubt it would go beneath conscious awareness, where such assumptions are fully absorbed and our immersion into the study is consciousness itself. Without a matching function the concept of 'study' becomes meaningless. It might as well mean 'to stare blankly'.
> >
> > As the matching function fruits and branches clearly the translations that ensue, which characterize those branchings, are exactly the structure upon which the being works. A stick is split in two upon a clean branch hole.. The pin recovers itself and the holes. All are a match yet their parts are unique. Reinstalling the parts and pivoting yields a set of calipers which now can perform more matching functions. A bit of shaping gets them precise transference: the ability to copy (match) parts. And of course the errancy is of interest. Surprisingly in pine these calipers also can lock immediately thanks to the pitch in the joint. Simply work them a few times, melting the pitch, then settle them upon the object to measure. Let it set and the pitch solidifies in just a few seconds. All this from next to naught. All upon the continuum without ever raising the need of number.
> Ultimately it seems the relationship between permutations and group theory is somewhat
> analogous to the relationship between combinations and set theory.
> These concepts can also be mixed up, like combinations of permutations or
> permutations of combinations.
>
> https://flickr.com/photos/thcganja/49912907817/
>
> They seem like generic conceptual tools that allow for identification and
> differentiation in the realm of conceptual structures.
> It will be interesting to see what concepts AI systems are able to come up with
> from scratch, once they master the skill of processing information to such a level
> that we will have an independent source for conceptual structures.
> Then we can do some sort of cross-validation with the range of concepts originating
> in humanity over the course of history to debug our conceptual framework or identify
> important concepts we've been missing or overlooking so far.

In that the continuum that we observe as space is three dimensional and that mathematicians insist on a one dimensional constructor arbitrarily tripled it is considered appropriate theory to simply pull rabbits out of a hat.

That these continuum concepts apply as well onto the objects in space: here is a crux I think that gets further swamped in layers like topology. Meanwhile the physicists happily build out quantum theory with things like
Lx,Ly,Lz
as if these creatures were native in plurality. This to me is the strangest of disconnects. Somehow they all go on down that chute together. Thereabouts I'll go another way.