ADEPT LION studies

[Alex Shkotin]

Greg,

I think it's better to keep a separate thread to discuss your IS which looks more and more ontological 🔬

Your table reminds me of "The concept of a universal relation (UR) was explored extensively by DBMS theoreticians in the early 1980s following an initial paper on the topic in 1982 by Jeff Ullman et. al. [1]." https://www.enterprisedb.com/blog/universal-relation-data-modelling-considered-harmful

Do you have a table description?

"the fixed schema" should not be necessarily one tabled.

Alyx column looks like a column with a complex value.

I think rendering this table and checking its consistency is a lot of coding.

Of course without description (including DB schema) your table is unreadable.

And it is nice to know you have a program to keep and handle your instances on the computer.

So, you have a KBMS. Welcome on board 🤝

Alex

[alex.shkotin]

END of previous thread https://groups.google.com/g/ontolog-forum/c/sdJ3GpvrxuA/m/fRdmjS8aAgAJ

среда, 12 февраля 2025 г. в 11:38:05 UTC+3, Alex Shkotin:

[gregsharp73]

Hi Alex,

Thanks for routing this conversation to the new thread.

I can certainly think of easier entry points for a thread on "ADEPT LION studies" than the data model but I'm happy to jump in with you there.  But for anyone wanting a more systematic approach, I would refer them to https://patternslanguage.com/

I would be curious to hear your thoughts before I bias you with my own experiences around optimization of this data model.

