## Conceptual Truth can be understood as math

What is the basis for reason? And mathematics?

Moderators: AMod, iMod

Eodnhoj7
Posts: 5154
Joined: Mon Mar 13, 2017 3:18 am

### Re: Truth can be understood as math

PeteOlcott wrote:
Thu Aug 15, 2019 5:13 am
Eodnhoj7 wrote:
Thu Aug 15, 2019 5:04 am
PeteOlcott wrote:
Thu Aug 15, 2019 3:02 am

When we make the analytic versus synthetic distinction correctly the stipulated relations
between finite strings IS ALL THERE IS TO THEIR TRUTH.

The analytic side of this distinction fully encompasses Tarski Undefineability and Gödel
1931 Incompleteness, thus making context and every aspect of physically manifest reality
OFF-TOPIC and OUT-OF-SCOPE.
"If we make the distinction correctly" fundamentally requires us to analyze analysis. All analysis, as divergent in nature is grounded in a bare minimum quanity of 2 phenomenon being produced or a qualitative dualism.

Analytic divergence: 1 -> (1(.5), 1(.5))

->

Synthetic convergence: (1(.5), 1(.5)) -> 2(1)

Synthesis can maintain the original truth while producing a variation.

Synthesis allows for maintenance and continuity.
Still pretty nuts to me. It is like you are saying that the stipulated
relation between finite strings "5" [>] "3" is free to wiggle around if
it gets in the mood of divergence.
All axioms are subject to divergence, as all axioms manifest definition through divergence.

If the axiom is not defined it becomes formless.
If the axiom is defined to much...it becomes formless.

PeteOlcott
Posts: 730
Joined: Mon Jul 25, 2016 6:55 pm

### Re: Truth can be understood as math

Eodnhoj7 wrote:
Thu Aug 15, 2019 5:20 am
PeteOlcott wrote:
Thu Aug 15, 2019 5:13 am
Eodnhoj7 wrote:
Thu Aug 15, 2019 5:04 am

"If we make the distinction correctly" fundamentally requires us to analyze analysis. All analysis, as divergent in nature is grounded in a bare minimum quanity of 2 phenomenon being produced or a qualitative dualism.

Analytic divergence: 1 -> (1(.5), 1(.5))

->

Synthetic convergence: (1(.5), 1(.5)) -> 2(1)

Synthesis can maintain the original truth while producing a variation.

Synthesis allows for maintenance and continuity.
Still pretty nuts to me. It is like you are saying that the stipulated
relation between finite strings "5" [>] "3" is free to wiggle around if
it gets in the mood of divergence.
All axioms are subject to divergence, as all axioms manifest definition through divergence.

If the axiom is not defined it becomes formless.
If the axiom is defined to much...it becomes formless.
I have ALWAYS only been talking about stipulated relations between finite strings.
[If the axiom is not defined it becomes] OFF-TOPIC and OUT-OF-SCOPE.

What kind of a nutty idea is: [the axiom is defined too much] ?

Skepdick
Posts: 2086
Joined: Fri Jun 14, 2019 11:16 am

### Re: Truth can be understood as math

PeteOlcott wrote:
Thu Aug 15, 2019 5:26 am
I have ALWAYS only been talking about stipulated relations between finite strings.
It is becoming more and more obvious to me that you don't understand how type-systems actually work.
From your very own grammar definition ◁ means "isTypeOf". And it takes two strings as inputs.

But then cat ◁ cheese is True. Because both "cat" and "cheese" are the same types of things. They are String-Types !
In fact string1 ◁ string2 is ALWAYS True, because any two strings are the same TYPE of thing. STRINGS.

https://repl.it/repls/UnderstatedNauticalNumerator

Code: Select all

``````class Object
def isTypeOf?(other)
return self.class == other.class
end
end

puts "cat".isTypeOf? "cheese"
=>true
``````
Or... since you are C++ person...

Code: Select all

``````#include <typeinfo>
#include <iostream>

bool isTypeOf(std::string a, std::string b) {
return typeid(a) == typeid(b);
};

int main(){
std::string cat = "cat";
std::string cheese = "cheese";
std::cout << isTypeOf(cat, cheese) << std::endl;
return 0;
}
➜  ~ c++ type.cpp -o type && ./type
1
``````
I am almost certain I am overlooking something trivial here, so I eagerly await your implementation of the isTypeOf() function.

Eodnhoj7
Posts: 5154
Joined: Mon Mar 13, 2017 3:18 am

