Re: More on trits & tetrits... (long)
Hi Dan,
Well done!
It is officially no-longer half-baked.
So now let me raise a few observations about the nicely-cooked version:
Dan Zuras Intervals wrote:
For the decoration named 'domain' (or defined or valid, I don't
really care) we want to set 2 bits in the following way:
domainFalse = {There exists x in xx such that x is not
in the domain of f()}
domainTrue = {There exists x in xx such that x is in the
domain of f()}
...
sqrt([empty]) = {[empty],{}}
The result is decorated with {} (the empty set)
because there exist no points of any flavor at
all in the operand.
This last is the cheap way to find empty intervals.
Let's look at another example, e.g.,
[1,1]/[0,0] = {[empty], {definedFalse}}.
It seems in this case, testing the tetrit for {} will give the misleading
impression that the interval is not empty. So I don't think we should count
on this approach as a method to test for empty intervals.
But...
xx <<== yy implies that
decoration(xx) <<== decoration(yy)
In particular, since [empty] <<== xx <<== [entire] we must have
decoration([empty]) <<== decoration(xx) <<== decoration([entire])
for all intervals xx & for all decorations.
The only assignment of a decoration for [empty] (the empty
interval) that meets that requirement is {} (the empty set),
for all decorations.
Suppose we are given
xx = {[0,0], {definedTrue}},
yy = {[-1,1], {definedTrue}},
zz = {[3,5], {definedTrue}}, and
ff(aa) = sqrt(1/aa).
We have xx \subseteq yy, and
ff(xx) = sqrt( 1/{[0,0], {definedTrue}} )
= sqrt( {[empty], {definedFalse}} )
= {[empty], {definedFalse}}
ff(yy) = sqrt( 1/{[-1,1], {definedTrue}} )
= sqrt( {[entire], {definedFalse, definedTrue}} )
= {[0,+Inf], {definedFalse, definedTrue}}.
Now, decoration(ff(xx)) \subseteq decoration(ff(yy)) holds, even though the
decoration for [empty] in f(xx) was not {}. So I don't believe its correct
to say "the only assignment of a decoration for [empty] (the empty interval)
that meets that requirement is {} (the empty set)".
I think for all these reasons, the tetrit {} might effectively just be an
alias for {definedFalse}.
HOWEVER:
What's interesting is to compare and contrast with the "gathering of
assertions" method. In that case,
sqrt( {[empty], {definedTrue}} ) = {[empty], {definedTrue}}.
And your "two bits" approach gives
sqrt( {[empty], {definedTrue}} ) = {[empty], {}}.
What will be the consequences of these two results in various types of
lengthy computations? That is the interesting question.
In the example of ff, it appears it doesn't really make a difference, e.g.,
decoration(ff(xx)) \subseteq decoration(ff(yy)) holds. In fact, "gathering
of assertions" method returns the same intervals and decorations as "two
bits" approach. This is because the decoration of [empty] is {definedFalse}
when input to the sqrt function in ff.
At some point, it seems there _has_ to be an example where "gathering of
assertions" will produce a different result than "two bits". But I'm rather
suprised to find how difficult its.
I'd encourage everyone to think about finding such examples. It will prove
to be a helpful study.
Nate