From: Thomas Walker Lynch Date: Wed, 14 Jan 2026 14:30:28 +0000 (+0000) Subject: doc development X-Git-Url: https://git.reasoningtechnology.com/?a=commitdiff_plain;h=4fe40f0eb8a22ce49f9846d4665c91c100639fa3;p=Epimetheus%2F.git doc development --- diff --git a/developer/document/Epimetheus.html b/developer/document/Epimetheus.html index ea2c834..07e122f 100644 --- a/developer/document/Epimetheus.html +++ b/developer/document/Epimetheus.html @@ -12,117 +12,181 @@ + +

What is it

+ + +

Epimetheus is a Python library for Higher Order Analysis and Semantic Annotation. A computer scientists might say it is a mechanism for Late Binding of ontology, while a programmer will call it a type system.

+ +

Unlike Prometheus (Forethought), who defines what an object /is/ before it is born (classic class instantiation), Epimetheus allows you to attach meaning, identity, and semantic types to objects /after/ they exist.

+ +

Assumptions and Terms

Given

The English language is a given, apparently.

The English language is a given, apparently. Though once we have English, it seems a lot of the rest of this is moot. +

+ The code related to this discussion is implemented in Python, however issues with other languages are considered. On salient difference that is considered is that Python integers are bignums are passed by reference. In some other languages integers are considered primitives, are bounded and bit copied. +

+ +

Symbol

+ +

Instance

+ +

+ We are given a symbol instance factory. Each time the make function on the factory interface is called, the factory returns an instance of a distinct symbol. +

+ +

+ A symbol instance may be copied. A common method for making a copy in many languages is to use assignment, e.g., x = y, where y is a variable holding a symbol instance. After execution of the assignment, x will hold another instance of the same symbol. (Note that in Python an assignment will copy a reference, and the symbol itself will not be copied.) +

+ +

+ Any two, or by transitivity, any number of, symbol instances can be compared for equality, say x == y. A comparison between symbol instances will always return True or False. +

+ +

+ A symbol instance newly minted using the given symbol factory make function is said to come direct from the factory. Such a symbol is also called an original. +

+ +

Required Properties

+ +

+ Equality over symbol instances is an equivalence relation: x == x is True; x == y implies y == x; and if x == y and y == z then x == z. +

+ +

+ Any two symbol instances returned directly from the factory using two different make calls will always equality compare to be False. In other words, two distinct originals will always be not equal. +

+ +

+ Given an original, all copies stemming from it will be equal to each other and to the original. By stemming we mean to include all direct copies and copies of copies. +

- This discussion happens to appear in the context of a Python language - implementation, though it applies equally as well to other languages. + Given any two originals, say A and B, we know that A is not equal to B, as discussed above. Note also that A is not equal to any copy stemming from B, and B is not equal to any copy stemming from A.

Symbol

Definition

- We have a symbol instance factory. Each time the make - method on the factory is called, the factory returns an instance of a - distinct symbol. + Though symbol instances are integer-like in that copy and equality compare can be used with them, symbol instances are disallowed from being used with other integer operators. Symbols cannot be compared for greater-than or less-than; they cannot be incremented, added, nor subtracted, etc.

In shock

+ +

What is a Symbol?

- A symbol instance may be copied as though it were an integer. Thus, a - common method for making a copy is assignment, e.g., - x = y, where y is a variable holding - a symbol instance. After execution of the assignment, x - will hold another instance of the symbol. + Only symbol instances exist at runtime, so a symbol is never manipulated directly.

- Any two, or by transitivity, any number of, symbol instances can be - compared for equality using an integer equality comparison: - x == y. A comparison between symbol-holding variables + Define a relation ~ over instances by x ~ y iff x == y. Since == is an equivalence relation, this partitions instances into equivalence classes. Each such equivalence class is a symbol. +

+ +

+ The factoryâs make returns an original instance that is not equal to any other original. All copies stemming from an original remain in the same equivalence class. Therefore any instance in the class can represent the symbol, and we may choose any one instance as the symbolâs name (a canonical representative), or we could use a dictionary, and use, say, the original instance, to lookup a string as a name. +

