Imagine you are handed a black box. You can't open it, but on one side is an input mechanism, and on the other side is an output mechanism. For example, the input mechanism might be a keyboard, and the output a display screen. The box, somehow (you don't know the inner workings) maps inputs to outputs. That means if you give it an input, it figures out what output to give back, according to its inner workings. And for simplicity, assume the box is in no way random. For a given input, it always gives the same output.

Now, imagine someone gives you a second black box. And you test both out, and discover that for any input, both boxes give the same output. You test every single allowed input, and they always give the same answer. (The word I will use for this is: the two boxes have the same *denotation*). Now, the question is: do the boxes do the same thing? Do they contain the same knowledge?

Well, of course it's possible that they do. They might be the same inside. But can we be sure? Just because they always answer the same way, can we tell they *definitely* do the same thing? And either way, can we say they definitely have the same knowledge?

I'd like to apologise to non-programmers now. The following examples will probably look like gibberish to you. But read the English around them, and I think my point should still make sense.

Here are three different ways to do a multiply function. They all accurately multiply any integers. They have the exact same domain (allowed input), the same range (possible outputs), and they map (relate) the same elements of the domain (inputs) to the same elements of the range (outputs).

```
// iterative multiplication
int multiply(int a, int b)
{
int total = 0;
if (b > 0)
for(int j=0; j<b; j++)
total += a;
if (b < 0)
for(int j=0; j>b; j--)
total -= a;
return total;
}
// recursive multiplication
int multiply(int a, int b)
{
if(b == 0)
return 0;
if(b > 0)
return (a + multiply(a, b-1));
if(b < 0)
return ( (a * -1) + multiply(a, b+1));
}
// multiplication using a built-in function
int multiply(int a, int b)
{
return a*b;
}
```

As you can see, even if you don't understand the code, all three are written differently. I assure you, however, they do give the same answers. Now, remember the black box I talked about? Well, lets say you have three that all do integer multiplication. The inner workings could be the three functions I just showed.

Do each of the black boxes do the same thing? No. Each uses a different procedure to find its answer. Like if you wanted to get from California to New York, you might go through Canada, through Mexico, or stay in the US the whole way. Each trip would start and end in the same place, but they'd certainly be different trips.

But the key question is whether each black box, or each multiply function, which has the exact same *denotation*, has the same knowledge.

I propose they do not. While they have the same denotation, I would say they have different *knowledge structure*. And to see why this matters, and makes a great difference: Alright, the boxes have the same functionality (namely multiplication) *now*, but what if we want to alter them? If we want to change their denotation, even just a little bit, then knowledge structure makes all the difference.

**To be continued...**

PS: I'm aware that I'm not using 'denotation' in the standard, dictionary way.

Note: David Deutsch explained much of what I know about structural epistemology to me. Kolya Wolf explained some too, and also Kolya originally thought of the idea.

Part 2
## Comments (5)

Your iterative example is messed up (in IE at least) because you have "j<b" and it looks to IE like the beginning of a bold tag.

You should at least replace that instance with "<" (no quotes). To be completely correct you should probably replace all of them, and replace all greater-than symbols with ">".

thanks, changed.

part 2 in the OP is a bad link.

fixed

> The box, somehow (you don't know the inner workings) maps inputs to outputs.

wtf is that comma :(

curiat 9:48 AM on July 15, 2018 | #10180 | reply | quote