Given these requirements, what would you do?  (I will say that the lessons learned around the UR model are good insights here, but there are some important differences, as I'm sure will occur to you as you consider the following requirements.)

• OLTP support
• The type system is emergent from the patterns of referencing and therefore not a requirement of the DBMS aside from the handling of unique identifiers and the one content field that you noted (.ie int and string would do the trick, or something comparable in function).
• As a graph model, you have unique nodes, seven relationship types and one node property for the content field. Fixed.
• Alternatively as a relational database, you can have however many tables you want to represent the same, unique identities having seven relationship types, and one value.  Single table is one approach, A hash table for each relationship is another.... get as creative as you want.
• An API will serve up queries exclusively containing collections of the identifiers with their associated content (columns with ID references are all populated with user-readable content values).  The logic of these queries is all associated with the patterns of relationships of each tuple's relations or node's incoming edges and the count of these queries are finite in number.  This is the fixed schema and because these are all based in abstract patterns, they will never change regardless of the implementation.  There are no ad hoc or custom queries ever required of the data model. Estimate, at max around 300 possible views that can be materialized, but a functional application could work with around 50 views.
• Data is rarely deleted or edited. Primary access patterns are read and write.
• But the fixed schema is amenable to sharding either according to views on the schema, or not.  The query logic is the same for any shard or distributed data instance.  This allows for performance optimization techniques that might leverage extraction of any "subgraph".  These extractions may also be "reconciled" at any point in the future, which involves a merging of the unique identities that represent the same pattern in two different graphs.

Thanks for your thoughts, or of course, anyone else is welcome to throw their ideas at this problem too!  If you have thoughts about using existing DBMS vs. custom tailored design I'd love to hear pros and cons on that too.

Greg

[Alex Shkotin]

Greg,

We all here have our own favorite projects. For example my one (of ~5) is to formalize the Statistics part of classical mechanics. How to formalize theory you may read in (PDF) Theory framework - knowledge hub message #1. How to use formal theory for task solving is written here Specific tasks of Ugraphia on a particular structure (formulations, solutions, placement in the framework).

The other one is "Criticism of definitions encountered in practice from the point of view of ontology engineering" as announced here https://ontologforum.com/index.php/OntologySummit2025.

I hope to ask you from time to time about your project. 

For example I am still hope to get grammar or at list description of your linear language 🙂

For me if you have expressions like this "ꓱPhilosopher ⊇ ∂Person" you have one. 

Alex

чт, 13 февр. 2025 г. в 01:02, gregsharp73 <gregs...@gmail.com>:

--
All contributions to this forum are covered by an open-source license.
For information about the wiki, the license, and how to subscribe or
unsubscribe to the forum, see http://ontologforum.org/info
---
You received this message because you are subscribed to the Google Groups "ontolog-forum" group.
To unsubscribe from this group and stop receiving emails from it, send an email to ontolog-foru...@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/12f28e16-f7e9-4507-b8f1-15eb5a8f58ccn%40googlegroups.com.

[Alex Shkotin]

IN ADDITION. Let me add my  understanding of The power of natural language: every diagram and every data can be verbalized.

You give me a diagram, I ask you: how to read it (loudly after John Corcoran).

You give me data, I ask you: how to read it (loudly after John Corcoran).

Alex

чт, 13 февр. 2025 г. в 20:13, Alex Shkotin <alex.s...@gmail.com>:

[Gregory Sharp]

Alex,
A linear formal language encounters a contradiction or paradox and halts. A cyclic one moves in another direction. ADEPT lion is cyclic.
Greg

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/CAFxxRORgvte3w-UvbiR_qk0cnJCsY0aTB%3DPsL1y%2BGFKJGuz_LQ%40mail.gmail.com.

[Alex Shkotin]

Greg,

When I study an Information System, it may be yours, and found expression "ꓱPhilosopher ⊇ ∂Person" I am asking 

-What is it?

-do you have another one or this one is the only one possible in your system? You did not give an expression for the "wife" role in the relationship.

-What is a relationship of this expression with your diagrams and UR?

These are questions about your system, not about linear languages.

I have my own experimental linear language YAFOLL (PDF) Finite Systems Handling Language (YAFOLL message 1)

Usually the author is happy to give a short, precise answer. 

Ask me about YAFOLL🤣

Alex

пт, 14 февр. 2025 г. в 13:52, Gregory Sharp <gregs...@gmail.com>:

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/CAB5TTE7OAH4X%2B%3Dip5KY%3DUzkMu_8-fEEJaF3EU5z30Y1M7Q%2BpZw%40mail.gmail.com.

[Alex Shkotin]

Just FYI:

"17.02.2025, jointly with S.I. Adian seminar Alexei Miasnikov (Stevens Institute of Technology): First-order classification, non-standard models, and interpretations

In this talk I will focus on three things:

1. First-order classification: in particular, how one can describe ALL groups which are first-order equivalent to a given one.

2. Non-standard models of groups: in particular, I will describe non-standard models of the finitely generated groups with decidable or recursively enumerable (or arithmetic) word problems and explain how they naturally appear as non-standard Z-points of the general algebraic schemes.

3. Theory of interpretations: it seems a new rich theory is emerging right now. I will show several interesting results based on interpretations."

https://www.mathnet.ru/eng/conf876

Enjoy,

Alex

пт, 14 февр. 2025 г. в 13:52, Gregory Sharp <gregs...@gmail.com>:

Alex,

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/CAB5TTE7OAH4X%2B%3Dip5KY%3DUzkMu_8-fEEJaF3EU5z30Y1M7Q%2BpZw%40mail.gmail.com.

[Gregory Sharp]

ꓱPhilosopher ⊇ ∂Person is a label given to the central occasion of a 9 occasion pattern that follows the general form of a logical statement. This particular statement is analogous to an Aristotelian I-premise which can be rendered in English as "some person is a philosopher". The general form of a logical statement requires quantification of both of its terms and a copula. The copula here is called "predication". There are three other copulas. The concept philosopher is existentially quantified. The concept person is partially quantified. There are two other quantifiers used in the analogous Aristotelian system. They are universal and non-existential quantification. There are six additional quantifiers in pattern logic. The four copulas and ten quantifiers set the boundaries for pattern logic "proper" in the ADEPT LION "first consideration" which encapsulates the "grammar" of the broader pattern language. The second consideration is the vocabulary and the third consideration is the syntax.
From the standpoint of pattern logic, "wife" is a concept, or a non-logical term.
Greg

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/CAFxxROTsDwKekOKX9Or8aAYq_3hU1wCks8wgoY60i38dB3ejxg%40mail.gmail.com.

[Alex Shkotin]

I am happy to get that "ꓱPhilosopher ⊇ ∂Person" is a statement. And "some person is a philosopher" is its English form.

In the formal theory framework [1] your statement can be stored like this

eng:some person is a philosopher.

all:ꓱPhilosopher ⊇ ∂Person.

fol:ꓱx Person(x) ∧ Philosopher(x).

And we can look at English grammar here English grammar - Wikipedia.

We can look at FOL grammar here First-order logic - Wikipedia

I hope to read ADEPT LION language documents like Primer, Reference manual, etc this Summer.

What do you think?

Alex

[1] framework

example:

rus	Пусть e1, e2 - два ребра. e1 смежно e2 еите e1 и e2 являются различными и имеют общую концевую вершину.
eng	Let e1, e2 be two edges. e1 is adjacent to e2 if and only if e1 and e2 are different and have a common terminal vertex.
yfl	declaration adjacent func(TV edge edge) (e1 e2) ≝ {e1≠e2} (∃v:vertex enp(v e1) and enp(v e2))).

I would be happy to add a line tagged "all" for ADEPT LION language here.

пт, 14 февр. 2025 г. в 17:29, Gregory Sharp <gregs...@gmail.com>:

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/CAB5TTE4CcS-sn7wpbn2q55cD3HbMREsyjsOO-oczPrXusfjg6A%40mail.gmail.com.

[alex.shkotin]

In DL we have (if I am not mistaken):

dll:ꓱid(Person).ꓱPhilosopher

Alex

суббота, 15 февраля 2025 г. в 11:40:21 UTC+3, Alex Shkotin:

[alex.shkotin]

typo:

dll:ꓱid(Person).Philosopher

суббота, 15 февраля 2025 г. в 21:08:40 UTC+3, alex.shkotin:

