Representing SHA-256 Hashes as Avatars
francoisbest.com
francoisbest.com
It follows that, since avatars do not provide any proof of identity, there is actually no harm in greatly truncating the hash space when generating them! That is, rather than trying to encode all 256 bits into the avatar, you can use a much more manageable number, like 16. But isn't this too small? Won't there be lots of collisions? Yes -- but that's a feature! If collisions are common, then the average user will be aware that avatar != identity, which makes them less susceptible to scamming. But 16 bits is still enough to meet the real goal of avatars: quickly distinguishing between different people in a conversation (or transaction, or whatever).
(This also shows why making avatars more costly to generate, e.g. with scrypt, can do more harm than good: doing so makes collisions less likely, but still not impossible. Meaning that if a collision does occur, whether accidental or malicious, you are less likely to notice it.)
That sounds intriguing to me. Are you aware of any research into this?
I suppose it's a somewhat nuanced question, though. For example, if I were shown every avatar in sequence, I'm quite sure I would always notice the "diff" between two consecutive avatars. But the bar that I have in mind is much, much higher: given a sequence of avatars, can I recognize my friend's avatar with 100% accuracy? Given that we can't even do this within the set of <8 billion human faces (we occasionally accost a stranger as though they were a friend), I have to conclude that doing so within a set of 2^256 abstract shapes is entirely hopeless.
echo "hello" | sha256sum
>> 5891b5b522d5df086d0ff0b110fbd9d21bb4fc7163af34d08286a2e846f6be03
echo "world" | sha256sum
>> e258d248fda94c63753607f7c4494ee0fcbe92f1a76bfdac795c9d84101eb317
But were I to briefly glance at a computer screen, I'd probably confuse these next two:
e258d248fda94c63753607f7c4494ee0fcbe92f1a76bfdac795c9d84101eb317
e258d248fda94c63753607f7c4494ee0fcbe92f1a76bfaac795c9d84101eb317
Your example of the fact that we can't reliably recognize every face on this planet is very interesting. Let's imagine we know n faces which I can reliably distinguish from one another, but now there is a (n+1)th face which I mix up with one of the previous ones. Now lets assume this face would instead have a very unique characteristic, unlike all previous faces - lets imagine for example, the nose on this face is upside down. Surely I'd be able to differentiate it from the previous n faces, hence the issue of identifying it might've been the limited variability/characteristics in the various previous instantiations of a face.
So there are a number of characteristics in a face, which have a certain degree of variability, which enable us to distinguish from a number of them. I've been pondering on how many of those characteristics could be combined in an object, and how high the variability could be; to create uniquely identifiable patterns. It probably depends a lot on the meaning we attribute to the pattern, different associations we have to it.
I apologize - quite the tangent, I guess. I've just been pondering a lot on this for a project I've been working on for some time.
Practically speaking, though, this isn't something that the average person is capable of doing. Even memorizing one hex string, let alone multiple (for each of your friends), requires a lot of effort for little benefit.
Furthermore -- if you can memorize the hex directly, you don't need the avatars in the first place! :P
One billion is really really tiny though, let's just play a game :
- Unless you're colorblind, you can easily tell ten hues apart. Let's pick two colors, one with a saturated hue, and the other with a pastel one. That's 100 possibilities.
- I'm pretty sure you can easily recognize pictures of a hundred people you've met at some point in your life. Let's pick two of them, that's 10 thousand combinations.
- can you recognize ten different road signs? Ten country shapes ? Ten animals ? Ten fictional character? Ten books cover? Ten celebrities? Just pick three categories, and you've got a thousand combinations.
Now I'm pretty sure you can tell your grandma sitting under a vivid pink UK shape next to your 9th grade math teacher staring at Bruce Willis holding a giant light blue stop sign apart from any other imaginable combinations.
An untrained[1] human brain probably cannot distinguish between 2^256 items, but it's still able to do it for massive numbers.
[1]: but maybe it's possible with training: for instance, chess professionals might be able to do it.
I assumed there would be existing implementations of something similar but have not found one that fits criteria other than some that use very small word lists. Diceware has 7776 words and pushing that to 8192 should be feasible and is a bit easier to work with.
See for BIP-39, wordlists under a folder https://github.com/bitcoin/bips/blob/master/bip-0039.mediawi...
https://github.com/luke-clifton/memorable-bits
(Also on hackage [0] but readme is missing)
It let's you define a pattern for generating "sentences" from data.
It deals with padding, lets you join word lists, or use multiple word lists in a single pattern.
Word lists can be any power of 2 long, and the library comes with a few different word lists.
I guess my broader point here (which I neglected to mention in the OP) is that we already have an excellent means of verifying identities: cryptographic signatures. Avatars are fine, but our interfaces need to make it clear that an avatar is just a costume, not a fingerprint. The Hard Problem, as we all know, is tying real-world people (and objects) to virtual-world pubkeys. If we can manage that, the rest is moot.
In any case, there are a lot of variations on this "visual hash" idea, including the original fractal one, and I heard of more recent work to use the hash to seed StyleGAN face generation.
The "Hello, Hacker News!" Hash's middle ring has half it's ring that looks identical to me, and unless I looked carefully, that entire ring looked the same to me.
You could apply repeating surface textures inside each slice, rather than showing a solid color, so that Hue 1 shows repeating dots, Hue 2 shows repeating lines, Hue 3 shows repeating triangles.
You could use a Braille-like 2x2 grid to represent the 4-bit Hue space as circles and lines within each slice.
If you imagine that each slice has 4 walls, replacing the missing fourth wall of the innermost slices with the innermost corner, then you could map the binary representation of 2^4 hue (such as 0110) onto "bites" out of the walls. For example, given 0110, map the 0s onto "bites" and punch a small hole into two adjacent walls of the slice; given 0000, punch a small hole into all four walls.
ASCII art of what I mean by "punch a hole into the wall", for Hue 0111 (one zero, so one hole punched). This is an uncurved slice, because ASCII art.
____________
| |
| __ |
|____/ \____|The key is to find a solution that looks good enough when zoomed out to ~64px square, which is tricky for details, especially in the inner ring where sections are packed so close from one another.
1) One confuses two types of colors as the same one (e.g. red-green, blue-yellow, etc. colorblind) or
2) Colors that are close together appear to be the identical (Like the case that I saw, half of the row looked exactly the same to me, the the entire row looked the same until I looked close).
Perhaps a mix of shapes and colors would make it more obvious? Or constrasting the border colors too to hightlight closer difference (like if you have "f8" and "f0", which has a hamming distance of 1, you make the boarder somehow highlight the differences.
Don't get me wrong, I think it is a neat idea! I just want you to be aware.
> Are the color-blindness simulators in Firefox devtools good enough to reproduce your experience?
I have honestly not used them, sorry.... (I don't make GUIs).
I am looking at the docuymentation, and I am a bit disappointed though. By far the most common issue is contrast loss like they say: https://developer.mozilla.org/en-US/docs/Tools/Accessibility...
The condition to not see one color completely is incredibly rare, and not seeing any colors even more so. By in large the issue is constrast loss.
Normally when discussing being color-blind sensitive we're discussing not embedding 2 or 3 bits of information into colors that can't be distinguished by those who are color blind, but in this case, we're trying to jam massively more bits than anyone can handle into an image, so it's not clear that much is called for other than tweaking where the bits get lost a bit.
Or, to put it another way, relative to the desired goal, we're all already massively "colorblind". Those who are what we humans would call colorblind are, in relative terms, hardly at a disadvantage at all for once, because we're all so many orders of magnitude short of the mark.
It hashes the user's email http://en.gravatar.com/site/implement/hash/ and creates an "identicon" from the hash http://scott.sherrillmix.com/blog/blogger/wp_identicon/ or loads a user-defined image.
Urbit names are just another representation of a 32-bit number, like the sigils. You can use any 32-bit number as the "seed" for a sigil.
https://exascale.info/assets/pdf/students/MSc_Thesis_-_Micha...
Since it doesn't seem to be lossy, I was wondering if it could be somehow adapted to something that could be scanned as a QR code. I guess the minor color shifts might be hard to get right, but maybe combined/replaced with some form of symbol inside rings to help, a dot/dash combination?
1. Creating at least some default avatar. Not to be used to verify identity but just somewhat better than having a very limited set of default images. Having rate limits on account creation would prevent most brute force methods. 2. Avatar suitable for partial-identification for very small populations. Imagine a matrix/Element room that as <100,000 people. The hash/math could be modified to drastically trim down the space of the hash (e.g. 2^256) to something similar to the size of the room.
#2 sounds pretty interesting. It could be expanded by making parts of the image/avatar dependent on some other input other than the user ID like the user's role in the chat group. Another segment/ring could something more short lived and relative like just identifying users in recent chat messages.
The rings are neat, but I found many to be too similar based on color alone, and segments too are really hard pick up on a pattern or something memorable
That would obviously not make it suitable for generating avatars to identify humans, but it would make this really useful to eg identify git commits or hash signatures.
The idea is explored a bit in Peter Watts novel Blindsight - not for hashes, but visualizing high dimensional multivariate data via clouds of tormented faces :)
Why not convert a hash to a correct horse battery staple? https://xkcd.com/936/