= 27d567bc2d48d9f40e9ccc20ea370b15)
anotherblackhat comments on [SEQ RERUN] Nonperson Predicates - Less Wrong
You are viewing a comment permalink. View the original post to see all comments and the full post content.
= 783df68a0f980790206b9ea87794c5b6)
Loading…= b715d02e85f7b3b4ae65ca3d3e450868)
Subscribe to RSS Feed
Powered by Reddit
= f037147d6e6c911a85753b9abdedda8d)
You are viewing a comment permalink. View the original post to see all comments and the full post content.
Comments (7)
Consider the intuitively simpler problem of "is something a universal turing machine?" Consider further this list of things that are capable of being a universal turing machine;
Even a sufficiently complex shopping list might qualify. And it's even worse, because knowing that A doesn't have personhood, and that B doesn't have personhood doesn't let us conclude that A+B doesn't have personhood. A single Transistor isn't a computer, but 3510 transistors might be a 6502. If we want to be 100% safe, we have to rule out anything we can't analyze, which means we pretty much have to rule out everything. We might as well make the function always return 1.
OK, as bad as that sounds, it just means we shouldn't work too hard on solving the problem perfectly, because we know we'll never be able to do so in a meaningful way. But perhaps we can solve the problem imperfectly. Spam assassin faces a very similar kind of problem, "how can we tell if a message is spam?" The technique it uses is conceptually simple; Pick a test that some messages pass and some fail. Use the test on a corpus of messages classified as spam and a corpus classified as non-spam, and use the results to assign a probability that a message is spam if it passes the test. In addition to the obvious advantage of "I can see how to do that for a non-person predicate test", such a test could also give a score for "has some person-like properties". Thus we can meaningfully approach the problem of A + B being a person even though A and B aren't by themselves.
What kind of tests can we run? Beats me, but presumably we'll have something before we can make an AI by design.
One problem with this approach is it could be wrong. It might even be very wrong. Also, training the predicate function might be an evil process - that is, training may involve purposely creating things that pass.
Nitpick: strictly speaking, a computer is not a universal Turing machine because it has a finite amount of memory and is therefore a finite state machine (and in particular can therefore only run finitely many programs). When we say that computers are universal Turing machines we are talking about an idealized version of a computer that acquires more memory as necessary.
Regarding the problem of determining whether a Turing machine is universal, this is undecidable by Rice's theorem, which asserts more generally that any nontrivial property (in the sense that at least one Turing machine has it and at least one Turing machine doesn't have it) of Turing machines is undecidable. The best you can do is an algorithm which returns "is a UTM" on some Turing machines, returns "is not a UTM" on others, or doesn't halt (or outputs "unknown"). For example, it might search through proofs that a given Turing machine is or is not universal (possibly up to some upper bound).
Yes, that was sort of the point - you can't make a function for "is a Turing machine" that works in all cases, and you can't make a "is a non-person" function that works in all case either. Further, the set of things you can rule out with 100% certainty is to small to be useful.
Don't see how that relates to my suggestion of a probabilistic answer though. Has anyone proven that you can't make a statistically valid statement about the "Is a Turing machine" question?
The problem with training isn't purposely creating things that pass. It's purposely creating things that don't. In order to figure out what doesn't pass, we need a predicate function. Once we've figured out how to find things that won't pass, we've already found the answer.
Doesn't follow. Consider;
I accept that in order to classify something, we need to be able to classify it.
I'm suggesting there might be a function that classifies some things incorrectly, and is still useful.
Depending on what you mean by "capable", I'd add "a bunch of silicon and germanium atoms" to the list.