[alex.shkotin]

In OWL2\FS we have:

ofs:ClassAssertion(ObjectIntersectionOf(Person Philosopher) _:x)

Alex

суббота, 15 февраля 2025 г. в 11:40:21 UTC+3, Alex Shkotin:

I am happy to get that "ꓱPhilosopher ⊇ ∂Person" is a statement. And "some person is a philosopher" is its English form.

[Alex Shkotin]

As you love quantifiers have a look at my approach (PDF) ∀∃λΣ metamorphoses. Generalizations, variations, algorithmic semantics

And there is more to say💥

Alex

пт, 14 февр. 2025 г. в 17:29, Gregory Sharp <gregs...@gmail.com>:

ꓱPhilosopher ⊇ ∂Person is a label given to the central occasion of a 9 occasion pattern that follows the general form of a logical statement. This particular statement is analogous to an Aristotelian I-premise which can be rendered in English as "some person is a philosopher". The general form of a logical statement requires quantification of both of its terms and a copula. The copula here is called "predication". There are three other copulas. The concept philosopher is existentially quantified. The concept person is partially quantified. There are two other quantifiers used in the analogous Aristotelian system. They are universal and non-existential quantification. There are six additional quantifiers in pattern logic. The four copulas and ten quantifiers set the boundaries for pattern logic "proper" in the ADEPT LION "first consideration" which encapsulates the "grammar" of the broader pattern language. The second consideration is the vocabulary and the third consideration is the syntax.

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/CAB5TTE4CcS-sn7wpbn2q55cD3HbMREsyjsOO-oczPrXusfjg6A%40mail.gmail.com.

[Alex Shkotin]

following https://patternslanguage.com/articles/f/unifying-logic-traditional-premises-and-classical-propositions 

"∃ person  isPhilosopher(¬person)"  is not from FOL💡

пт, 14 февр. 2025 г. в 17:29, Gregory Sharp <gregs...@gmail.com>:

ꓱPhilosopher ⊇ ∂Person is a label given to the central occasion of a 9 occasion pattern that follows the general form of a logical statement. This particular statement is analogous to an Aristotelian I-premise which can be rendered in English as "some person is a philosopher". The general form of a logical statement requires quantification of both of its terms and a copula. The copula here is called "predication". There are three other copulas. The concept philosopher is existentially quantified. The concept person is partially quantified. There are two other quantifiers used in the analogous Aristotelian system. They are universal and non-existential quantification. There are six additional quantifiers in pattern logic. The four copulas and ten quantifiers set the boundaries for pattern logic "proper" in the ADEPT LION "first consideration" which encapsulates the "grammar" of the broader pattern language. The second consideration is the vocabulary and the third consideration is the syntax.

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/CAB5TTE4CcS-sn7wpbn2q55cD3HbMREsyjsOO-oczPrXusfjg6A%40mail.gmail.com.

[alex.shkotin]

by the way " ∄Philosopher ⊇ ∂Person" [1] is not a FOL, but HOL like this

∃p:unary_predicate, ∃x:Person p≠Philosopher ∧ p(x)
[1] https://patternslanguage.com/articles/f/unifying-logic-traditional-premises-and-classical-propositions

пятница, 14 февраля 2025 г. в 17:29:39 UTC+3, Gregory Sharp:

[Alex Shkotin]

Just small Sunday's evening addition: If we put brackets we get this

(∄(Philosopher) ⊇ ∂(Person))

i.e. we have two unary modifiers (∄ ∂) of unary predicates (concepts) into something that can be modified by the binary operator ⊇ to create a proposition.

Very interesting.

вс, 16 февр. 2025 г. в 14:42, alex.shkotin <alex.s...@gmail.com>:

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/273e24d1-cc1b-4b6a-ab12-79ee08f8e8b9n%40googlegroups.com.

[gregsharp73]

The requested pattern logic primer can be found here: https://patternslanguage.com/pattern-logic

The subject of pattern logic is developed over several illustrated webpages and culminates in the topic of "decisions" which represents a novel theory of propositional truth grounded in the structure of interpreted patterns.  This expanded theory of truth encompasses both the typical truth values, as well as intermediate degrees of certainty and contradiction.

For a discussion of why a cyclic pattern language is an improvement over linear formal languages and offers an approach to making the meaning in natural language accessible to computation see the following article: https://patternslanguage.com/articles/f/a-cyclic-pattern-language

Thanks,

Greg

[John F Sowa]

Greg and Alex,

I agree that graph structures support algorithms that are more flexible than the typical operations with predicate calculus.  I also agree that it's important to support methods that deal with approximations or "fuzzy" kinds of truth values.  There has been a huge amount of theoretical and practical R & D 0n these issues in the past 50 years.

GS:  The subject of pattern logic is developed over several illustrated webpages and culminates in the topic of "decisions" which represents a novel theory of propositional truth grounded in the structure of interpreted patterns.  This expanded theory of truth encompasses both the typical truth values, as well as intermediate degrees of certainty and contradiction.