### Re: Truth can be understood as math

PeteOlcott wrote:
Thu Aug 15, 2019 5:26 am
Eodnhoj7 wrote:
Thu Aug 15, 2019 5:20 am
PeteOlcott wrote:
Thu Aug 15, 2019 5:13 am

Still pretty nuts to me. It is like you are saying that the stipulated
relation between finite strings "5" [>] "3" is free to wiggle around if
it gets in the mood of divergence.
All axioms are subject to divergence, as all axioms manifest definition through divergence.

If the axiom is not defined it becomes formless.
If the axiom is defined to much...it becomes formless.
I have ALWAYS only been talking about stipulated relations between finite strings.
[If the axiom is not defined it becomes] OFF-TOPIC and OUT-OF-SCOPE.

What kind of a nutty idea is: [the axiom is defined too much] ?
Paradox of precision, with the increase in defintion in one area comes a decrease elsewhere.

PeteOlcott
Posts: 730
Joined: Mon Jul 25, 2016 6:55 pm

### Re: Truth can be understood as math

Skepdick wrote:
Thu Aug 15, 2019 9:40 am
PeteOlcott wrote:
Thu Aug 15, 2019 5:26 am
I have ALWAYS only been talking about stipulated relations between finite strings.
It is becoming more and more obvious to me that you don't understand how type-systems actually work.
From your very own grammar definition ◁ means "isTypeOf". And it takes two strings as inputs.

But then cat ◁ cheese is True. Because both "cat" and "cheese" are the same types of things. They are String-Types !
In fact string1 ◁ string2 is ALWAYS True, because any two strings are the same TYPE of thing. STRINGS.

https://repl.it/repls/UnderstatedNauticalNumerator

Code: Select all

``````class Object
def isTypeOf?(other)
return self.class == other.class
end
end

puts "cat".isTypeOf? "cheese"
=>true
``````
Or... since you are C++ person...

Code: Select all

``````#include <typeinfo>
#include <iostream>

bool isTypeOf(std::string a, std::string b) {
return typeid(a) == typeid(b);
};

int main(){
std::string cat = "cat";
std::string cheese = "cheese";
std::cout << isTypeOf(cat, cheese) << std::endl;
return 0;
}
➜  ~ c++ type.cpp -o type && ./type
1
``````
I am almost certain I am overlooking something trivial here, so I eagerly await your implementation of the isTypeOf() function.
I can only reply on my phone so this reply will be terse. Apparently my IP address has been blocked.

Think of a database of N tuples. The relation is the first finite string. The subsequent finite strings are the arguments to this relation.

Tuple("type", "cat", "animal").
This tuple stipulates that a cat is of the animal type.
To verify that a stipulated relation is true only involves looking it up in the database. Not found means not true.

Code: Select all

``````struct Relation
{
std::vector<std::string> List;
public:
Relation& operator+=(const std::string& S){ List.push_back(S); return *this; }
};

struct Relation_List
{
std::vector<Relation> List;
public:
Relation_List& operator+=(const Relation& R){ List.push_back(R); return *this; }
bool True(const Relation& R); // Return true if in List, else return false.
};

void main()
{
Relation T;
T += "type";
T += "cat";
T += "animal";

Relation_List L
L += T;
}
``````

wtf
Posts: 844
Joined: Tue Sep 08, 2015 11:36 pm

### Re: Truth can be understood as math

PeteOlcott wrote:
Thu Aug 15, 2019 5:10 pm
Apparently my IP address has been blocked.
My power is unlimited.

AMod
Posts: 169
Joined: Thu Mar 20, 2008 6:32 pm

### Re: Truth can be understood as math

PeteOlcott wrote: I can only reply on my phone so this reply will be terse. Apparently my IP address has been blocked.
Not by us. It might be the case that your IP address has fallen foul of the very few IP bans we've ever made. Please PM me your IP address and I'll check if this is the case.
AMod.

PeteOlcott
Posts: 730
Joined: Mon Jul 25, 2016 6:55 pm

### Re: Truth can be understood as math

AMod wrote:
Thu Aug 15, 2019 11:06 pm
PeteOlcott wrote: I can only reply on my phone so this reply will be terse. Apparently my IP address has been blocked.
Not by us. It might be the case that your IP address has fallen foul of the very few IP bans we've ever made. Please PM me your IP address and I'll check if this is the case.
AMod.
This fixed the problem:

PeteOlcott
Posts: 730
Joined: Mon Jul 25, 2016 6:55 pm