+ +

Symbol

+ +

Instance

+ +

+ We are given a symbol instance factory. Each time the make function on the factory interface is called, the factory returns an instance of a distinct symbol. +

+ +

+ A symbol instance may be copied. A common method for + making a copy in many languages is to use assignment, e.g., + x = y, where y is a variable holding a symbol instance. After execution of the assignment, x will hold another instance of the same symbol. However in Python an + assignment will copy a reference, and the symbol itself will not be copied. +

+ +

+ Any two, or by transitivity, any number of, symbol instances can be compared for equality, say + x == y. A comparison between symbol instances will always return True or False.

- It follows that any two symbol instances directly returned from the - factory will always equality compare to be False. + A symbol instance newly minted using the given symbol factory make function is said to come direct from the factory. Such a symbol is also called an original.

Required Properties

- An equivalence set of symbol instances is a functional representation of - the symbol. The name of this set is yet another instance of said symbol. - Thus, every instance of the symbol represents the symbol. + Any two symbol instances returned directly from the factory using two different make calls will always equality compare to be False. In other words, two distinct originals will always be not equal.

- Though symbol instances are integer-like for copy and equality compare, - they are disallowed from being used with other integer operators. - Symbols cannot be compared for greater-than or less-than; they cannot be - incremented, added, nor subtracted, etc. + Given an original, all copies stemming from it will be equal to each other and to the original. By stemming we mean to include all direct copies and copies of copies.

Distinctness Across Contexts

- If a symbol persists across contexts, such as across scopes or processes, - it must remain distinct from all other symbols as it enters into those - new processes or contexts. + Given any two originals, say A and B, we know that A is not equal to B, as discussed above. Note also that A is not equal to any copy stemming from B, and B is not equal to any copy stemming from A. +

+ +

+ Though symbol instances are integer-like in that copy and equality compare can be used with them, symbol instances are disallowed from being used with other integer operators. Symbols cannot be compared for greater-than or less-than; they cannot be incremented, added, nor subtracted, etc. +

+ + +

What is a Symbol

+ +

+ A symbol is not manipulated directly. Only symbol instances exist at runtime. +

+ +

+ Define a relation ~ over instances by x ~ y iff x == y. This partitions instances into equivalence classes. Each such equivalence class is a symbol. +

+ +

+ + +

Distinctness Across Contexts

+ If a symbol persists across contexts, such as across scopes or processes, it must remain distinct from all other symbols as it enters into those new processes or contexts.

- In this implementation, we meet this constraint by using a global symbol - factory and by explicitly disallowing a symbol from being used outside - the process it was made in. + In this implementation, we meet this constraint by using a global symbol factory and by explicitly disallowing a symbol from being used outside the process it was made in.

Object

Definition

Object

Definition

- The term "Python object" refers to anything that can or could - appear in Python code and could be associated with a symbol. This - includes symbols themselves. + The term "Python object" refers to anything that can or could appear in Python code and could be associated with a symbol. This includes symbols themselves.

- A symbol is associated with an object using a Python dictionary. The - symbol is the key, and the object is that thing which is "looked up" - via said key. + A symbol is associated with an object using a Python dictionary. The symbol is the key, and the object is that thing which is "looked up" via said key.

Path

Individual Path

Path

Individual Path

- In the TTCA, we provided a formal definition for a "tape." A tape has a - leftmost cell, one or more "in-between" cells, and a rightmost cell. - A "path" is a special case of a tape with additional constraints. + In the TTCA, we provided a formal definition for a "tape." A tape has a leftmost cell, one or more "in-between" cells, and a rightmost cell. A "path" is a special case of a tape with additional constraints.

Each cell of a path holds a symbol. The leftmost cell is called the - destination. The reader might have expected the path - to go from left to right, but such a definition would run into a problem, - as left-to-right traversal might not ever end. + destination. The reader might have expected the path to go from left to right, but such a definition would run into a problem, as left-to-right traversal might not ever end.