I don't know the details of your system, but from your notes, I believe that you have a more advanced system than the so-called ":semantic web stack" that is based on the 2005 "layer cake".   But as I have said many times, the "decidability gang" destroyed the vision and specifications in the winning proposal by Tim Berners-Lee in 2000.   The so-called "Semantic Web Stack" of 2005 was a pale shadow of what Tim B-L had proposed.

In 2003, another branch of the Federal Gov't saw that the Semantic Web was headed in the wrong direction, and they funded a much more advanced and more ambitious project  called IKRIS.   See https://jfsowa.com/ikl/ .   It was funded for two years (2004 to 2006) and it included some of the most advanced AI projects and researchers from industry and Academia.   Arun Majumdar and I were just two of the many researchers involved.  

Unfortunately, there were some cutbacks in gov't funding in 2005, and neither the IKRIS project nor the SW project were continued.   For a survey of developments from the late 1970s to 2011, see Semantics for Interoperable Systems, documents collected and related by John Sowa,  https://jfsowa.com/ikl/ .

You don't have to believe me.  I wrote the overview, but I include links to the original R & D articles by everybody I mention in the reviews.  I also have more reviews and publications, but this is enough for now.

John

 

---

From: "gregsharp73" <gregs...@gmail.com>

[Alex Shkotin]

Greg,

https://patternslanguage.com/pattern-logic is not a primer. Primer introduces language constructions step-by-step with examples of its usage. 

See OWL2 Primer.

Every diagrammatic language has at least one isomorphic linear language, i.e. serialization. 

serialization action: input is diagram, output is text.

diagramming action: input is text, output is diagram. By the way your table of instans is a way to serialize.

Some subtle guys differ in graphs and rendering. 

Any computer program is a graph see (PDF) Program structure.

See Existential Graphs, Conceptual Graphs, and ask John Sowa how to linearize diagrammatic language.

See RDF graphs, and Notation 3, or XML serialization.

Your introduction https://patternslanguage.com/articles/f/a-cyclic-pattern-language reminds me Peirce's Existential Graphs (JFS's tutorial), or Laws of Form i.e. any diagrammatic approach 🎯

It's a pity you don't use Context-Free Grammar technique.  Using CFG for diagrams would be exciting.

`Fax me a pizza` i.e. Primer.

Show usages, not thoughts 🏋️

Alex

чт, 20 февр. 2025 г. в 03:58, gregsharp73 <gregs...@gmail.com>:

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/42f70b3e-fd42-48ef-a4da-ed5c2248054dn%40googlegroups.com.

[Gregory Sharp]

We are not on the same page here Alex. I am not even sure what your thoughts above are trying to convey or what relevance any of that has to what I have said.  I have no interest in CFG, so maybe you can tell me why I should?  Or try to meet me where I am at rather than trying to cram my thoughts into your own?  Why are you so insistent on these absolute assumptions like "every diagrammatic language...; any computer program...l there is only one definition of primer or grammar?  What is your point!?

Greg

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/CAFxxRORpxeGd8ZssguTYOjrMGR%2B5JxES1RSXfPp%3D-y1qbXyfFA%40mail.gmail.com.

[John F Sowa]

Alex and Greg.

That is certainly true:

Alex:  Every diagrammatic language has at least one isomorphic linear language, i.e. serialization. 

In fact, everyting stored on a digital computer is linearized.  All storage devices consist of a huge bit string that is subdivided in linear  blocks.  

For any structure x stored on any computer device, all the blocks that contain parts of x  can be moved together into one continuous bit string.  That bit string would be totally unreadable by humans, but it is indeed linear.  The challenge is to find ways of organizing the linear string in a way that is easy to read and write by humans.

For some things, such as a photograph, no linearization would be humanly readable.   But computer displays can make those strings readable in a tiny fraction of a second.

John

 

---

From: "Alex Shkotin" <alex.s...@gmail.com>

Greg,

[Alex Shkotin]

Greg,

My point is math. And from time to time I have time to look at  your beautiful site.

For example for me at this page https://patternslanguage.com/limitation there are a lot formulas like this

"α ⊆ β ⊇ γ  ⊢ β ≈ α ∪ γ  ⊢  β ≈ γ ∪ α"

And I think: Oh, formal language! It should be CFG for it. Or maybe just a set of inductive definitions.

For operations it's interesting to know arity, type of arguments, and priority, as brackets can be omitted.

Or at this page https://patternslanguage.com/decision I see a diagram

and I think: Oh, labelled directed graph! It should be CFGs for labels and rules to label. Or maybe just a set of inductive definitions.

And the relationship between diagram and formula is intriguing.

Fantastic work done. It's my pleasure to ask you about your invention.

Alex  

чт, 20 февр. 2025 г. в 21:30, Gregory Sharp <gregs...@gmail.com>:

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/CAB5TTE65MXkhJZv1nUfC8JiKpaSf0wFiNaPC6xpCXA5NSPvLrA%40mail.gmail.com.

