So..
Perhaps instead of simply adding up all the RDC's - aiming for them to add to zero (which works perfectly for correct distances) - I was thinking of relaxing this:
Instead of adding up the RDCs - I would instead count how many refs give a zero error.
If that count is 5 or more (what we have more or less established to be the minimum refs needed to pin down the coords for sure) I'll let it pass - Even if one or more RDC's in fact don't give zero.
This would allow for any number of "bad distances" as long as there's at least five good ones.
Thoughts?
I think the problem with that is that there could be multiple coordinates that have 5 good distances and 1 bad one, but a different "bad" one..
So, the way I'm thinking about it is that we currently have a method to detect the level of "redundancy" in the data, which I had described before. Basically, to ensure n+1 redundancy for some set of distances (i.e. enough redundancy to detect 1 bad distance), you remove each distance in turn and recalculate the coordinate, and ensure that you are still able to get the same single valid coord with each reduced set of distances. Or for n+2, you would need to iterate over the combinations of subsets of length - 2, etc.
So, using that redundancy measure, we can have a measurable level of confidence in some set of distances.
So, let's say that our goal is to achieve n+1 redundancy before deciding a coordinate is definitely valid. Now, let's say we have some set of distances such that there is no valid coordinate. So, the goal is to find a subset of the distances that have n+1 redundancy.
So something like
Code:
(pseudocode)
for i in 0 to distances.length:
new_distances = copy(distances).remove(i)
is_redundant = true
coord = null
for j in 0 to new_distances.length:
test_distances = copy(new_distances).remove(j)
test_coord = find_coord(test_distances)
if test_coord is null: // no valid coordinate for this set of distances
is_redundant = false
else if coord = null:
coord = test_coord
else if test_coord != coord:
is_redundant = false
if is_redundant:
print "distance " + i + " is bad"
At the end, if it wasn't able to determine which distance was bad, then there are 2 possibilities:
1. There isn't enough redundancy in the data to detect the bad distance and still have n+1 redundancy after removing the bad distance
2. There are multiple bad distances
The solution for #1 would be to get more distances and rerun the same algorithm.
The solution for #2 would be to run an extended version of the algorithm that iterates over the combinations of subsets of length n-2 (or n-3 for 3 bad distances, etc.) - which might also require more distances.
As a general rule, I think n+1 redundancy should be required before presenting a coordinate for a star, and n+2 (or higher) should be required for verification of that coordinate.
)