>To take your example of sqrt(xx),

Yes, for small floats posits do ok, but they fail for other sizes. For example, here's float32 vs posit32 for 100,000 random values in ranges 1e2,1e4,..,1e18.

Posit32 fails on (respectively) 21%, 71%, 91%, 97%, 99%, 99.9%, 99.97%, 99.99% of the cases. Float32 fails on 0 of them. Julia code at the bottom.

Posit even fails on simple integer multiplication so often that you'd be terribly pressed to know ahead of time when it happens. For example, take integers 1 to 40 for i and j, multiple as posit16 and as float16, an see how they do. Posit fails 1.75% of the values, float fails none.

This is simple multiplication of numbers well within range. The same problem happens in posit32,64,anysize, but not for the same sized floats.

>These are The two most important parts of what equality means.

As a PhD in math, this is not what equality means. You'll find nothing like that here for example https://en.wikipedia.org/wiki/Equality_(mathematics)

And if you're worried about equality, you might notice that in posit16, 2739 gives 1052 instead of 1053, which is real (in)equality. You worry so much about made up concerns that you miss the crazy bad results scattered throughout posits.

Posits of all sizes make errors when multiplying by powers of two that floats do not make (die to their inability to keep digits). For example, in posit8, 2.01.03125 returns 2.0, 102 returns 16, and examples this bad can be found for any size posit.

To see this, take 1e6 random values in 0-100, mult by 2, then divide by 2, and see how many made it round trip. All float16 values do. 4% of posit16 values do not round trip. These are small numbers - the entire computation stays in the range 0-200, and this is even the base of the underlying number. Posit32 has the same failure rate for the same reason: posits lose precision even under small multiplications.

As a result, posits fail at x-y=0 means x=y, which is also pretty fundamental, is it not?

Want to compute a discriminant sqrt(bb-4ac)? Good luck, nearby values for a,b,c don't give smooth results, and routinely give imaginary numbers when they should be real (due to the above screwiness around powers of 2).

There's so many failure cases, not even at the edge of the ranges, where posits fail and equivalent sized floats don't, that doing any simple computations is error prone.

Here's the Julia code for the sqrt failures. You can do similar error checks for a ton of computations and you'll find posits failing a significant amount of them.

# count failures of float32 and Posit32 in Julia
# for sqrt(x*x) ==?= x
using Random

Random.seed!(1234) # make reproducible

scale = 1.0f0 # try exponent 4,6,8,10,etc
for s in 1:9 # powers 2,4,5,8,10,...18
scale *= 100.0f0

badF,goodF = 0,0
badP,goodP = 0,0
for i in 1:10000
f = rand()*scale

f1::Float32 = f
f2 = f1*f1
f3 = sqrt(f2)

@assert typeof(f1) == Float32
@assert typeof(f2) == Float32
@assert typeof(f3) == Float32

p1 = Posit32(f)
p2 = p1*p1
p3 = sqrt(p2)

@assert typeof(p1) == Posit32
@assert typeof(p2) == Posit32
@assert typeof(p3) == Posit32

if f1 != f3
badF+=1
else
goodF+=1
end

if p1 != p3
badP+=1
else
goodP+=1
end
end

println("Scaling: $(scale)")
println("float: $(goodF) good, $(badF) bad, $(100*badF/(goodF+badF)) % failed")
println("posit: $(goodP) good, $(badP) bad, $(100*badP/(goodP+badP)) % failed")