## Structural Epistemology Introduction Part 1

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;
}

// 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 ( (0 - a) + 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

Elliot Temple on November 10, 2003

## Messages (7)

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 "&lt;" (no quotes). To be completely correct you should probably replace all of them, and replace all greater-than symbols with "&gt;".

Gil at 5:07 PM on November 10, 2003 | #613 | reply | quote

thanks, changed.

Elliot at 6:31 PM on November 10, 2003 | #614 | reply | quote

Anonymous at 5:43 PM on February 5, 2016 | #4886 | reply | quote

fixed

Anonymous at 5:50 PM on February 5, 2016 | #4888 | reply | quote

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

wtf is that comma :(

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

Following a suggestion, I changed a*(-1) to 0-a in the recursive example so that it isn't using a built in multiplication function.

curi at 10:17 PM on January 29, 2019 | #11755 | reply | quote

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

I think using a nonstandard meaning of denotation will make it harder to talk about structural knowledge outside FI. The idea is pretty general, though. It's important for learning (like you mention in FI.com article)

Do you think it's an issue / worth thinking about changing?

Nothing single word comes to mind as a better alternative though. Maybe some groups of words.

Max at 6:03 PM on November 2, 2020 | #18564 | reply | quote

(This is an unmoderated discussion forum. Discussion info.)