How does my boolean HashSet from a span have 3 values?

I vaguely understand this, but I would like a concrete explanation as to what's happening. If I construct a HashSet<bool> with data originally from a byte array, why exactly does it keep duplicate values? I've tried to debug this but once I have a bool array, all the elements appear like standard bools.

.Net Fiddle: https://dotnetfiddle.net/QOll01

byte[] bytes = new byte[] { 0, 1, 2 };
ReadOnlySpan<byte> span = new(bytes);
ReadOnlySpan<bool> boolSpan = MemoryMarshal.Cast<byte, bool>(span);
bool[] bools = boolSpan.ToArray();

Console.WriteLine(string.Join(", ", bools)); // False, True, True

Console.WriteLine(new HashSet<bool>(bools).Count); // 3??
Console.WriteLine(string.Join(", ", new HashSet<bool>(bools))); // False, True, True

My guess would be that the memory for a bool can actually be populated with any data. If you set it explicitly then it is probably populated with all 0s or all 1s but it can actually be populated with anything and any value that is not zero is interpreted as true. Because you are creating your values from numbers, the two true values actually do contain different numbers in memory so, while they are the same when interpreted as bool values, they are actually being compared as numbers under the hood and are thus not equal.

To test, I changed this:

byte[] bytes = new byte[] { 0, 1, 2 };

to this:

byte[] bytes = new byte[] { 0, 1, 2, 1, 2 };

and the output was this:
<pre>
False, True, True, True, True
3
False, True, True
</pre>
That appears to support the theory.

bools are represented by 8 bits, but only 0 and 1 are emitted/expected by C#'s compiler. You've introduced 2 as a boolean. Since C# is expecting either 0 or 1, the Equals(object) method on the boolean returns an incorrect value.

EqualityComparer<bool>.Default.Equals((unsafebool)1, (unsafebool)2); // False; visually: true != true

So you get 3 values in your HashSet.

> ## Representation of Boolean Values
> The C# and VB compilers represent true (True) and false (False) bool (Boolean) values with the single byte values 1 and 0, respectively, and assume that any boolean values that they are working with are restricted to being represented by these two underlying values. The ECMA 335 CLI specification permits a "true" boolean value to be represented by any nonzero value. If you use boolean values that have an underlying representation other than 0 or 1, you can get unexpected results. This can occur in unsafe code in C#, or by interoperating with a language that permits other values. To avoid these unexpected results, it is the programmer's responsibility to normalize such incoming values.
>
>
> See also https://github.com/dotnet/roslyn/issues/24652

https://github.com/dotnet/roslyn/blob/main/docs/compilers/Boolean%20Representation.md

> A CLI Boolean type occupies 1 byte in memory. A bit pattern of all zeroes denotes a value of
false. A bit pattern with any one or more bits set (analogous to a non-zero integer) denotes a
value of true. For the purpose of stack operations boolean values are treated as unsigned 1-byte integers

ECMA 335 specification (§III.1.1.2) p. 293