### Re: Truth can be understood as math

Skepdick wrote:
Thu Aug 15, 2019 9:40 am
PeteOlcott wrote:
Thu Aug 15, 2019 5:26 am
I have ALWAYS only been talking about stipulated relations between finite strings.
It is becoming more and more obvious to me that you don't understand how type-systems actually work.
From your very own grammar definition ◁ means "isTypeOf". And it takes two strings as inputs.

But then cat ◁ cheese is True. Because both "cat" and "cheese" are the same types of things. They are String-Types !
In fact string1 ◁ string2 is ALWAYS True, because any two strings are the same TYPE of thing. STRINGS.

https://repl.it/repls/UnderstatedNauticalNumerator

Code: Select all

``````class Object
def isTypeOf?(other)
return self.class == other.class
end
end

puts "cat".isTypeOf? "cheese"
=>true
``````
Or... since you are C++ person...

Code: Select all

``````#include <typeinfo>
#include <iostream>

bool isTypeOf(std::string a, std::string b) {
return typeid(a) == typeid(b);
};

int main(){
std::string cat = "cat";
std::string cheese = "cheese";
std::cout << isTypeOf(cat, cheese) << std::endl;
return 0;
}
➜  ~ c++ type.cpp -o type && ./type
1
``````
I am almost certain I am overlooking something trivial here, so I eagerly await your implementation of the isTypeOf() function.
I applaud your effort suggesting an excellent way for me to make my ideas perfectly concrete.
Your suggestion has spawned my creative process for replicating the functionality of Prolog as
applied to higher order logic defined entirely as stipulated relations between finite strings.

I showed how to define axioms in my prior reply to this message. By using the syntax of Prolog
I can define Facts (axioms) and Rules (rules of inference) as stipulated relations between
finite strings. I have not yet figured out how to adapt this syntax to specify higher order logic.

Since Prolog already defines FOL as stipulated relations between finite strings, the idea that
formal systems can be defined this way is already fully elaborated for FOL in Prolog.

Eodnhoj7
Posts: 5154
Joined: Mon Mar 13, 2017 3:18 am

### Re: Truth can be understood as math

PeteOlcott wrote:
Fri Aug 16, 2019 7:06 pm
Skepdick wrote:
Thu Aug 15, 2019 9:40 am
PeteOlcott wrote:
Thu Aug 15, 2019 5:26 am
I have ALWAYS only been talking about stipulated relations between finite strings.
It is becoming more and more obvious to me that you don't understand how type-systems actually work.
From your very own grammar definition ◁ means "isTypeOf". And it takes two strings as inputs.

But then cat ◁ cheese is True. Because both "cat" and "cheese" are the same types of things. They are String-Types !
In fact string1 ◁ string2 is ALWAYS True, because any two strings are the same TYPE of thing. STRINGS.

https://repl.it/repls/UnderstatedNauticalNumerator

Code: Select all

``````class Object
def isTypeOf?(other)
return self.class == other.class
end
end

puts "cat".isTypeOf? "cheese"
=>true
``````
Or... since you are C++ person...

Code: Select all

``````#include <typeinfo>
#include <iostream>

bool isTypeOf(std::string a, std::string b) {
return typeid(a) == typeid(b);
};

int main(){
std::string cat = "cat";
std::string cheese = "cheese";
std::cout << isTypeOf(cat, cheese) << std::endl;
return 0;
}
➜  ~ c++ type.cpp -o type && ./type
1
``````
I am almost certain I am overlooking something trivial here, so I eagerly await your implementation of the isTypeOf() function.
I applaud your effort suggesting an excellent way for me to make my ideas perfectly concrete.
Your suggestion has spawned my creative process for replicating the functionality of Prolog as
applied to higher order logic defined entirely as stipulated relations between finite strings.

I showed how to define axioms in my prior reply to this message. By using the syntax of Prolog
I can define Facts (axioms) and Rules (rules of inference) as stipulated relations between
finite strings. I have not yet figured out how to adapt this syntax to specify higher order logic.

Since Prolog already defines FOL as stipulated relations between finite strings, the idea that
formal systems can be defined this way is already fully elaborated for FOL in Prolog.
Actually, you haven't.

Facts and rules are subject to the same logic system you are observing.

A fact is a localization of some phenomena and as such exists as a context of rules.

For example: my shoe is black.

This is a localization of some aspect of empirical reality, and as such it exists as a finite continuum.