[Gregory Sharp]

Thank you for this resource John. There is a lot to review but I will dive in.

Greg

--

All contributions to this forum are covered by an open-source license.
For information about the wiki, the license, and how to subscribe or
unsubscribe to the forum, see http://ontologforum.org/info
---
You received this message because you are subscribed to the Google Groups "ontolog-forum" group.
To unsubscribe from this group and stop receiving emails from it, send an email to ontolog-foru...@googlegroups.com.

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/3804be3aff624c1f973cf0c0e85e3fff%400eecd40aac864636a1e49912b0ab6fe0.

[gregsharp73]

The history of IKRIS seems intertwined with that of the Semantic Web as John presents it.  I'm particularly interested in exploring the relationship between logical systems and their chosen native database or data serialization formats from the unifying perspective of a pattern language.  I believe this is relevant to the concern that too much expressivity was sacrificed in setting semantic web priorities in the name of preserving decidability and that it would be helpful to recover some of that lost capability. I also believe that Pattern Logic could pull together not only the RDF stack, but potentially even more customized knowledge modeling and logics, as I understand were used in Cyc.

Here is what I hope will be a discussion-starter along those lines: https://patternslanguage.com/articles/f/interpretations-of-rdf-in-the-adept-lion-third-consideration

This article discusses the displayed "pattern set", which is a blueprint for how to represent the syntactic structure of the RDF triple in patterns.  These patterns happen to be the same as the pattern set for a generic table within a relational database.  This overlap of patterns has implications for data interoperability.  Furthermore, these patterns of RDF triple or an data entry in a table, are interpretable in ten different ways in ADEPT LION and this provides a means of clarifying the meaning that is otherwise latent in the structure of the table or of the RDF graph.  

This is a rather advanced topic for ADEPT LION, but I hope it will be of interest to those familiar with the challenges of wrangling data and looking for some new handles by which to grab at data in ways that make the implicit meaning of data structures more explicit without altering the source.  Essentially sense-making at the data level.

[Alex Shkotin]

Greg,

What's a pity I don't understand this text and, unfortunately, I have to stop studying it while waiting for the description and the tutorial on the language of formulas.

Examples of formulas and even seem to be manipulation of formulas are:

1. d ⊇ (t ⊆ p) ⊇a {V ⊢}   (t ⊆ p) ≈ d ⊇a 

2. d ⊇((t ⊆p) ⊇a) { }  d ⊇((t ⊆p) ⊇a) 

3. (d ⊇(t ⊆p)) ⊇a { }   (d ⊇(t ⊆p)) ⊇a 

4. (d ⊇ t) ⊆(p ⊇a) { }   (d ⊇t) ⊆(p ⊇a) 

5. d ⊇(t ⊆(p ⊇a)) { }  d ⊇(t ⊆(p ⊇a)) 

6. ((d ⊇t) ⊆p) ⊇a { }   ((d ⊇t) ⊆p) ⊇a 

7.  d ⊇t ⊆(p ⊇a)  {VIII ⊢}  t ≈ d ∩ (p ⊇a) 

8.  (d ⊇t ⊆p) ⊇a  {VIII ⊢}   (t ≈ d ∩ p) ⊇a 

9. (d ⊇t) ⊆p ⊇a  {VII ⊢}  p ≈ (d ⊇ t) ∪ a 

10.  d ⊇(t ⊆p ⊇a)  {VII ⊢}  d ⊇(p ≈ t ∪ a)

What I got so far is:

-d t p a are terms.

-⊇ ⊆ ≈ are binary infix operations.

-in some cases brackets are needed or priority of operations:

(t ⊆ p) ≈ d ⊇a

d ⊇t ⊆(p ⊇a)

t ≈ d ∩ (p ⊇a)

etc.

And to understand a language it is customary to describe a language. Of course, it is not necessary to use CFG. The other day I'll give an example of how Barwise defines the FOL family of languages "mathematically".

I am waiting when this comes true:

∃d:Document Reference_Manual(ADEPT_LION.formulas d) ∨ Tutorial(ADEPT_LION.formulas d)).

Where Reference_Manual and Tutorial are binary predicates of type (Language Document):Boolean.

Best regards,

Alex

сб, 22 февр. 2025 г. в 05:02, gregsharp73 <gregs...@gmail.com>:

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/c54b717b-b8c6-46ae-9cfe-504d4f32443bn%40googlegroups.com.

[gregsharp73]

Hi Alex,

You got me.  Those are formulas.  They represent ten different means of interpreting a particular type (called SEL\\\) of occasion (these are the nodes in the graph). Fortunately, I did provide English renderings of those formulas further along in the article, so I hope that is of some consolation to you.  

Of greater interest in that article however is that they are a structural embodiment of any RDF triple or any entry in a table. And they have a diversity of nuanced meaning that gets to a prominent point of discussion in John and Pat's Interlingua thread: how can we establish a common logic that doesn't have to sacrifice the nuance of natural language in order to be useful when it comes to questions of interoperability?

