Yep, the problem IMHO for the ones looking at philosophical answers is that their position (at least in this thread) depends on just looking at what it amounts to be a sophisticated straw man (it does make a point, but it is not the only thing CTMs look at nor a show stopper), as I look at what scientists are doing nowadays is more complex than just looking at a simple circuit and call it a day.
Looks a lot like the words an audience member made when after Faraday showed his early work on magnetism and electricity:
So it is similarly with the issue here, what people like Searle did was to state the obvious limitation of past table experiments, but to me is like the limitations a new born baby has and the philosophers of this issue seem to be happy to ponder on those early limitations and call it a day too.
An interesting point is that few of those actually agree on why the argument is false. As Einstein supposedly said about the book ‘100 Authors against Einstein’: “If I were wrong, one would have sufficed.”
Regardless, I do actually believe that Searle’s argument doesn’t establish its intended conclusion. But the argument I’m proposing is different. It’s rather analogous to Searle’s ‘wall’-argument, and argues for the position that’s sometimes called ‘interpretivist pancomputationalism’, which is not a conclusion of the Chinese Room.
Let’s try and get at this another way. Take the two words ‘dog’ and ‘Hund’. They’re different symbols; yet, there is something that’s the same about them, namely, what they denote—one is the general name for various canines in English, the other in German. So, there is some level beyond the merely symbolic (or syntactic), and that level is what we’re talking about here.
Take now the word ‘gift’. In German, it means ‘poison’, while in English, it means ‘present’. Hence, the same symbol may be interpreted in different ways: the symbol itself does not fix its interpretation. Nevertheless, I can interpret it in a definite way: thus, my mind does something—whatever it may be—to map a symbol to its meaning. This is a capacity any computational theory must be able to replicate.
Now, take the symbols ‘1 + 2 = 3’, and ‘I + II = III’. I suppose you’ll grant that both, using a standard interpretation, have the same meaning. What they mean is the operation of addition; that is, there’s something that goes beyond the symbols, which we generally denote as ‘addition’. If we want to say that a system computes that particular function, that it performs addition, then it must stand in some appropriate relation to that which is equivalent between ‘1 + 2 = 3’ and ‘I + II = III’. Hence, we need some way of associating symbols with the abstract object that’s connected to ‘1 + 2 = 3’ in the right way.
And once more, human minds can associate symbols in the right way. That’s demonstrated by our ability to recognize both ‘1 + 2 = 3’ and ‘I + II = III’ as meaning the same thing. Hence, the mere manipulation of the symbols can’t suffice to equal the human mind’s capacities in this way; it’s not about producing the symbol ‘3’ as a response, but about computing the number 3. These are different things—they must be, otherwise, ‘3’ and ‘III’ would be just entirely distinct things. The number 3 is then what’s the same between the numerals ‘3’ and ‘III’, and it’s that what we’re interested in.
So now, I think, it becomes clear why your proposed implementation of computing the function f fails: it produces merely the symbols. But, as with the word ‘gift’, these symbols don’t fix their interpretation. Hence, the mind has a capability of fixing interpretations—which is, once again, not something I stipulate, but something that is demonstrated by the fact that we can recognize ‘3’ and ‘III’ as meaning the same thing—and that capability must be demonstrated in a computational system to make computationalism into a plausible theory of the mind.
I think it’s then also clear how the argument I propose differs from the Chinese Room. The Chinese Room is (in my opinion) vulnerable to the systems reply: that the man in the room can’t understand Chinese is not sufficient to demonstrate that the act of following rules and manipulating symbols doesn’t suffice for the understanding of Chinese, since the system itself might understand Chinese (Searle’s counter of this, that one might just ‘internalize’ the room, doesn’t work, either: one can just hold that this would essentially simulate a ‘virtual person’, whose knowledge and understanding may be completely opaque to Searle even as his mind is simulating them).
My argument, on the other hand, applies directly at the level of the complete system. I consider its total input-output capabilities, and show that these don’t suffice to pin down the semantics of the system. The systems-reply thus doesn’t threaten this argument. As the two arguments are thus different, the counter you cite is also not relevant. In particular, I don’t appeal to the conceptual truth discussed in the snippet you posted, but merely on demonstrable capabilities of human minds—their ability to interpret symbols.
No. The salient bit is that whether or not I know the answer isn’t relevant to whether or not I can critique your proposed solution. And of course, the basic answer is quite clear: since the regress only occurs for a computational system, the mind avoids it by not being computational.
Maybe, but of course, that doesn’t mean they were successful in doing so. You proposed that it follows from Watson’s Jeopardy-playing competence that Watson successfully understands the semantics of natural language. However, that is simply false: the lookup-Watson has no claim at all to understanding the semantics of natural language, and can replicate that competence. If you have another argument to the effect that Watson can understand semantics, you haven’t presented it so far.
Sure, but just stipulating that semantics is captured in terms of functional identity is begging the question, since that’s what’s under discussion.
No. He says that there are examples of the two notions diverging, which (according to him) simply don’t occur in our universe. So while they may be (if that’s right) nomologically equivalent, they’re not logically equivalent.
Uh, yes? After all, that’s the regress. The two formulae imply that you need A to have B, but also, you need B to have A. Imagine, for a second, that it would actually be a temporal relation: then, you’d have that A occurs before B, and B occurs before A, which is a contradiction.
See the above.
But still, it’s a dependence relation. The computation depends on the interpretation; if the computation then is supposed to yield the interpretation, then the interpretation depends on the computation. In other words, you don’t have a computation without an interpretation, and you don’t have an interpretation without the computation.
These are just synonyms, though. The bulb glowing is the bulb being lit; the bulb glowing does not depend on the bulb being lit. The interpretation, however, is a prerequisite to there being a computation. The interpretation generates, creates, or causes the computation; it is responsible for there to be a computation. Hence, there must first (‘first’ here not meaning ‘temporally prior’) be an interpretation, in order for there to be a computation.
The connection is rather the same as between heat and fire: heat can cause something to burst into flame, and a fire causes heat. But the fire can’t cause the heat that causes itself.
No. The relationship between the two is such that a system computes because it is interpreted as computing—again directly showing the logical priority. Without interpretation, no computation. This is born out by the fact that if I use different interpretations of my box, I can use the box to implement different computations.
A computational device is anything that implements a computation. This is something that a computationalist claims is uniquely possible, and I claim is a matter of interpretation; that doesn’t mean, however, that the notion is in any way vague. If I use a device to compute the sum of two numbers, or whatever else, the device is a computational device.
This is just blatantly untrue. What I said was:
So whether or not the mechanism is implemented by a human or wiring explicitly makes no difference.
This should go without saying, but of course, there are entirely unproblematic cases of such a relationship, for instance, if both A and B are necessary consequences of a common cause—as in your light bulb example. But in the case where the relationship is causal, or generative, as in the case of the interpretation, which after all is the reason for the existence of the computation, you’ll end up in a regress.
In any case, the salient point is that the interpretation is necessary for the existence of the computation; if then the computation is necessary for the existence of the interpretation, the whole thing just never gets off the ground. The regress can only be broken by the existence of interpretations that don’t derive from computations.
It’s not different in the least, as I outline below.
You’ve just given a simple example of what semantics is.
You’re going down a rabbit hole that is about nothing more than the choice of arbitrary alphabets. While I appreciate your attempt to explain your position, the only obvious difference between the human mind and a computational device is that the syntactic operations on symbolic representations (granting that that’s indeed how cognition works) in the mind is a hidden intermediate process, the visible results being a direct interaction with the external world. Whereas computers typically expose some level of these symbolic representations, such as by printing numerical results which we then look at (“interpret”, if you like). But it’s trivially obvious that this need not be the case, and we can build an AI that has robotic interfaces with the external world that equivalently hides its internal representations.
No. The central point of Searle’s argument is that the room is merely manipulating symbols and possesses no knowledge of semantics, which is to say, no knowledge at all. But this is what you accuse computation of, and specifically my answer to your challenge when you say “… it merely manipulates symbols, syntactic tokens, which can be interpreted in different ways”. This is exactly Searle’s argument, and that this is false is exactly why it fails.
Your repetitive denial that Watson extracts semantics from the Jeopardy questions also exactly reflects Searle’s argument – more on that below.
This is just nonsense, and the people who built Watson beg to differ.
From a research paper [PDF] describing Watson’s question analysis component (emphasis mine):
The first stage of processing in the IBM Watson system is to perform a detailed analysis of the question in order to determine what it is asking for and how best to approach answering it. Question analysis uses Watson’s parsing and semantic analysis capabilities: a deep Slot Grammar parser, a named entity recognizer, a co-reference resolution component, and a relation extraction component.
The paper then goes into greater detail, giving an example near the end of how the semantic analysis works:
The deep semantic relations framework is well suited for detecting and instantiating slot values, and an adaptation for that purpose is a part of the semantic frame-based answering pipeline. As an example, the question “His 2 acting Oscars have been awarded for playing a tough cop in 1971 and a brutal sheriff in 1992” leads to the identification of the following relations:
awardType(Oscar), awardWinner(focus), awardRole(tough_cop), and awardCategory(acting).
The reference to “deep semantics” reflects one of the Watson design goals described in a previous overview paper – “Integrate shallow and deep knowledge: Balance the use of strict [deep] semantics and shallow semantics, leveraging many loosely formed ontologies”. “Deep semantics” here means explicitly engineered knowledge structures that allow the machine to have a human-like level of understanding of natural language, while “shallow semantics” are more superficial approaches based on things like pattern matching and frequently built up by machine learning. Watson notably uses both techniques.
To claim that Watson doesn’t do semantic analysis – and moreover to try to justify that claim by equating it to a table lookup – is, again, just philosophical sophistry. And of course the table lookup argument could be applied to any computation whatsoever, and hence to disclaim the possibility of machine intelligence altogether, which is precisely the nonsense the Searle has been peddling and that has made him so ridiculed in the AI and cognitive science communities.
I’m sure you’re going to disagree with all of this but at this point I don’t know that there’s anything more I can say.
That’s a non-trivial hypothesis on how the mind works that you haven’t made a convincing argument for. Furthermore, it again assumes what you need to establish to make computationalism convincing: that from the manipulation of symbols, their meaning can be obtained. My argument, if it establishes its conclusion—which you have done nothing to call into question—exactly shows that this can’t happen; that all the manipulation you’re doing on the level of symbols, using computation, still falls short of establishing their semantics.
Again, what you’d need to show is something that computes the function f, in the same way that I using the box do, yet without the interpretive capacity of the human mind intervening to make the connection to the semantic level. Otherwise, you simply have no case.
But assuming that the behavior of the AI with robotic interfaces entails that it has any semantic capacity is just begging the question; and is, in fact, shown not to be the case by the lookup-table argument, as a lookup table can duplicate its competence without any pretense at semantic understanding. Now, of course, that doesn’t mean that the robotic AI doesn’t have semantic competence, but it does mean that you need some further reason to establish that it does beyond its mere behavior.
That is the conclusion Searle’s argument is intended to reach, yes. It’s also (a part of) the conclusion my argument establishes. But both arguments go about this in a different way, and hence, must be considered separately.
Searle’s argument doesn’t rely on the interpretational nature of syntactic vehicles (symbols); he merely argues that manipulating them does not suffice to discover their semantics. This is a different argument; in the Chinese Room, no mapping from symbols to semantics is assumed—the argument makes no use of the fact that human beings can (evidently) facilitate this mapping, while mine does.
And again, you simply claim that it’s false that symbol manipulation doesn’t suffice for semantics, without providing any argument. The simple fact of the matter is that I have shown ample examples of syntactical manipulations failing to establish semantic meaning, while you haven’t been able to show a single case where it does. Sure, you gesture vaguely in the reason of complexity providing the magic sauce, such that conveniently once we can’t actually examine a system in detail, we are supposed to have faith that it’s probably gonna do something semantic-like, but that’s a far-flung hope, not an argument. The one argument you did provide—that behavior suffices to establish semantic competence—is debunked by the example of lookup tables.
I’m not denying that Watson extracts semantics—I don’t know whether it does. But I do know that Jeopardy-competence doesn’t suffice to show that it does, since that competence can be replicated without extracting semantics.
The thing is—and the difference between my and your stance is—that I’m not merely claiming things, but propose arguments; so until those arguments are shown to be faulty, your making of base assertions that they’re wrong simply accomplishes nothing.
Now, I don’t know nearly enough about how Watson works to assess the claims made about it in detail. But the notion of ‘semantics’ in computer science is usually a different one than the semantics we’ve been talking about—namely, for instance, what a given instruction set makes a computer do, the process it leads the machine to follow. That is, the semantics of a command may be to write a certain value into a certain register. But that’s ultimately just the same sort of thing as what a switch flip makes my box do.
Your quote seems to indicate that it is, in fact, this notion of semantics that is being used—based on the input, certain procedures are executed, and the fact that these procedures are executed are then considered to be the ‘semantics’ of the input. But this notion of semantics is ultimately only physical cause and effect—behavior—‘chunked’ into easily apprehended notions for the benefit of human users. It does not connect
This may or may not be what actually happens. In any case, it matters relatively little: the fact remains that Watson’s performance doesn’t suffice to showcase semantic competence, and that, in the absence of any counter to my argument, the ascription of semantics to Watson is either in the unproblematic ‘how it reacts to inputs’-sense used above, or simply in error.
In complex systems, we very easily slip into the habit of describing them in terms of meaningful notion—witness discussions in evolutionary biology, where the force of natural selection is often personified, and talked about as if it has aims and goals. This sort of talk, properly understood as being nothing but useful shorthand, is entirely unproblematic, and in particular does not actually claim that natural selection has such things as ‘aims’.
Talk about Watson’s ‘semantic abilities’ may be just that—a useful shorthand. I could say that entering a code ‘means’ to open the door to a keypad, or that a change in temperature ‘means’ to activate the heating for a thermostat; but of course, no claim would thereby be made that keypads or thermostats have any semantic competence whatever.
To adjudicate between these two ways of talk, what I’ve been repeatedly proposing is to concentrate, instead, on simpler systems, where the relevant phenomena are easily appreciated. And so far, it seems clear that nobody really has any idea—certainly, nobody in this thread has proposed an idea—of how semantics, that is, the interpretation of symbols as that what they refer to, rather than the mere reaction to symbolic vehicles, comes around. Again, the way to show that would be to show how something like my box could compute f—could manipulate symbols whose meaning is uniquely determined by the abstract specification of f.
Well, you could tell me how, in your opinion, any computation could fix the meaning of a symbol—better yet, give an example. Because that’s what I’ve done: give an example that assumes nothing special about computation whatsoever (and hence, applies with full generality), and where it’s clear that the semantics isn’t fixed, and moreover, where nothing can be done computationally to fix the semantics. That’s where the weight of argument lies in this debate: a concrete, easily apprehended example versus unsubstantiated claims (even if they come from supposed authorities).
Besides, even modern-day AI approaches make it clear where they fail to understand what they’re talking about. Take, for instance, the recent examples of text generation by OpenAI’s GPT-2. The system is given a prompt, and then continues the writing. So let’s look at one example (source):
Make no mistake, this is impressive stuff. But what’s telling about it isn’t its abilities, but rather, the mistakes it makes. For consider the bolded parts: the unicorns are named for their distinctive horn, and are called ‘four-horned’ immediately afterwards. The discovery is recent enough to be shocking, but the mystery has been solved after ‘almost two centuries’. The creatures were observed from the air, but close enough that one could touch their horns. Also, despite being animals, they’re descendants of people—moreover, people who lived there before any humans lived there.
These mistakes, I think, make it clear that the system has no actual idea what it’s talking about. For if it knew the concept of unicorn, it would know that they aren’t four-horned; if it knew what observing something from the air means, it would know that what you observe that way typically isn’t close; and so on. That is, the system has no actual clue of the semantics of the symbols it’s manipulating; all it has is a statistical predictive model of what sort of text likely follows what sort of prompts—nothing but your predictive text on your cell on steroids (well, conceptually speaking).
I have no reason at all to believe that Watson does anything relevantly different. For instance, it answered ‘What is Toronto?’, when the question category was ‘US Cities’, and ‘What is a Chemise?’, when the category was ‘on your keyboard’. In both cases, it clearly didn’t know what the things the words referenced were—a Canadian city, and a clothing item (not found on the keyboard). So at least in these cases, Watson didn’t succeed in extracting the semantics of the words it produced.
Nevertheless, the questions were both suited to the prompts it was presented with—they were just wrong, if one doesn’t consider the category. So, it doesn’t seem as if Watson is using semantic understanding—knowledge of what Toronto or a chemise is—in order to match answers to clues.
Of course, you’re likely going to claim that once Watson gets better at what it’s doing, these gaps will be closed. And it’s indeed quite possible that its performance will equal that of a human being eventually. But crucially, to conclude from that alone that the sort of thing Watson does is all there is to semantic understanding is question-begging. Indeed, you can read my examples as a demonstration of that: the box acts as if it understood the semantics of the functions—that is, it manipulates the symbols in the same way as an entity who actually does understand the semantics would.
But the box example then demonstrates that this is not what semantics boils down to; i. e., that there is more to semantic understanding than manipulating the symbols in the proper way. That’s because the human mind actually can do more: it can interpret the symbols. Again, that’s not a stipulation on my part, but merely an observation: using the box, I can uniquely compute f, without any possibility of further interpretation. Consequently, there is a semantic level beyond the symbol-shuffling level, and that’s something that a computational theory must account for.
In the end, only a demonstration of how my argument can be avoided—of how a computation can be uniquely implemented—can settle the debate; absent this, any claim to the effect ‘but the argument must be wrong because Watson’ is simply begging the question, as there is no reason at all to accept that Watson has any semantic competence.
[sub]Remember about Achilles and the Turtle?[/sub]
Well then, no soup for you!
But more seriously, you are going on as if current computer research is not valid or if your argument is actually relevant. What you described in the last cites is indeed what I pointed out as what a baby would be doing. (And there you are still pondering ‘what is good for?’) Of course it would be a mistake tossing that baby out and regardless of what you insist, research and academia still consider the CTM as serious business.
The lookup-table argument is just a philosophical truism. Why would one think that a lookup table invalidates the semantic account? Well, it appeals to the notion that there’s no intelligence in a lookup table, but that’s only because we inherently think of such things as being extremely limited in scope and function, which indeed they are in the real world. But in your theoretical world, lookup tables are completely unbounded, just like the tape of a theoretical Turing machine, and as such, they can do anything that any computation can do. That being the case, they can have arbitrarily powerful levels of intelligence and as such, they should be able to derive semantics from arbitrarily complex language structures, in just the same way as you now seem to be allowing that computations might be able to do it. It may not intuitively seem right but that’s only because we can’t intuitively conceive of nearly-infinite lookup tables, just like we don’t intuitively conceive of a sufficient expansion of pi encoding the complete works of Shakespeare.
You’re right that there are these different senses of semantics, and the sense that you describe is indeed widely used in computer science and even probably used in some descriptions of Watson internals, but not in the ones I quoted, which explicitly deal with the problem of question decomposition.
If that’s not sufficiently obvious to you, consider that the entire purpose of developing Watson was to advance the state of the art in what IBM calls open-domain question-answering, within which a semantic level of understanding of natural language is obviously an integral part. The Jeopardy challenge was both a real-world test and a publicity campaign for what evolved into a line of IBM products supporting open-domain QA and information retrieval. David Ferrucci, the principal investigator and project leader for Watson, heads the Semantic Analysis and Integration Department at the IBM Research Center and he specializes in technologies for extracting semantic meaning from unstructured natural language. This is what the man does for a living, and this is clearly how the team regarded the problem domain and how they approached it, and it’s patently absurd to suggest that Watson doesn’t actually do any of the things it was explicitly designed and built to do.
But as I said, Watson uses both deep and shallow semantics as a pragmatic approach to trying to achieve the best possible understanding, so clearly the human-like deep semantics of which it’s capable are far from complete and indeed perhaps not particularly strong (which is entirely different than “not there at all”). I don’t fully remember the reasons behind the “Toronto” choice, but IIRC there was some strong factor in its favor that outweighed the obvious contradiction of “US city” but which led Watson to rank the response with a very low confidence rating – in essence, it just didn’t know the answer and was guessing. I believe the correct answer, whatever it was, was also in its list but ranked even lower. So Watson blew that one. But its win over the two best Jeopardy players ever at the time surely counts for having significant competence at a meaningful understanding of the Jeopardy clues, as does the fact that essentially the same natural language QA engine has been successfully migrated to entirely different problem domains.
I’ll respond to more if I have anything further to add to your other points.
For the sake of accuracy I should revise a sentence in the third paragraph of #429. I should have said “The Jeopardy challenge was both a real-world test and a*** proof of concept*** for what evolved into a line of IBM products supporting open-domain QA and information retrieval”.
Calling the Jeopardy challenge a “publicity campaign” makes it sound like IBM already had a product (they didn’t) and that the thing was just a publicity stunt (I wouldn’t regard it that way at all).
Also this, which I had somehow missed before:
This sounds like the old saw that computers will never be able to comprehend semantics. Is that you, Hubert Dreyfus, who once also claimed that no computer will ever play better than very mediocre chess? Or is it John Searle, of Chinese Room fame?
I don’t know what one is supposed to conclude from this except that some programs understand semantics well, some understand it poorly, and others don’t understand it at all. Way back in the 60s Joseph Weizenbaum wrote a semi-frivolous attempt at passing the Turing test called Eliza, which played the role of a non-directive therapist. It very clearly had no idea what was being said to it, responding to particular keywords with randomly selected stock phrases, and if it didn’t detect any keywords, it would regurgitate the sentence back framed as a random stock question like, “Why do you think that …?” or “Are you happy that …?”. What do you think this lack of performance proves, other than computers were much less powerful then and AI was still in its infancy?
Anyway, back to GPT-2. I briefly skimmed the description (I haven’t read the full technical description) and it sounds to me like, at best, it’s a classic example of what I described in #426 as “shallow semantics” – essentially learned pattern matching. Kind of reminds me of the first computer program I ever wrote when I was just a little kid, and had the good fortune to be given access to a university’s IBM mainframe. It was a program which purportedly generated computer poetry. All it was was a set of sentence templates with encoded parts of speech, and a vocabulary of words tagged by what parts of speech they were. The program then wrote “poems” by randomly selecting templates and randomly filling them with the grammatically appropriate parts of speech. I must say some of the results were rather entertaining and I was quite proud of my little accomplishment, but clearly the computer had no idea what it was saying. So what? That was never the intent.
I’m far more impressed by Watson’s performance than you are, and that’s fine, but again I point out that it’s now been successfully adapted to multiple commercial problem domains where essentially language understanding is coupled to many different kinds of knowledge bases. It may or may not become a commercial success – maybe the idea is a little ahead of its time – but it’s clearly an important advancement, in my view. Do you really doubt that intelligent assistants capable of deep semantics will be with us sooner or later?
This discussion about computer understanding of linguistic semantics got me playing around a bit with Google Translate, which is both a pretty advanced translation system and also much disparaged by professional translators, but it turns out that many of those points are, arguably, concerned with relatively nuanced levels of meaning. For instance the gender-neutral pronouns in French can totally botch a translation from English where the distinction between “his” and “hers” is the whole point of the statement, requiring a complete rewrite to properly express the sentiment. We’re not quite there yet with machine translation.
But I recall some classic examples of machine-translation blunders back in the early days of MT. One famous example was “The spirit is willing but the flesh is weak” being transliterated into Russian as meaning something akin to “The liquor is still good but the meat has gone bad”.
So I tried it with Google Translate, and it came up with:
Дух желает, но плоть слаба.
Now, I can’t claim that my extremely tenuous grasp of Russian is even remotely up to the standard of evaluating the accuracy of this, but translating back into English produces:
The spirit desires, but the flesh is weak.
which seems to correctly capture the intended meaning.
Another classic example is the sentence “Time flies like an arrow”. The pertinent thing here is that there are multiple possible interpretations based on the straightforward grammar. There’s the obvious one that a human would make, but it could also be taken as a nonsensical command to time flies with a stopwatch in the manner of an arrow, or that there is a species of fly called a “time fly”, and they enjoy arrows.
So I tried it for both Russian and French – the latter of which at least I can vaguely understand – and it came up with:
Время летит как стрела.
Le temps file comme une flêche.
Both of which appear to be right on point.
But it’s more interesting than that when you consider the French version. If you input only the sentence fragment “time flies like a …” you get:
le temps passe comme un …
If you input the sentence fragment “a plane flies” you get:
un avion vole
But when you input the entire sentence, you get, as I said:
Le temps file comme une flêche.
Notice how “file” is now substituted for the more obvious “passe” (time merely passes) or “voler” (to fly); it comes from the root “filer” (to go fast). Somehow the sentiment of how fast time passes has been preserved, triggered by the entirety of the sentence. This was most likely achieved through shallow semantics, but it’s still noteworthy.
My final point here is from this story about AI achievements in chess championships that are now well known. I just wanted to cite the last line, quoting Murray Campbell, one of the IBM computer scientists who developed Deep Blue: “It’s a really dangerous business to say, ‘computers will never,’ and then say something after that”.
Simply because there’s clearly no semantic understanding going on in a lookup table. You can hide behind complexity in cases like Watson, but not in this one—a lookup table does one thing only: match its input with elements of a list. This doesn’t change, no matter how long the list is; and finding it does not entail any knowledge about what the input refers to. So if lookup-Watson is handed the clue ‘This mythical horned horse is said to only be captured by a virgin’, and answers ‘What is a unicorn?’, the process by which this answer was arrived is just—check the first entry: not it; check the second entry: not it; and so on, until, some fantastillion entries later, it finds a match. This does not tell it anything about what a unicorn is (or a virgin, or what the word ‘mythical’ means, and so on).
The lookup table is not completely unbounded; it must be able to traverse all of its items in finite (though arbitrarily long) time. As such, it will also always halt, and hence, can’t implement universal computation.
Even if it were the case that lookup tables implement universal computation, this would just be question-begging. In particular, it’s not clear that intelligence is sufficient to derive meaning; after all, intelligent behavior plausibly operates at the symbol-manipulating level, and whether that’s sufficient for semantics is exactly the question at hand.
This isn’t a question of intuition, though. The lookup table’s workings are completely transparent, and it being a big lookup table doesn’t add anything—as long as you don’t appeal to magic and propose that if you’re doing the same thing over and over, something is just going to spark up.
Question decomposition also doesn’t need to appeal to the level of meaning, though. You need to appeal to the structure of the question—what kinds of words stand in what kinds of places—and then match that to possible answers. Anyway, the question really is moot—as long as you don’t have any good notion of how a computational process gets at semantic meaning, that Watson does so is at best unsupported speculation, since (once more) it’s clear that it doesn’t necessarily do so in order to achieve its performance.
Right. The entire purpose of homeopathy is to create remedies for certain ills, of which healing is obviously an integral part. There are millions of people who believe that homeopathy achieves that goal, among them working professionals. Each of them can point to lots of cases where some homeopathic treatment worked, and a patient got better. There is lots of literature on the healing powers of homeopathy. Does this mean homeopathy works?
No, because in every case where a homeopathic remedy worked, it was in fact some other factor that was responsible for the healing process—from the placebo effect to simply the natural healing powers of the human body. How do we know that? Well, simply, because the theory we have is fundamentally incompatible with the idea that water could somehow acquire healing powers by having some inconceivably thin solution of a substance in it. That is, we have an a priori argument that homeopathy can’t work, and thus, should remain skeptical against any claims that it does work.
It would be different if, for example, the homeopaths could come up with a valid theory of how the healing effect is achieved. If they could find a valid model, integrated with modern science, of how ‘water has memory’, the reason to consider their claims with doubt would evaporate. But in the absence of such a theory, no amount of claims of homeopathic healing is really going to hold much water.
We’re in a similar situation here. There exists a good argument that demonstrates that there are semantic competences a human mind has that a computer can’t duplicate. Hence, every claim that a computer has duplicated those capabilities needs, at the very least, to be critically examined. And moreover, it needs to be shown how the argument is wrong—how the capabilities of the computer arise, in order to circumvent the argument. So any base claims—even by those who worked on the computer—simply aren’t going to settle the issue.
So let’s briefly review where we stand, since this discussion about semantics really is a bit of a red herring. I’ve argued the following:
[ol]
[li]I can construct a box whose behavior is sufficiently described by lamps lighting up in response to switches being flipped.[/li][li]I can use that box to compute a function f, which is equal to adding two two-bit binary numbers.[/li][li]I do so by interpreting parts of the box as having semantic content: by interpreting switch-states and lamp-states as representing numbers, for example.[/li][li]Thus, the human mind evidently can give symbols a unique interpretation, leading to the unique computation of a given function (like f).[/li][li]I can also interpret the symbols differently, leading to the computation of a different function f’.[/li][li]Thus, the box alone does not settle which function is computed. [/li][li]The method used to use the box to implement distinct computations is completely general, and in principle applicable to any purported computing system.[/li][li]Hence, further computation can’t be used to settle the question of what my box computes: in order to do so, it would first have to be decided what the system implementing that further computation actually computes.[/li][li]There is thus no unique fact of the matter regarding what computation a physical system implements. [/li][li]In order for the CTM to be viable, there has to be a unique fact of the matter regarding whether a given system implements the computation giving rise to a mind.[/li][li]The CTM isn’t viable.[/li][/ol]
Against this, you’ve leveled a variety of objections, which are interrelated to varying degree. One core point seems to be that there is a unique computation that’s being performed by the system, which is just given by the table of switch- and lamp-states. This runs, to me, into several obvious problems.
[ol]
[li]Switch- and lamp-states simply aren’t computational objects; they’re physical states of physical systems. How to get from there to computation as usually defined seems mysterious.[/li][li]The approach threatens to collapse into behaviorism, or even identity physicalism.[/li][li]It’s difficult to see how computation defined in this way could account for the abilities of the mind—most notably, its capacity of interpreting symbols. If the same sort of thing is just daisy-chained, we’re not getting any closer to the meaning of the symbols—consider a dictionary, where each unknown word is just explained in more unknown words: no matter how complex that dictionary becomes, you’ll never get at the meaning of any word.[/li][/ol]
To answer these worries, you introduced the ‘but Watson does it’-argument. But fundamentally, that Watson does it is just a claim, that hasn’t been substantiated (other than by appeal to authority). Furthermore, if my argument is right, we’re still at stage 1: because whether a physical system indeed implements the computation implementing Watson’s software is, then, a matter of interpreting that system in the right way. So this sort of attack just doesn’t make any headway on the problem: you’d have to believe first that a system uniquely implements Watson in order to argue that Watson can solve the semantics-from-syntax problem (and thus, generate something like a box computing my function f uniquely). But that’s just begging the question.
In the end, your claim comes down to nothing but as assertion that, once things get complicated enough, something unknown will do we don’t know what to make semantics happen. Consequently, you’re not refuting my argument, so much as just refusing it, because you don’t like its conclusion.
The thing you’d still need to do to make your position have any plausibility is to give an explanation of how a computational system could conceivably implement a function like my f uniquely. Without that, there simply is no logical force to your brute denial.
This sort of guilt-by-association argument isn’t really doing your position any favors. The more so, since (as you I suppose long have tired from having to constantly miss) Dreyfus’ arguments have been vindicated to a large degree. You can’t really claim that because he was wrong on something, his entire stance is false.
It shows that, in order to give a—to a certain, limited degree—convincing imitation of understanding, no actual understanding is necessary, thus calling into questions arguments that conclude understanding from mere behavior.
Of course, but that’s the point: a very strong likeness of intelligible text can be created, without any understanding behind it. Hence, it’s very dubious that Watson needs any understanding to approximate human performance, as well.
This is once again nonsense, and all I can do is try once again to carefully explain why. And given that it’s nonsense, I don’t see the point of revisiting the rest of the argument that depends on it.
Any deterministic computation is reducible to the transformation of a set of inputs to a set of outputs. ANY computation. The salient question here is only whether all computations are deterministic. If they are – and as a non-believer in magic and tooth fairies I take it as axiomatic that any computation is deterministic – then in your imaginary theoretical world all possible inputs can have their outputs pre-computed and loaded into an arbitrarily large (and possibly infinite) lookup table. This is the case whether the computational problem is adding two numbers or computing the prime factors of an arbitrarily large integer. Note that in both cases – even the trivial addition – your hypothetical table is infinitely large, and would take an infinite amount of time to create. This is contrary to your stated claim that the table isn’t unbounded. It absolutely is, or else your argument falls apart at the starting line, and not all computations can be mapped to a lookup table.
So the “lookup table” argument is completely meaningless because it simply boils down to being exactly equivalent to the argument about the limits of computational capabilities, which is precisely begging the question because the limits of computation is what philosophers like Searle and Dreyfus have been arguing about – mostly wrongly – with AI researches and cognitive scientists for decades.
Just as a side note here, I would argue that determinism exists not only in computational systems, but in ourselves, since our minds are physical systems that have to follow the laws of nature and hence, taken in their entirety as complete systems including biochemical influences on neural activity, are equally deterministic given all pertinent information. Not all of the pertinent inputs are digital, but they are all reducible to information, so in principle the entire stimulus/response behavior of a human and the entirety of someone’s identity at any instant in time could be modeled and reduced to a (very large) lookup table.
The argument doesn’t depend on it. The lookup table issue was simply something I introduced to counter your claim that Watson ‘obviously’ has semantic competence; but since that’s something you’ve so far only claimed, I can just as well simply reject it.
On the question of whether it’s nonsense, this sort of thing is standard in this discussion. Take, for instance, Jack Copeland’s discussion of the program ‘Superparry’ in Artificial Intelligence: A Philosophical Introduction. Superparry is described as a program containing all possible conversations using sentences of up to 100 words length. There’s a finite number of those, so we have a huge (but finite) lookup table. Superparry then simply looks for the appropriate inputs (the conversational history up to a given point), and selects one of its possible continuations. Superparry, to Copeland, is an ‘obviously unthinking program’, and, more importantly, in a discussion of the Chinese Room argument, he claims that ‘no one believes that a Superparry-type program qualifies as a Chinese understander’. Which is, of course, exactly what I’ve been saying.
And of course, it’s very hard to see how anybody could believe this. I mean, it’s just a simple matter of establishing that there is no understanding at all going on in such a device. For take the following lookup table:
"What is your favorite food?" | "I just love pizza!"
"The weather is nice today." | "Yeah, but I heard it's going to rain tomorrow."
Using this lookup table, a computer could make perfectly semantically appropriate replies, provided it is given one of the two inputs as prompt. (We could even give it a general response of “don’t care!” for any response not in the list.)
Now, of course, this program has no semantic understanding whatsoever. It doesn’t know what a ‘pizza’ is, what ‘rain’ is, and so on. It’s just matching the symbols—the shapes of the symbols, so to speak—it receives to the entry in its data base.
You now claim that once one makes a table that’s big enough, the same program spontaneously acquires understanding. But of course, that can never happen. Adding more lines to the table doesn’t change anything about the previous lines; the lines are never brought into any contact whatsoever, they don’t, in any sense, interact with one another. So, further lines can never clarify the meaning of earlier ones. If the program doesn’t understand the meaning of the above two lines, adding a third one won’t help it at all.
This can be shown in a different way. Suppose we have two systems: one, with a very small lookup table, say, enough to hold a very short conversation, and perhaps only one. Let’s assume that conversation is (italics denoting the contribution of the program):
“Hi, how are you today?” – “I’m fine, thanks. Who do you think is going to win the game tonight?” – “I reckon Newcastle might pull through.” – “Really? I think they’re rather outmatched.” – “Well, we’ll see. Til next time!” – “Bye!”
Now, somebody, by sheer chance, holding just that conversation with the program will take it to respond in a fully appropriate manner. However, the program’s lookup table is surely way too short to inundate it with semantics, even if such a thing were possible.
You, however, hold that a system that differs from this one in just the fact that its lookup table has been extended by some gazillions of entries would, in fact, know what it’s talking about. Even in the same conversation, showing the same behavior, the mere fact of the presence of those gazillion other entries, even though they’re never actually accessed, somehow suffices to grant understanding to the extended version.
To me, this would already seem to reduce the idea to absurdity, but nevermind, we can go on. Suppose now that the second system, with the humongous lookup table, is, in fact, outfitted with a device that blows it up if any of the entries in its lookup table other than the ones used in the above conversation is accessed. Would you still consider it to possess semantic understanding, even though they could never be accessed in principle?
It seems that this sort of argument would commit you to either of two (to me, equally unpalatable) options:
[ol]
[li]The second system does possess semantic understanding, even after it is fitted with the explosive device.[/li][li]The second system does not possess semantic understanding, once it is fitted with the explosive device.[/li][/ol]
The first position entails that the mere presence of these gazillions of other entries somehow suffices to grant the system an understanding of the meaning of the ones used in the conversation, even though these entries could never be accessed. That is, while remaining completely inert, while not even being possibly accessible, these entries still have an effect on whether or not entirely separate entries are understood.
The second position is worse: it entails that the question of whether a system has semantic understanding is present on an explosive device, even if it never in fact comes active. That is, the device, in the conversation above, never actually blows up the system—it remains completely inert—yet, its mere presence suffices to shut down the ability of semantic understanding in the system.
Both positions thus seem, to me, to be equally untenable. Consequently, if the small lookup table doesn’t confer semantic understanding (and it obviously does not), then neither does a larger one (which is what we should have expected, since the emergence of sudden understanding by just adding further entries to a table would seem nothing short of magical).
That’s why Copeland could validly take himself to be uttering nothing but a truism when he proposed that nobody could hold such a lookup table program to possess any sort of understanding whatsoever.
It’s not really an issue (since, in fact, deterministic and non-deterministic computation are equivalent in power, as you can always just evaluate all branches of an indeterministic automaton), but quantum computation is generally thought to be indeterministic without magic or tooth fairies. Also, regarding this bit:
It would be very astonishing if the brain didn’t make good use of the randomness in its environment; randomness is generally a very valuable resource for complex systems—from thermal fluctuation facilitating DNA-folding to genetic algorithms. In fact, I’ve posted a set of sources that provide good evidence to the utilization of randomness by the brain somewhere upthread.
Thinking about an infinitely large lookup table is severely problematic, though. For one, whether you can perform a search would seem to depend on the Axiom of Choice. Hence, this sort of discussion generally assumes a limited domain of discourse, to keep the lookup table finite (such as, for instance, the length of a Jeopardy-episode).
And in such a limited domain, there clearly are things finite (that is, physically realizable) computers can do that a lookup table can’t equal—get into an infinite loop, for example; conditional branching, more generally.
This is a good thing for your argument, in fact, because it entails the possibility that computers with a more sophisticated (universal) instruction set can outperform a lookup table—and that, they need to be able to do, as otherwise, the above would simply mean that no computer at all could possibly possess semantic understanding. If it were that easy, I could’ve just saved myself the trouble of coming up with my example!
This is actually false, but I’d prefer to drop the confusing and obfuscatory table analogy since actual AI computations do real-world table lookups, and to discuss the matter merely in terms of computation for the sake of clarity, which is either equivalent to your hypothetical tables (in which case it doesn’t matter) or it’s not, as you seem to be hinting towards the end, in which case it should never have come up.
The achievement of certain behavioral qualities actually does come down to computational complexity, for the fundamental reason that qualities like “understanding” and “intelligence” – or for that matter, “semantics” in the strong sense – have no mathematical definition and are qualitative judgments that we make empirically. So pointing out how silly some question/response program is and that it won’t get any smarter if you give it more dialog options is probably true but rather obfuscates the point. One can imagine some simpleton acting like the program you described (which sounds a lot like the aforementioned Eliza) by reading responses from a card. One can next imagine someone who’s at least memorized the responses. Then one can imagine someone who’s deduced a pattern in the questions and responses and dynamically generates similar but different responses in accordance with various cues he picks up, regarding the table of responses only as templates. Then one can imagine a whole hierarchy of those who draw increasingly more than the former from general knowledge and life experiences in their responses, and correspondingly less from rote patterns, and have hardly any preset templates at all.
Computational systems can follow the same hierarchy, and they are correspondingly associated with consuming greater computing resources and requiring increasingly complex code. So tell me, at what level does actual “understanding” occur? At what level can we say that we see “intelligence”? It must surely be acknowledged toward the high end where a witty and original response was produced that this is creative intelligence, and at the low end where it’s a lookup in a simple table (like what Eliza does) that it clearly is not. So where in this continuum did this transition to intelligence take place? It’s entirely a philosophical question and not a computational one, and I’m happy to let philosophers argue about it til the cows come home. But the phenomenon is absolutely and empirically real.
And speaking of semantics, I do want to point out again (in case you missed it) the result of my little experiments with Google Translate in #432, particularly “Time flies like an arrow” going from English to French. I was impressed by how three different phrases using the word “flies” produced three different French verbs that were all contextually correct, and particularly how in that sentence it was translated to a somewhat unusual verb meaning “to go fast” that one wouldn’t normally associate with “fly” but was exactly correct for this context! It wasn’t that long ago that the best research translation systems couldn’t do this well, and this is a free internet utility. In fact the two sentences I used were ones that were classically problematic for early systems.
So what? In the macroscopic world, “randomness” is just a word we made up to say that we don’t have enough information to predict some outcome. The underlying systems are still deterministic. The only real randomness that exists is at the quantum level. If you want to argue that quantum phenomena can percolate up and randomize aspects of the macroscopic world like brain function, then fine, but it still doesn’t mean that brain activity isn’t intrinsically deterministic. It means that brain activity is subject to undirected random noise. It has no more to do with its cognitive architecture than a cosmic ray causing a bit error in a computer is in any way part of the machine architecture.
As for quantum computers, this is the weirdness of true randomness at the quantum level. Nevertheless, though I don’t really know very much about them but to the best of my understanding – assuming that true quantum computers are even really a thing – it can be said in a practical sense that they’re just as deterministic as classical computers (else they wouldn’t be useful). They’re just extremely prone to errors internally due to unpredictable quantum decoherence, so IIRC computations have to be run repeatedly and statistically filtered. I mean, if you’re running Shor’s algorithm on a quantum computer to break a cryptography key and it non-deterministically gives you random wrong answers it wouldn’t be very useful!
You still manage to astonish, I give you that. I produce an argument to show how your position is wrong, I cite relevant literature where your position is considered so obviously wrong that it’s not even worth discussing whether anybody would conceivably hold it, and your response—‘yeah, that’s wrong, now let’s talk about something else’.
I’m thinking no, let’s not. If you ever want to get back to actual debate, I’ll be here.
You will be there in irrelevance then, a few posts ago you wanted to tell **wolfpup **that he used an argument from authority, the problem I saw there is that you seem to not know when that is a fallacy, you just pick and choose what is a proper authority.
Absolutely - if it was a temporal relation, where one thing’s existence had to precede the other thing’s existence, then there would be a problem. It’s not and so there isn’t.
Thank you for stating the logical flaw in your argument so clearly.
And, as you have yourself highlighted, this is not a problem, because there’s not a temporal discontinuity.
Look, it’s very simple - the reason why things can’t create themselves is because physical creation is presumed to have the following properties:
At T[sub]0[/sub] the created thing exists.
At T[sub]-1[/sub] the created thing doesn’t exist.
At T[sub]-1[/sub] something existed to do the creating.
And thus creation by definition requires an external creator, because the created thing didn’t exist at the T[sub]-1[/sub] when the creator thing’s creator is required to have existed.
Now let’s talk about this “logical dependence”
At T[sub]0[/sub] the consequent is true.
At T[sub]0[/sub] the antecedent is true.
If the antecedent is the consequent this is actually not a problem for the logic!
Consider an ‘ideal’ bicycle chain going around two ideal frictionless gears in a vacuum. It’s currently spinning - the top part of the chain is running to the left, and will continue doing so indefinitely. Why? Because the bottom half of the chain is constantly supplying an endless supply of chain links coming from the right side that are pushing the other links ahead of them. These links come from the fact that the lower chain is running to the right, pushing an endless supply of links out of its rightmost end And why is the lower chain shoving links to the right? Because it’s getting an endless supply of links pushing into its left end, from the upper chain.
The movement of the upper chain is causing the movement of the lower chain.
The movement of the lower chain is causing the movement of the upper chain.
Circular logical dependence. Not a problem.
You keep citing physical things that require temporal causality as though they’re somehow applicable to your argument.
But this only applies if the interpretation is interpreting the system’s output as a computation, right? If I look at the box and say, “Pretty lights!” then no computation has occurred. If I look at the box and say, “Nice paperweight,” then no computation has occurred.
Right?
Suppose I say to myself, “Huh, I wonder what seven minus seven is?”, and grab my handy X-minus-X calculation box and flip the switches to ask that question. “No lights came on! That means the answer is zero! Sweet” and walk off whistling. I have interpreted the box’s output as that of a computation, so the box did a computation.
However the box was unplugged. And also the box has no workings inside it whatsoever. It’s completely hollow. Yet by your non-definition it’s still a computational device - one that calculates X-X.
In your argument, the statements “the object is doing a computation” and “the object is being interpreted as doing a computation” are literally synonymous statements.
Welcome to “how to pretend you’re defining a term while not doing so, 101”.
An empty box can compute the sum of 0 and 0. Empty air is a computational device!
You’re going to have to do better than that, or your argument is going to be usable to prove that humans don’t have minds, which will immediately demonstrate the fact that it is indeed fallacious via argumentum ad absurdum.
I genuinely have absolutely no idea what you’re on about or what you think you’ve proven that is “so obviously wrong that it’s not even worth discussing”. In any case, what I was trying to discuss there was the concept of a hierarchy of conversational AI programs where the lowest tier simply looks up responses in a table, and as you move up the ladder, table lookups were gradually replaced by more and more computationally intensive generated responses. So I said for the sake of clarity let’s drop the “all computation is a table” nomenclature in this particular discussion and just speak in terms of computation so that when I reference a “table” we’re clear on what we’re talking about – a table within a program. I can only assume that you misunderstood my meaning or intent. Regardless, if you want to bow out, suit yourself.
As for astonishment, there’s lots of that to go around, considering your flippant dismissal of the most foundational theory of cognitive science that is the basis of most research in the field today.