That locality of reality acts as a context for the reality that is composed of "my black shoe". The various components of the shoe, its intended purpose, price range, where it is worn, etc is defined by the context of the black shoe as mine...and it is a context dont kid yourself.

The fact exists, in these respects as a system of rules.

The rules on the other hand exist as facts.

"Thou shall not kill" is a fact within the context of certain belief systems as a commandment of divine principle and/or intuitive disposition. It exists as a reality that forms the psyche, where if this reality is negated certain consequences follow.

As to rules and facts....again you are assuming things.

PeteOlcott
Posts: 730
Joined: Mon Jul 25, 2016 6:55 pm

### Re: Truth can be understood as math

Eodnhoj7 wrote:
Fri Aug 16, 2019 9:56 pm
PeteOlcott wrote:
Fri Aug 16, 2019 7:06 pm

I applaud your effort suggesting an excellent way for me to make my ideas perfectly concrete.
Your suggestion has spawned my creative process for replicating the functionality of Prolog as
applied to higher order logic defined entirely as stipulated relations between finite strings.
Actually, you haven't.

Facts and rules are subject to the same logic system you are observing.

A fact is a localization of some phenomena and as such exists as a context of rules.
I was not responding to you, I was talking to Skepdick.
I was not talking about the English word "Fact" that corresponds to physical reality.
I was talking about the term of the art from Prolog: Fact meaning axiom

as it is applied to the body of conceptual knowledge comprised of analytic
sentences:
An analytic sentence is any sentence that can be verified as
completely true entirely on the basis of the meaning of its words.

Skepdick
Posts: 2086
Joined: Fri Jun 14, 2019 11:16 am

### Re: Truth can be understood as math

PeteOlcott wrote:
Fri Aug 16, 2019 7:06 pm
I applaud your effort suggesting an excellent way for me to make my ideas perfectly concrete.
Your suggestion has spawned my creative process for replicating the functionality of Prolog as
applied to higher order logic defined entirely as stipulated relations between finite strings.

I showed how to define axioms in my prior reply to this message. By using the syntax of Prolog
I can define Facts (axioms) and Rules (rules of inference) as stipulated relations between
finite strings. I have not yet figured out how to adapt this syntax to specify higher order logic.

Since Prolog already defines FOL as stipulated relations between finite strings, the idea that
formal systems can be defined this way is already fully elaborated for FOL in Prolog.
Everything you have said above boils down to expressive power.

What I am warning you against is the Turing tarpit.

Beware of the Turing tar-pit in which everything is possible but nothing of interest is easy.

In theory, everything you can do in C++ or Prolog - you can do in Brainfuck also.
The reason WHY you don't is very, very important. Human usability.

A language with rich vocabulary is very concise.
A language with poor vocabulary is very verbose.

A programming language like Mathematica has an exceptional vocabulary.
You can express incredibly complex ideas from broad domains of knowledge in a just a few lines of code.
A programming language like Brain fuck is the exact opposite of that.

Both Mathematica and Brainfuck are Turing-complete.

This exact property (expressivity) applies to logic also. FOL is atrocious! There is a reason Prolog is dead.
Worse - you are trying to retro-fit high-order logic on top of FOL. You are doing it backwards! Why?

Just start with a language that has been designed as a high-order logic from the start.

I urge you, advise you and encourage you to learn a high-level programming language. Start at the highest level of abstraction you can work your way to.

Python, Ruby, TypeScript, Julia - it doesn't matter. Just pick any language that uses dynamic typing!
Something that does not require the rigour and strictness of static typing like C++
Something that is almost as natural, expressive as intuitive as speaking English!

You are so used to having type safety in your programming languages that you are trying to shoehorn human knowledge into a strongly normalising type-safe system.

It's perfectionism at its worst. It's unnecessary. It's pure masochism. It's outright inhumane.

You remind me of me in my 20s. Trying to adapt the world to my brilliant design, rather than adapting my design to the world.

PeteOlcott
Posts: 730
Joined: Mon Jul 25, 2016 6:55 pm

### Re: Truth can be understood as math

Skepdick wrote:
Sat Aug 17, 2019 12:04 am
PeteOlcott wrote:
Fri Aug 16, 2019 7:06 pm
I applaud your effort suggesting an excellent way for me to make my ideas perfectly concrete.
Your suggestion has spawned my creative process for replicating the functionality of Prolog as
applied to higher order logic defined entirely as stipulated relations between finite strings.

