Philosophy Now Forum

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.

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.

This causes a paradox.

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

PeteOlcott wrote: ↑Thu Aug 15, 2019 5:26 am I have ALWAYS only been talking about stipulated relations between finite strings.

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

puts "cat".isTypeOf? "cheese"
=>true

#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

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.

This causes a paradox.

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 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.

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

PeteOlcott wrote: ↑Thu Aug 15, 2019 5:10 pm Apparently my IP address has been blocked.

PeteOlcott wrote: I can only reply on my phone so this reply will be terse. Apparently my IP address has been blocked.

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.

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.

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.

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.

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.

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.

PeteOlcott wrote: ↑Sat Aug 17, 2019 12:45 am Like I said, C++ is expressive enough to create a fully functional human mind.

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

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.