And, you are correct about the parentheses indicating priority of operations (see section entitled "The problem of the Parentheses" here... https://patternslanguage.com/interpretation-1)

But "d t p a" are not terms.  If you are looking for where logical terms show up in the pattern language, I would suggest starting here:  https://patternslanguage.com/modality-1.  As it states at the top of that page, "Every logical term is built upon a concept. A concept is a monadic occasion, that can have one of four patterns.  The interpretations of these four patterns correspond to the alethic modalities of possible, impossible, necessary and contingent."

"d t p a" are called ontological constructs.  And forgive me for not pointing this out earlier, but there is a page linked from the site that goes into a "deeper dive" off of the "classification" page and this is where you will find the technical definitions of the ontological constructs and what you may think of as the "type system" of the ADEPT LION pattern language. Here is the direct link to that page: https://patternslanguage.com/constructs .  Pay particular attention to the slide shows which first unpack the terminology and then visualize how this terminology is grounded in explicit pattern structures.

Perhaps this is the level of detail you seek?  Just realize that the symbols are simply alternate expressions of the only thing that matters in ADEPT LION when it comes to establishing meaning:  the pattern of inputs for any occasion in the graph.  And all of this "pattern" boils down to one operator, which yes, you may express, if you like, as a binary infix operator but which is really only an expression of the graph's structure.  This is a key point.  These are not formulas to manipulate, they are merely reflections of embodied structure in a graph.  

FYI, according to Law X (see https://patternslanguage.com/limitation for all ten laws) "⊇" "⊆"  are two ways of representing the same pattern.  The first is called limitation and the second is called counter-limitation but because a pattern has no default orientation, you can think of them like reading the same sentence forwards or backwards but arriving at the same idea regardless of where you start.

If after reviewing the ontological constructs, you still believe that there is a way of expressing this as a CFG, I'd be happy to set up a time to work that up together.

Thanks,
Greg

[Alex Shkotin]

Greg,

We have a step forward, and keep in mind that my time to study your approach is mainly weekends. If new questions arise, I will immediately issue them.

Alex

пн, 24 февр. 2025 г. в 02:58, gregsharp73 <gregs...@gmail.com>:

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/1ec8ef47-0e6a-496e-a973-e774c8196835n%40googlegroups.com.

[Alex Shkotin]

I hope this is a right thread 

Greg,

Nowadays it is common practice to start describing a language by indicating its alphabet, the letters and symbols that are allowed to be used in it.

Usually, a small part of Unicode is enough for everyone.

For example, in YAFOLL we have [1]

What is the alphabet of your formulas? What characters can be used there?

Of course you do not need Flex definitions, if you don't use Flex to create a scanner.

Alex

[1]Finite Systems Handling Language.v.X.0 (YAFOLL)(-:PUBLIC:-)

Alphabet

We use [Flex] Regular Expression notation in the task for a lexical analyzer (aka scanner), which can be considered as a type of formalization to UTF-8.

The basis of the alphabet is made up of lowercase and uppercase Russian and Latin letters. Let us denote these sets RSL, RCL, LSL, LCL.

Flex:

RSL "\xd1\x91"|("\xd0"([\xb0-\xbf]))|("\xd1"([\x80-\x8f]))

RCL "\xd0\x81"|("\xd0"([\x90-\xaf]))

LSL [qwertyuiopasdfghjklzxcvbnm]

LCL [QWERTYUIOPASDFGHJKLZXCVBNM]

Of course, the language has Arabic numerals that are divided into two subsets: the zero itself is separated into a separate one.

Flex:

DIGI   [1-9]

ZERO [0]

We use the underscore character "_", denoted US, to create special "identifiers", and double quotes ("), denoted DG, to enclose strings. For simplicity, it is done so that there should be no double quotes in the string itself.

Flex:

US [_]

DQ "\x22"

Many common characters are legal in the language and have the following names.

These characters are: .- ,:(){}!?=<>+*/%#

Names see in flex-notation.

Flex:

DOT     [.]

MI [-]

ws [ ]

COMMA [,]

COLON [:]

l_p [(]

r_p [)]

l_cb [{]

r_cb [}]

e_m [!]

q_m [?]

EQ [=]

LT [<]

GT [>]

PL [+]

ST [*]

DI [/]

PCT [%]

COUNT [#]

TAB "\x09"

EOL "\x0A"

CR "\x0D"

The last three and a space (ws) are classical separators.

Last group of characters keeps more exotic beginning from BOM (Byte Order Mark) and continue with various mostly logical math symbols:

∃ ∀ Σ ↓ ¬ ∧ ∨ → ≡ ≠ ≤ ≥

Flex:

BOM "\xEF\xBB\xBF"

EXISTS "\xE2\x88\x83"

FOR_ANY "\xE2\x88\x80"

SUM "\xE2\x88\x91"

RED "\xE2\x86\x93"

NOT "\xc2\xac"

AND "\xe2\x88\xa7"

OR "\xe2\x88\xa8"

IMPLIES "\xe2\x86\x92"

EQUIV "\xe2\x89\xa1"

Neq "\xe2\x89\xa0"

Leq "\xe2\x89\xa4"

Geq "\xe2\x89\xa5"

It is usual to group characters a little bit further. Lttr keeps all letters, DIGIT - all digits, QUANT - all quantifiers, and FIX keeps all special operations we have.

Flex:

Lttr {LCL}|{LSL}|{RCL}|{RSL}

DIGIT  {DIGI}|{ZERO}

QUANT {FOR_ANY}|{EXISTS}|{COUNT}|{SUM}|{RED}

FIX {NOT}|{AND}|{OR}|{IMPLIES}|{EQUIV}|{Neq}|{Leq}|{Geq}|{EQ}|{LT}|{GT}|{PL}|{MI}|{ST}|{DI}

These are all significant characters and groupings we have.

It should be mentioned in advance that in Comment and String token any Unicode character is possible, but in String one DG is forbidden.

чт, 20 февр. 2025 г. в 21:30, Gregory Sharp <gregs...@gmail.com>:

We are not on the same page here Alex. I am not even sure what your thoughts above are trying to convey or what relevance any of that has to what I have said.  I have no interest in CFG, so maybe you can tell me why I should?  Or try to meet me where I am at rather than trying to cram my thoughts into your own?  Why are you so insistent on these absolute assumptions like "every diagrammatic language...; any computer program...l there is only one definition of primer or grammar?  What is your point!?

Greg

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/CAB5TTE65MXkhJZv1nUfC8JiKpaSf0wFiNaPC6xpCXA5NSPvLrA%40mail.gmail.com.

[alex.shkotin]

Just extraction of funny characters used by YAFOLL:

Many common characters are legal in the language.

These characters are: .- ,:(){}!?=<>+*/%#

...

Last group of characters keeps more exotic beginning from BOM (Byte Order Mark) and continue with various mostly logical math symbols:
∃ ∀ Σ ↓ ¬ ∧ ∨ → ≡ ≠ ≤ ≥

When we are talking about characters the Reference Manual is https://home.unicode.org/

Alex

вторник, 25 февраля 2025 г. в 13:55:57 UTC+3, Alex Shkotin:

[John F Sowa]

Alex,

The best possible character set for an official standard is the empty set -- zero characters of any kind.  And a formal definition should also be independent of the dimensions (1, 2, 3, 4 ...).

That is the strategy for the abstract definition of the ISO standard for Common Logic:  purely formal with no implicit preference for any choice of symbols, or notation or even dimension..  But the standard also includes three concrete versions, each with very different representations,  

The abstract definition is also the shortest and simplest, and it has no distracting details that depend on the notation.  The three concrete syntaxes are more complicated and harder to read than the short and simple formal specification.

Just look at all the wasted space in your definition of the character set below.   Those details are important for an implementation, but they're not helpful for understanding the basic principles.

John

 

---

From: "alex.shkotin" <alex.s...@gmail.com>

[Alex Shkotin]

John,

It was a good step forward that we agree with Greg that he has a kind of language (see upper).

Next request is the ABC of this language. My ABC of YAFOLL is just an example.

This is absolutely practical request as I try to study ADEPT LION. As you see in the title of this thread.

Alex

вт, 25 февр. 2025 г. в 18:37, John F Sowa <so...@bestweb.net>:

--

All contributions to this forum are covered by an open-source license.
For information about the wiki, the license, and how to subscribe or
unsubscribe to the forum, see http://ontologforum.org/info
---
You received this message because you are subscribed to the Google Groups "ontolog-forum" group.
To unsubscribe from this group and stop receiving emails from it, send an email to ontolog-foru...@googlegroups.com.

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/592ff63a3c864f1f952432c76d19589e%40816b2c24a312443a87b58bf2d2b06d70.

[Alex Shkotin]

IN ADDITION: https://www.linkedin.com/pulse/jon-barwise-formalises-fol-alex-shkotin-nwtwe

вт, 25 февр. 2025 г. в 13:55, Alex Shkotin <alex.s...@gmail.com>:

[alex.shkotin]

John,

It is also worth keeping in mind that the document Finite Systems Handling Language.v.X.0 (YAFOLL)(-:PUBLIC:-) is technical and contains not only a full description of the language but also a description of the implementation. Flex and Bison were used. Although now I would do it using Antlr.

Maybe Greg will think of making an interpreter or some other kind of formula processing.

Alex

вторник, 25 февраля 2025 г. в 18:37:54 UTC+3, John F Sowa:

[Gregory Sharp]

I have updated the last entries in the glossary to include a more concise listing of the "alphabet" for ADEPT LION rivulet (functional pattern types) and trickle (distinguishable pattern types) notations along with explanatory diagrams which I will attach below.

The glossary is here: https://patternslanguage.com/glossary 

The character set is [A, B, D, E, G, H, L, M, O, P, S, T, -, *, /, +, |, =]. 

Please be aware that the meaning of these symbols has nothing to do with what you think they mean.  They are indicative of an occasion of pattern's connections to other occasions. These connections are the basis of the type system and these characters are simply a means of notating the connections. You should think of the letters as metaphorical for connection types and the punctuation as more like ASCII art describing a graph's structure than the alphabet of a linear language.

--

All contributions to this forum are covered by an open-source license.
For information about the wiki, the license, and how to subscribe or
unsubscribe to the forum, see http://ontologforum.org/info
---
You received this message because you are subscribed to the Google Groups "ontolog-forum" group.
To unsubscribe from this group and stop receiving emails from it, send an email to ontolog-foru...@googlegroups.com.

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/7495b961-d5c9-4e37-ba33-52d0dbeddc40n%40googlegroups.com.

[Alex Shkotin]

Greg,

I am happy to see your alphabet. And it looks for me you have more than one language, or maybe sub-languages:

-to label nodes

-to label arcs

etc.

But I asked you for the alphabet for your formulas.

And let me clarify that we use the alphabet to define some permissible, usable strings of these characters called lexemes.

To define these sequences of char we use notation of Regular Expressions of one or another kind.

This is where Flex was used for YAFOLL and we have definitions like this

Identifiers

Class Id dedicated for naming anything we can (see Grammar rules) and consist of two not intersecting sets:

FIX - class of special characters used in math for operations. For example ∧ is usual sign (identifier) for AND logical operation, etc.

Classical style identifier: it must begin from a letter which can be followed by a sequence of letters, digits and "_". 

Flex:

Id {FIX}|{Lttr}({Lttr}|{DIGIT}|{US})*

For example, the following Y!L sentences introduce two identifiers for sorts: sample and place.

Declaration sample sort.

Declaration place sort.

So your nice ABC#1: [A, B, D, E, G, H, L, M, O, P, S, T, -, *, /, +, |, =]

maybe useful for labels of your diagrams but I can't create lexemes for  

" ∄Philosopher ⊇ ∂Person"

where for me "Philosopher" and "Person" are lexemes of Id class.

So if ABC#1 is your alphabet what classes of lexemes do you have?

See [1] for the list of all lex-classes we have in YAFOLL. 

Let me recall that Flex creates a scanner program which gets as input a sequence of characters from our ABC, and returns a sequence of lexemes of our language.

Alex

[1] Finite Systems Handling Language.v.X.0 (YAFOLL)(-:PUBLIC:-) (Flex notation)

for reference. List of lexical non-terminals

Just a copy-paste from SA-specification

%token QUANT

%token DOT

%token COMMA

%token COLON

%token l_p

%token r_p

%token l_cb

%token r_cb

%token e_m

%token q_m

%token DECLARATION

%token PRIME

%token DEFINITION

%token FINSET

%token FINSEQ

%token FUNC

%token TYPE

%token Id

%token Ide

%token Number

%token String

%token Natural

Definitions of every of these non-terminal can be found in the upper text.

ср, 26 февр. 2025 г. в 19:40, Gregory Sharp <gregs...@gmail.com>:

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/CAB5TTE4Jh8C9_s_6tcAbVU9O31ejoqy%3D9rVNP30omvZnZuam%2Bg%40mail.gmail.com.

[alex.shkotin]

Greg,

To be more precise let me add, that actually scanner returns every lexeme with it class like this:

INPUT:"Declaration sample sort."

OUTPUT:"Declaration":DECLARATION sample:Id "sort":SORT ".":DOT

Where every lexeme has its class assigned.

Alex

четверг, 27 февраля 2025 г. в 15:51:06 UTC+3, Alex Shkotin:

[alex.shkotin]

Greg,

You have interesting sophisticated objects and processing. Have a look at Jon Awbrey project https://inquiryintoinquiry.com/2025/03/01/cactus-language-overview-1/ with another one.

Alex

среда, 26 февраля 2025 г. в 19:41:00 UTC+3, Gregory Sharp:

[Alex Shkotin]

Greg,

I remembered one of my works that might be interesting because it uses CFG and graphs. For example:

Enjoy here (PDF) Graph representation of context-free grammars 

Alex

ср, 26 февр. 2025 г. в 19:40, Gregory Sharp <gregs...@gmail.com>:

I have updated the last entries in the glossary to include a more concise listing of the "alphabet" for ADEPT LION rivulet (functional pattern types) and trickle (distinguishable pattern types) notations along with explanatory diagrams which I will attach below.

To view this discussion visit https://groups.google.com/d/msgid/ontolog-forum/CAB5TTE4Jh8C9_s_6tcAbVU9O31ejoqy%3D9rVNP30omvZnZuam%2Bg%40mail.gmail.com.