I showed how to define axioms in my prior reply to this message. By using the syntax of Prolog
I can define Facts (axioms) and Rules (rules of inference) as stipulated relations between
finite strings. I have not yet figured out how to adapt this syntax to specify higher order logic.

Since Prolog already defines FOL as stipulated relations between finite strings, the idea that
formal systems can be defined this way is already fully elaborated for FOL in Prolog.
Everything you have said above boils down to expressive power.

What I am warning you against is the Turing tarpit.

Beware of the Turing tar-pit in which everything is possible but nothing of interest is easy.

In theory, everything you can do in C++ or Prolog - you can do in Brainfuck also.
The reason WHY you don't is very, very important. Human usability.

A language with rich vocabulary is very concise.
A language with poor vocabulary is very verbose.

A programming language like Mathematica has an exceptional vocabulary.
You can express incredibly complex ideas from broad domains of knowledge in a just a few lines of code.
A programming language like Brain fuck is the exact opposite of that.

Both Mathematica and Brainfuck are Turing-complete.

This exact property (expressivity) applies to logic also. FOL is atrocious! There is a reason Prolog is dead.
Worse - you are trying to retro-fit high-order logic on top of FOL. You are doing it backwards! Why?

Just start with a language that has been designed as a high-order logic from the start.

I urge you, advise you and encourage you to learn a high-level programming language. Start at the highest level of abstraction you can work your way to.

Python, Ruby, TypeScript, Julia - it doesn't matter. Just pick any language that uses dynamic typing!
Something that does not require the rigour and strictness of static typing like C++
Something that is almost as natural, expressive as intuitive as speaking English!

You are so used to having type safety in your programming languages that you are trying to shoehorn human knowledge into a strongly normalising type-safe system.

It's perfectionism at its worst. It's unnecessary. It's pure masochism. It's outright inhumane.

You remind me of me in my 20s. Trying to adapt the world to my brilliant design, rather than adapting my design to the world.
Like I said, C++ is expressive enough to create a fully functional human mind.
I am 64 and have two software engineering patents:
https://patents.justia.com/inventor/peter-l-olcott

wtf
Posts: 844
Joined: Tue Sep 08, 2015 11:36 pm

### Re: Truth can be understood as math

PeteOlcott wrote:
Sat Aug 17, 2019 12:45 am
Like I said, C++ is expressive enough to create a fully functional human mind.
Could not possibly, since programs do syntax, not meaning.
PeteOlcott wrote:
Sat Aug 17, 2019 12:45 am
I am 64 and have two software engineering patents:
https://patents.justia.com/inventor/peter-l-olcott
Of what relevance are those two facts? You could be 90 with 12 patents or 12 with 90 patents and your argument would be just as wrong.

But yeah it's cool that your age is a power of 2, if that was your point. Is that your point?

Eodnhoj7
Posts: 5154
Joined: Mon Mar 13, 2017 3:18 am

### Re: Truth can be understood as math

PeteOlcott wrote:
Fri Aug 16, 2019 11:33 pm
Eodnhoj7 wrote:
Fri Aug 16, 2019 9:56 pm
PeteOlcott wrote:
Fri Aug 16, 2019 7:06 pm

I applaud your effort suggesting an excellent way for me to make my ideas perfectly concrete.
Your suggestion has spawned my creative process for replicating the functionality of Prolog as
applied to higher order logic defined entirely as stipulated relations between finite strings.
Actually, you haven't.

Facts and rules are subject to the same logic system you are observing.

A fact is a localization of some phenomena and as such exists as a context of rules.
I was not responding to you, I was talking to Skepdick.
I was not talking about the English word "Fact" that corresponds to physical reality.
I was talking about the term of the art from Prolog: Fact meaning axiom

as it is applied to the body of conceptual knowledge comprised of analytic
sentences:
An analytic sentence is any sentence that can be verified as
completely true entirely on the basis of the meaning of its words.
[/quote

Then maybe you should PM him, this is a forum

So fact as an axiom is determined by an analytic sentence,
this analytic sentence is true based upon the meaning of its words,
The meaning of words, however, require a connection to empirical reality.

That is the problem, your premises are just randomly cut portions of reality glued to together with scotch tape and glitter until some bastardized interpretation is produced...throw in a "ta-da" and a pat on the back and that sums up your system.

It's just made up. You cannot define reality without relying on a continuum, and formal system that is not subject to change cannot continue.

### Who is online

Users browsing this forum: No registered users and 3 guests