Overcoming Quine's objection to the analytic / synthetic distinction

[PeteOlcott]

Analytical_Knowledge
The set of expressions of language verified as true entirely on the basis of their semantic meaning specified as stipulated relations between expressions of this language.

Prolog source code refuting Quine
marital_status(bill, married).
marital_status(sam, single).
bachelor(X) :- \+ marital_status(X, married).

?- bachelor(bill).
false

?- bachelor(sam).
true

https://en.wikipedia.org/wiki/Two_Dogmas_of_Empiricism

The above simple Prolog shows how to define bachelor(X) as synonymous
with not married(X) without any cycles that the Wikipedia article about
Quine's objection indicated would be required.

Quine, W. V. (1951) TWO DOGMAS OF EMPIRICISM
The Philosophical Review, Vol. 60, No. 1 (Jan., 1951), pp. 20-43
https://pdfs.semanticscholar.org/675b/0 ... 1585101085

The above paper goes on and on in very tedious great depth of its
author's difficulty of defining synonymity between two terms. This is
actually trivial. We simply define the meaning of one term and then
define the meaning of the synonymous term on the basis of the definition
of the first term as the Prolog has shown above.

copyright Pete Olcott 2020

[Skepdick]

There are only two hard problems in Computer Science. Naming things, cache invalidation and off-by-1 errors.

Your falls into the problem of "naming things"

Why have you chosen "bachelor" to mean a person's marital status?

Code: Select all

bool Bachelor(Human_Being X)
{
  return (X.Marital_Status == 0); 
}

Why didn't you choose it to mean their level of education?

Code: Select all

bool Bachelor(Human_Being X)
{
  return (X.Has_Bachelor_Degree == 1); 
}

[Skepdick]

You really seem to be struggling with the idea of choice - design choice, which is basically the concept of reification.

Given your previous posts about abstract syntax trees and reifying knowledge-ontologies, I really think you need to look at LISP, and in particular the design choices it makes: it reifies the eval() function and its own syntax. It doesn't have to - you can reify other things: data flow, control flow, metaclasses, messages. Again: it's just a design choice.

This leads to another important distinction related to evaluation strategies.

The distinction between call-by-value and call-by-reference has a Monadic equivalent. Continuations.

https://ncatlab.org/nlab/files/WadlerMonads.pdf#page=25
https://en.wikipedia.org/wiki/Call-with ... ntinuation
https://en.wikipedia.org/wiki/Continuat ... sing_style

[Skepdick]

And MAYBE, given your inability to grasp that naming variables/functions/objects is a completely arbitrary exercise, you want to consider the π-calculus. Because it has this peculiar property with regards to naming computations.

The π-calculus allows channel names to be communicated along the channels themselves, and in this way it is able to describe concurrent computations whose network configuration may change during the computation.

[PeteOlcott]

There are only two hard problems in Computer Science. Naming things, cache invalidation and off-by-1 errors.

Your falls into the problem of "naming things"

Why have you chosen "bachelor" to mean a person's marital status?

Code: Select all

bool Bachelor(Human_Being X)
{
  return (X.Marital_Status == 0); 
}

Why didn't you choose it to mean their level of education?

Code: Select all

bool Bachelor(Human_Being X)
{
  return (X.Has_Bachelor_Degree == 1); 
}

My whole point is that Quine was incorrect when he determined that the synomity of Bachelor(X) with ~Married(X) could not possibly be defined in an acyclic way.

There are all kinds of ways that the concept of Bachelor could be associated with a unique meaning at both the source code level and the object code level, internally it would be this GUID: f67204ca-663f-4ab6-a0ad-717034f8903b.

[Skepdick]

My whole point is that Quine was incorrect when he determined that the synomity of Bachelor(X) with ~Married(X) could not possibly be defined in an acyclic way.

You haven't defined it in an acyclic way. Firstly, because what you've defined is not a Bachelor, but a test for a bachelor. In predicate logic the statement Bachelor(X) is explicitly assumed (but not explicitly stated) to be true. But in your code Bachelor(X) could be true OR false given any particular X. In English some Xs are bachelors, some aren't.