- Think about it this way: you are sitting in a pub of an inn, and a - stranger walks in. Though you know the stranger's current destination, - you might not know where he came from. + Think about it this way: you are sitting in a pub of an inn, and a stranger walks in. Though you know the stranger's current destination, you might not know where he came from.

- All cells of the path to the right of the destination cell are called - "the way." If we were to drop the leftmost cell from the tape, then we - would find "the way," if it exists, to be another tape. + All cells of the path to the right of the destination cell are called "the way." If we were to drop the leftmost cell from the tape, then we would find "the way," if it exists, to be another tape.

Discrete Function

- Consider another tape where each cell holds a path. If we compare all - paths on said tape and find that no two identical "ways" lead to - different destinations, we call said tape a discrete function. + Consider another tape where each cell holds a path. If we compare all paths on said tape and find that no two identical "ways" lead to different destinations, we call said tape a discrete function.

@@ -130,8 +194,7 @@

- This notation is possible because the same way always leads to the given - destination. + This notation is possible because the same way always leads to the given destination.

diff --git a/developer/document/style/Rubio.js b/developer/document/style/Rubio.js new file mode 100644 index 0000000..cd21a5a --- /dev/null +++ b/developer/document/style/Rubio.js @@ -0,0 +1,15 @@ +/* Style: The "State Department" Override + Description: Restores decorum. +*/ +(function(){ + const RT = window.StyleRT || {}; + + // Force the font regardless of other settings + RT.rubio = function() { + const articles = document.querySelectorAll("rt-article"); + articles.forEach(el => { + el.style.fontFamily = '"Times New Roman", "Times", serif'; + el.style.letterSpacing = "0px"; // No modern spacing allowed + }); + }; +})(); diff --git a/developer/document/style/custom_tag.txt b/developer/document/style/custom_tag.txt new file mode 100644 index 0000000..146d3ad --- /dev/null +++ b/developer/document/style/custom_tag.txt @@ -0,0 +1,8 @@ + : The root container. + : The page wrapper. + + + + + : For Conventional terms (standard definitions) +: Terms introduced in this article diff --git a/developer/document/style/style_orchestrator.js b/developer/document/style/style_orchestrator.js index 8850fdc..a076d4a 100644 --- a/developer/document/style/style_orchestrator.js +++ b/developer/document/style/style_orchestrator.js @@ -10,7 +10,7 @@ window.StyleRT.style_orchestrator = function() { const modules = [ // Theme & Semantics - 'style/theme_light_gold.js', + 'style/theme_dark_gold.js', 'style/RT_term.js', 'style/RT_math.js', 'style/RT_code.js', diff --git a/developer/document/style/test_0.c b/developer/document/style/test_0.c deleted file mode 100644 index 1c7cadc..0000000 --- a/developer/document/style/test_0.c +++ /dev/null @@ -1,8 +0,0 @@ -// test_0_in.c -void func(int a,int b){ - if(check(a,b)){ - for(int i=0; i<10; i++){ - if(i==0) return; - } - } -} diff --git a/developer/document/test.html b/developer/document/test.html index cb87322..5eca533 100644 --- a/developer/document/test.html +++ b/developer/document/test.html @@ -23,16 +23,16 @@

Symbol

Definition

x - We have a symbol instance factory. Each time the make - method is called, we get a unique identity i. + We have a symbol instance factory. Each time the make + method is called, we get a unique identity i. A symbol instance may be copied as though it were an integer. Thus, a common method for making a copy is assignment:

- + x = y # y is a variable holding a symbol instance - +

1. A symbol instance may be copied as though it were an integer. @@ -75,18 +75,18 @@ x = y

Topologically it gives us a satisfying feeling that a given 'way' never leads to different destinations.

A common notation for a function is:

- + destination = f(way) - +

Because the same way always leads to the given destination, we can represent the mapping as follows:

- + def resolve_path(way): return hypergraph.lookup(way) - +