Secondly, you've mixed up two programming paradigms (functional and object-oriented) so you've managed to trip over the expression problem (I'll elaborate at the end of this post).

The accessor method Marital_Status on X is the same thing as the predicate Married(X), so your Bachelor() predicate is really Bachelor(~Married(X)).

It will become obvious to you when you make the implementation of the Human_Being object explicit, because when it comes right down to it - you are still reading 1 bit of information irrespective of how you label that bit.

There are all kinds of ways that the concept of Bachelor could be associated with a unique meaning at both the source code level and the object code level, internally it would be this GUID: f67204ca-663f-4ab6-a0ad-717034f8903b.

There is no difference between "source code level" and "object code level" - code is data and data is code. But that's not the problem I am pointing out.

What I am pointing out is that you can't disambiguate Bachelor(X) into is_married?(X) and has_bachelor_degree?(X). Because the predicate Bachelor() is overloaded.

You are tripping over the The expression problem. It's a well understood (but unsolved) problem.

Read these posts to crystallise the concept in your mind:

https://stackoverflow.com/questions/359 ... on-problem
https://wiki.c2.com/?ExpressionProblem
https://eli.thegreenplace.net/2016/the- ... solutions/

This is why I pointed you to reification and Wadler's law a few posts up - what you choose to make explicit (fist class citizen) In any formal system is a choice.

[PeteOlcott]

My whole point is that Quine was incorrect when he determined that the synomity of Bachelor(X) with ~Married(X) could not possibly be defined in an acyclic way.

You haven't defined it in an acyclic way. Firstly, because what you've defined is not a Bachelor, but a test for a bachelor. In predicate logic the statement Bachelor(X) is explicitly assumed (but not explicitly stated) to be true. But in your code Bachelor(X) could be true OR false given any particular X. In English some Xs are bachelors, some aren't.

If I haven't defined it in an acylic way then you could point to the cycle and you can't because there is none.

The way that the term bachelor is define in predicate logic is by using a bachelor predicate, that is what I have done.
Perhaps you were unaware that a Predicate is merely a function that evaluates to Boolean.

Code: Select all

Thing
  Physically Existing Thing
    Human_Being
      properties
        Name
        Marital_Status {SINGLE, MARRIED, DECEASED_SPOUSE}
        Adulthood {0,1}
        Sex{MALE, FEMALE}
  Non Physically Existing Thing
    Marriage
      properties
        parties
          Human_Being spouse_1
          Human_Being spouse_2

bool Bachelor(Human_Being X)
{
  return (X.Marital_Status == SINGLE &&
          X.Adulthood == 1 &&
          X.Sex == MALE);
}

Human_Being("Bill", SINGLE, Adulthood(1), MALE)
Human_Being("Sally", SINGLE, Adulthood(1), FEMALE)
Human_Being("John", MARRIED, Adulthood(1), MALE)

Now the otherwise meaningless string "Bachelor" have been defined with a sufficient number of meaning postulates that allow it to select human beings that are bachelors from those that are not.

Copyright 2020 Pete Olcott

[Skepdick]

If I haven't defined it in an acylic way then you could point to the cycle and you can't because there is none.

I told you where the cycle is. It's in your implementation of the Human_Being class (which you have skilfully omitted).
There is necessarily a Marital_Status instance-method.

Obviously. Because you are calling it.

Code: Select all

return (X.Marital_Status == 0); 

Perhaps you were unaware that a Predicate is merely a function that evaluates to Boolean.

Perhaps you are unaware that EVAL() itself is a predicate?

https://en.wikipedia.org/wiki/Eval

Now the otherwise meaningless string "Bachelor" have been defined with a sufficient number of meaning postulates that allow it to select human beings that are bachelors from those that are not.

Q.E.D you don't understand the expression problem.

I am unable to select the bachelors from non-bachelors because your data model doesn't capture who has a Bachelors degree and who doesn't.

Quine is right. The analytic/synthetic distinction is not necessary because everything about logic/truth is synthetic.

[PeteOlcott]

If I haven't defined it in an acylic way then you could point to the cycle and you can't because there is none.

I told you where the cycle is. It's in your implementation of the Human_Being class (which you have skilfully omitted).

It cut and pasted the Human_Being class right here:
Human_Being
properties
Name
Marital_Status {SINGLE, MARRIED, DECEASED_SPOUSE}
Adulthood {0,1}
Sex{MALE, FEMALE

If someone hit you in the face with a pie would you deny that there ever was a pie?

[PeteOlcott]

Q.E.D you don't understand the expression problem.

I am unable to select the bachelors from non-bachelors because your data model doesn't capture who has a Bachelors degree and who doesn't.

Oh I see you are just being a Jackass, good bye.

[Skepdick]

It cut and pasted it right here:
Human_Being
properties
Name
Marital_Status {SINGLE, MARRIED, DECEASED_SPOUSE}
Adulthood {0,1}
Sex{MALE, FEMALE

The above is not a programming language I am familiar with.

Go ahead and implement the Human_Being C++ and see for yourself.

If someone hit you in the face with a pie would you deny that there ever was a pie?

I would certainly deny knowledge of it being a pie. Something hit me in the face. If I had time to examine what it was, I would've dodged it.

[Skepdick]

Oh I see you are just being a Jackass, good bye.

I pointed you to the expression problem. You chose to ignore it.

What I am pointing out is that you can't disambiguate Bachelor(X) into is_married?(X) and has_bachelor_degree?(X). Because the predicate Bachelor() is overloaded.

You are tripping over the The expression problem. It's a well understood (but unsolved) problem.

Read these posts to crystallise the concept in your mind:

https://stackoverflow.com/questions/359 ... on-problem
https://wiki.c2.com/?ExpressionProblem
https://eli.thegreenplace.net/2016/the- ... solutions/

This is why I pointed you to reification and Wadler's law a few posts up - what you choose to make explicit (fist class citizen) In any formal system is a choice.

[PeteOlcott]

I am unable to select the bachelors from non-bachelors because your data model doesn't capture who has a Bachelors degree and who doesn't.

It is impossible to mix up the idea of an unmarried adult male from the idea of someone with a four year college degree in the formalism that I stipulated because just these things are not in its database.

You are clearly stuck in rebuttal mode and have no motivation what-so-ever to understand what I am saying and only have the sole purpose of finding fault even where no fault what-so-ever exists. I no longer have any patience what-so-ever for such behavior.

[Skepdick]

It is impossible to mix up the idea of an unmarried adult male from the idea of someone with a four year college degree in the formalism that I stipulated because just these things are not in its database.

The absence of that distinction in your database is precisely the problem I am pointing out!

Bachelor is an overloaded term in English. It is NOT overloaded in your ontology. Therefore your ontology is incomplete!

I literally said that. Are you reading my responses or are you just wasting my time?

What I am pointing out is that you can't disambiguate Bachelor(X) into is_married?(X) and has_bachelor_degree?(X). Because the predicate Bachelor() is overloaded.

You are clearly stuck in rebuttal mode and have no motivation what-so-ever to understand what I am saying and only have the sole purpose of finding fault even where no fault what-so-ever exists. I no longer have any patience what-so-ever for such behavior.

I have found a fault. I have pointed out your fault. I have pointed you to further reading to rectify your fault.

What more do you want from me?

Your database cannot answer the question "Is John a bachelor?" because it cannot disambiguate the the meaning of 'bachelor'.
Your system cannot handle dynamic dispatch.

[PeteOlcott]

It is impossible to mix up the idea of an unmarried adult male from the idea of someone with a four year college degree in the formalism that I stipulated because just these things are not in its database.

The absence of that distinction in your database is precisely the problem I am pointing out!

Bachelor is an overloaded term in English. It is NOT overloaded in your ontology. Therefore your ontology is incomplete!

I literally said that. Are you reading my responses or are you just wasting my time?

What I am pointing out is that you can't disambiguate Bachelor(X) into is_married?(X) and has_bachelor_degree?(X). Because the predicate Bachelor() is overloaded.

You are clearly stuck in rebuttal mode and have no motivation what-so-ever to understand what I am saying and only have the sole purpose of finding fault even where no fault what-so-ever exists. I no longer have any patience what-so-ever for such behavior.

I have found a fault. I have pointed out your fault. I have pointed you to further reading to rectify your fault.

What more do you want from me?

Your database cannot answer the question "Is John a bachelor?" because it cannot disambiguate the the meaning of 'bachelor'.
Your system cannot handle dynamic dispatch.

Think of it as the Prolog model with the only meaning of bachelor defined that pertains to marital status.