Theme One • A Program Of Inquiry

[Jon Awbrey]

Ontologgers,

As an alternative to piling generalities on generalities,
not that there's anything wrong with that, it also helps
to look at issues as they arise in concrete applications.

One of the most concrete applications I ever attempted was
the program I worked on all through the 80s that sought to
integrate a basic form of inductive (data-driven) learning with
a fundamental form of deductive (concept-driven) reasoning.
Having recently begun a fresh attempt to essay all that on
my blog I think it might serve our ends to share that here.

Survey of Theme One Program • 2
http://inquiryintoinquiry.com/2018/02/25/survey-of-theme-one-program-%e2%80%a2-2/

This is a Survey ( http://inquiryintoinquiry.com/surveys/ )
of previous blog and wiki posts on the Theme One Program that
I developed all through the 1980s.  The aim of the project was
to develop fundamental algorithms and data structures to support
an integrated learning and reasoning interface, looking toward the
design of an Automated Research Tool (ART) that could do double duty
as a medium for Inquiry Driven Education (IDE).  I wrote up a running
pilot version of the program well enough to get a Master's degree out of
it, but I'm still getting around to writing up the complete documentation.

Wiki Hub
========

* Theme One Program
( http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program )

Documentation in Progress
=========================

* Theme One Program • Pascal Source Code
( https://www.academia.edu/5210987/Theme_One_Program_Pascal_Source_Code )

* Theme One Program • User Guide
( https://www.academia.edu/5211369/Theme_One_Program_User_Guide )

* Theme One Program • Exposition
( http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition )

Applications
============

* Applications of a Propositional Calculator : Constraint Satisfaction Problems
( https://www.academia.edu/4727842/Applications_of_a_Propositional_Calculator_Constraint_Satisfaction_Problems )

* Exploratory Qualitative Analysis of Sequential Observation Data
( http://intersci.ss.uci.edu/wiki/index.php/Exploratory_Qualitative_Analysis_of_Sequential_Observation_Data )

References
==========

* Awbrey, S.M., and Awbrey, J.L. (May 1991),
“An Architecture for Inquiry : Building Computer Platforms for Discovery”,
Proceedings of the Eighth International Conference on Technology and Education,
Toronto, Canada, pp. 874–875.
( https://www.academia.edu/1270327/An_Architecture_for_Inquiry_Building_Computer_Platforms_for_Discovery ) .

* Awbrey, J.L., and Awbrey, S.M. (January 1991),
“Exploring Research Data Interactively : Developing a Computer Architecture for Inquiry”,
Poster presented at the Annual Sigma Xi Research Forum, University of Texas Medical Branch,
Galveston, TX.

* Awbrey, J.L., and Awbrey, S.M. (August 1990),
“Exploring Research Data Interactively • Theme One : A Program of Inquiry”,
Proceedings of the Sixth Annual Conference on Applications of  Artificial Intelligence
and CD-ROM in Education and Training, Society for Applied Learning Technology,
Washington, DC, pp. 9–15.
( https://www.academia.edu/1272839/Exploring_Research_Data_Interactively._Theme_One_A_Program_of_Inquiry ) .

--

inquiry into inquiry: https://inquiryintoinquiry.com/
academia: https://independent.academia.edu/JonAwbrey
oeiswiki: https://www.oeis.org/wiki/User:Jon_Awbrey
isw: http://intersci.ss.uci.edu/wiki/index.php/JLA
facebook page: https://www.facebook.com/JonnyCache

[Jon Awbrey]

Ontologgers,

Here is my intro to the new series of blog posts I started this year
by way of explaining the problems I addressed and the lessons I think
learned in working on my Theme One program over the course of a decade.

Theme One • A Program Of Inquiry : 5
https://inquiryintoinquiry.com/2018/02/27/theme-one-%E2%80%A2-a-program-of-inquiry-5/

I started learning programming about the same time I first ran across
C.S. Peirce's Logical Graphs and Spencer Brown's Laws of Form in the
late 60s and naturally tried each new language and each new set of
skills I learned on writing processors and theorem provers for the
propositional calculus levels of their graph-theoretic formalisms.

Using previous work I had done in Lisp, I spent the 80s developing
a series of Pascal programs that integrated aspects of sequential
learning with aspects of propositional reasoning over an extension
of the CSP–GSB systems. I applied the program to a selection of
observational data sets from one of my advisor's research projects
and got an M.A. in Quantitative Psych out of it. People looking for
contemporary applications of the general Peircean paradigm may find
some of the directions in this work of interest.

The following blog post updates a list of links
to what documentation and exposition I've put on
the web so far:

Survey of Theme One Program

https://inquiryintoinquiry.com/2018/02/25/survey-of-theme-one-program-%e2%80%a2-2/

Regards,

Jon

On 4/25/2018 7:48 AM, Jon Awbrey wrote:
> Ontologgers,
>
> As an alternative to piling generalities on generalities,
> not that there's anything wrong with that, it also helps
> to look at issues as they arise in concrete applications.
>
> One of the most concrete applications I ever attempted was
> the program I worked on all through the 80s that sought to
> integrate a basic form of inductive (data-driven) learning

[joseph simpson]

Jon:

Do you plan on open sourcing the code?

Take care and have fun,

Joe

--
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-forum+unsubscribe@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

--

Joe Simpson

“Reasonable people adapt themselves to the world. 

Unreasonable people attempt to adapt the world to themselves. 

All progress, therefore, depends on unreasonable people.”

George Bernard Shaw

[Jon Awbrey]

Hi Joe,

There are copies of the Pascal source code here:

1. https://www.academia.edu/5210987/Theme_One_Program_Pascal_Source_Code
2. http://web.archive.org/web/20100603062658/http://ndirty.cute.fi/~karttu/Awbrey/Theme1Prog/Assembly/Theme1.pas

I don't know the technicalities of open-sourcing code,
so any informal advice would be appreciated. I looked
at the (CC BY-SA 4.0) referenced in the group info and
that seems okay by me, except it seemed a little fuzzy
about whether attribution by title is required or not.
For my part I regard the code and associated documents
as academic publications subject to the usual rules of
attribution. And I'll be around for a while if anyone
wants to dig into it. It's in what is probably a dead
language now but I took considerable pains to write it
in a functional style that should be easy to adapt.

Regards,

Jon

On 4/28/2018 6:28 PM, joseph simpson wrote:
> Jon:
>
> Do you plan on open sourcing the code?
>
> Take care and have fun,
>
> Joe
>

[Jack Park]

Hi Jon,

My experience is that CC-BY is good for documentation, whereas there are a host of software licenses available to you.

Some are so permissive they just say "have fun, don't use our name, and don't sue us".

Others offer a variety of "protections" -- which are defined in many ways. Some are actually "viral" in the sense that those licenses "infect" your work by demanding that others use the same license if they add stuff to your code. That's the light touch on it.

The more popular software licenses are:

permissive:
MIT, BSD, and Apache 2

where Apache 2 has an added clause which says something like "if you patent something that blocks our use of this code , then your right to use the code ends".

strict,
in increasing order: GPL, then AGPL

You can learn a lot by orbiting the help pages at https://github.com/

Hope that helps.

Cheers,

Jack

[joseph simpson]

Jon:

Thanks for the information.

More information about open source code is available at:

https://opensource.org/licenses

Given the age of the code and the computer language, it seems that a MIT type license might work.

Or may be just place the code in the public domain.

My plan, if I get the time, was to evaluate code and consider rewriting in another language .. like Python.

Anyway, you have a copyright statement on your code now and I was just checking your intent.

Take care, be good to yourself and have fun,

Joe

On Sat, Apr 28, 2018 at 7:24 PM, Jon Awbrey <jaw...@att.net> wrote:

[Jon Awbrey]

Jack, Joe,

Thanks for the helpful info and links! It looks like the MIT License
is permissive enough to enable discussion and development so I updated
the copy at Academia.edu to include the corresponding notice. (I just
imitated the form I saw being used at a couple of projects on GitHub.)

Theme One Program • Pascal Source Code

https://www.academia.edu/5210987/Theme_One_Program_Pascal_Source_Code

Regards,

Jon

[joseph simpson]

Jon:

Thanks for adjusting the permissions on this code file.

Take care, be good to yourself and have fun,

Joe

--

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-forum+unsubscribe@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[Jon Awbrey]

Ontologgers,

Discussion arose in the Laws Of Form Group about computational
explorations of George Spencer Brown's calculus of indications.

Readers of Peirce are generally aware that Spencer Brown revived
certain aspects of Peirce's logical graphs, focusing on the Alpha
level interpretable for Boolean Algebra and Propositional Calculus
but adding some hints of potential extension and generalization.
He used what amounts to Peirce's “entitative” interpretation of the
graphical forms in his exposition but was clear about the abstract
character of the forms themselves, as evidenced by their admitting
dual interpretations, dubbed “entitative” and “existential” by Peirce.

In computational context the question naturally arises how to code
the abstract formal structures used by the calculi of CSP and GSB
into the relatively concrete forms that a computer can process.

I began my response to that question as follows ...

Theme One • A Program Of Inquiry : 6
https://inquiryintoinquiry.com/2018/02/28/theme-one-%e2%80%a2-a-program-of-inquiry-6/

{A plaintext transcript follows, but see my blog copy
if the ASCII figure below gets mushed in this email.)

Programs are algorithms that operate on data structures (Wirth).
How do we turn abstract graphs like those used by C.S. Peirce
and Spencer Brown into concrete data structures that algorithms
can manipulate? There are many ways to do this, but one very
efficient way is through the use of “pointer data structures”.

The full documentation of my Theme One Program is still in progress,
but here's a link to a page of exposition, describing the family of
graphs used in the program, how to code the graphs as strings of
parentheses, commas, and letters, and how the program parses the
strings into pointer structures that live in computer memory.

Theme One Program • Exposition
http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition

Here's a link to a suitable point of entry for our present purpose:

Theme One Program • Expository Note 2
http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition#Expository_Note_2

2. Painted And Rooted Cacti And Conifers
=========================================

Figure 1 depicts a typical example of a painted and rooted cactus (PARCA).

o
a | d
o---o o
\ / b c |
o----o----o b e
\ /
\ /
\ /
\ /
@ a c e

Figure 1. Painted And Rooted Cactus

The graph itself is a mathematical object and does not inhabit
the page or other medium before our eyes, and it must not be
confused with any picture or other representation of it, anymore
than we'd want someone to confuse us with a picture of ourselves,
but it's a fair enough picture, once we understand the conventions
of representation involved.

Let V(G) be the set of nodes in a graph G and let L be a set of
identifiers. We very often find ourselves in situations where we
have to consider many different ways of associating the nodes of G
with the identifiers in L. Various manners of associating nodes with
identifiers have been given conventional names by different schools of
graph theorists. I will give one way of describing a few of the most
common patterns of association.

• A graph is “painted” if there is a relation between its node set
and a set of identifiers, in which case the relation is called a
painting and the identifiers are called paints.

• A graph is “colored” if there is a function from its node set
to a set of identifiers, in which case the function is called
a coloring and the identifiers are called colors.

• A graph is “labeled” if there is a one-to-one mapping between
its node set and a set of identifiers, in which case the mapping
is called a labeling and the identifiers are called labels.

• A graph is said to be “rooted” if it has a unique distinguished node,
in which case the distinguished node is called the root of the graph.
The graph in Figure 1 has a root node marked by the “at” sign or
amphora symbol “@”.

The graph in Figure 1 has eight nodes plus the five paints in the set
{ a, b, c, d, e }. The painting of nodes is depicted by drawing the
paints of each node next to the node they paint. Observe that some
nodes may be painted with an empty set of paints.

The structure of a painted and rooted cactus (PARC) can be encoded
in the form of character string called a painted and rooted cactus
expression (PARCE). For the remainder of this discussion the terms
cactus and cactus expression will be used to mean the painted and
rooted varieties. A cactus expression is formed on an alphabet
consisting of the relevant set of identifiers, the paints, together
with three punctuation marks: the left parenthesis, the comma, and
the right parenthesis.

To be continued ...

Jon

[Jon Awbrey]

Ontologists,

Coding Logical Graphs
=====================

My earliest experiments with coding logical graphs as
pointer data structures taught me that conceptual and
computational efficiencies of a critical sort could be
achieved by generalizing their abstract graphs from trees
to the variety graph theorists call “cacti”. The genesis
of that generalization is a tale worth telling another time,
but for now it's best to jump right in and proceed by way of
generic examples.

I gave a rough sketch of a typical cactus graph in my last post.
I'll make a better graphic eventually but for now see this page:

Theme One • A Program Of Inquiry : 8
https://inquiryintoinquiry.com/2018/03/10/theme-one-%e2%80%a2-a-program-of-inquiry-8/

Figure 1 shows a typical example of a “painted and rooted cactus”.

o
a | d
o---o o
\ / b c |
o----o----o b e
\ /
\ /
\ /
\ /
@ a c e

Figure 1. Painted And Rooted Cactus

Figure 2 shows a way to visualize the correspondence between
cactus graphs and cactus strings, demonstrated on the cactus
from Figure 1. By way of convenient terminology, the polygons
of a cactus graph are called its “lobes”. An edge that is not
a part of a larger polygon is called a “2-gon” or a “bi-gon”.
A terminal bi-gon is called a “spike”.

o
a (|) d
o---o o
(\ /) b c (|)
o--,--o--,--o b e
\ /
\ /
( \ / )

\ /
\ /
@ a c e

( ( a , ( ) ) , b c , ( d ) b e ) a c e

Figure 2. Cactus Graph and Cactus Expression

The correspondence between a cactus graph and
a cactus string is obtained by an operation
called “traversing” the graph in question.

• One traverses a cactus graph by beginning at the
left hand side of the root node, reading off the
list of paints one encounters at that point. Since
the order of elements at any node is not significant,
one may start the cactus string with that list of
paints or save them for the end. We have done the
latter in this case.

• One continues by climbing up the left hand side of
the leftmost lobe, marking the ascent by means of
a left parenthesis, traversing whatever cactus one
happens to reach at the first node above the root,
that done, proceeding from left to right along the
top side of the lobe, marking each interlobal span
by means of a comma, traversing each cactus in turn
one meets along the way, on completing the last of
them climbing down the right hand side of the lobe,
marking the descent by means of a right parenthesis,
and then traversing each cactus in turn, in left to
right order, that is incident with the root node.

The string of letters, parentheses, and commas one obtains
by this procedure is called the “traversal string” of the
graph, in this case, a “cactus string”.

Resources
=========

Theme One Program • Documentation
http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program

Theme One Program • Exposition
http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition

Theme One Program • Expository Note 3
http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition#Expository_Note_3

To be continued ...

Jon

[Jon Awbrey]

Ontologists,

I continue with the discussion of coding logical graphs.
See the following blog post for a better formatted text:

Theme One • A Program Of Inquiry : 9
http://inquiryintoinquiry.com/2018/03/14/theme-one-%e2%80%a2-a-program-of-inquiry-9/

We have seen how to take an abstract logical graph
of a sort a person might have in mind to represent
a logical state of affairs and translate it into a
string of characters a computer can translate into
a concrete data structure.

Now we look a little more closely at the finer details of
those data structures, as they work out in this particular
sequence of representations.

It is possible to write a program that parses cactus expressions into fairly close
facsimiles of cactus graphs as pointer graph structures in computer memory, doing
this in such a way that edges correspond to addresses and nodes correspond to records.
I did exactly that in early forerunners of the present program, but it turned out to
form a more robust strategy in the long run, in spite of the seemingly exorbitant
investment in nodes at the outset, to implement a more articulate but more indirect
type of parsing algorithm, one in which the punctuation marks are not just tacitly
converted to addresses in passing but recorded as nodes in roughly the same way as
the ordinary identifiers, or “paints”.

Figure 3 illustrates this type of parsing algorithm, showing the form of
pointer graph that results from parsing the cactus expression in Figure 2.
A traversal of this graph naturally reconstructs the cactus string that
parses into it.

o-----o
o------|--o |
| o---o | |
o->| ) |--o |
o---o |
^ o-----o
| / o-----o o-----o
o--------------------|-/----|--o | o-------------|--o |
| o---o o---o o---o< o---o | | | o---o o---o | |
o->| a |->| , |->| ( |->| ) |--o | o->| d |->| ) |--o |
o---o o---o o---o o---o | o---o o---o |
^ o--------------------------o ^ o------------o
| / | / o-----o
o------|-/----------------------------------|-/------------------|--o |
| o---o< o---o o---o o---o o---o o---o< o---o o---o o---o | |
o->| ( |->| , |->| b |->| c |-->| , |-->| ( |->| b |->| e |->| ) |--o |
o---o o---o o---o o---o o---o o---o o---o o---o o---o |
^ o---------------------------------------------------------------o
| /
o------|-/---------------------o
| o---o< o---o o---o o---o |
o->| ( |->| a |->| c |->| e |--o
o---o o---o o---o o---o
^
|
@

( ( a , ( ) ) , b c , ( d ) b e ) a c e

Figure 3. Parse Graph and Traverse String

A pointer graph of the type shown in Figure 3 has the
underlying form of a cactus graph and will normally be
convenient to describe in those terms, so long as we
remember its level of abstraction lies a step further
in the direction of concrete implementation than the
last thing we called by that name.

Resources
=========

* Theme One Program • Documentation
http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program

* Theme One Program • Exposition

http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition

* Theme One Program • Expository Note 4
http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition#Expository_Note_4

To be continued ...

Jon

[joseph simpson]

Jon:

I have a basic system working, after a few minor adjustments to the code.

I would like to put the code on Github and use Github as a mechanism for further system development.

Does that sound like a good Idea to you?

Some other people may also like to have access to a central repository for the code and the program underdevelopment. 

I can manage the Github repository.

Take care, be good to yourself and have fun,

Joe

--
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-forum+unsubscribe@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[Jon Awbrey]

Joe,

Wow, that was quick. Did you do that by hand or have a translator?
Sure, okay by me to develop on GitHub.

Did you implement the little bit of user interface I wrote, or bypass it?
There are 2 small txt files that it needs for startup. There's a branch
that lets you create them but it's easier to just keep copies on hand.

Attaching MENU.LEX and MENU.LIT

Regards,

Jon

On 5/2/2018 10:16 PM, joseph simpson wrote:
> Jon:
>
> I have a basic system working, after a few minor adjustments to the code.
>
> I would like to put the code on Github and use Github as a mechanism for
> further system development.
>
> Does that sound like a good Idea to you?
>
> Some other people may also like to have access to a central repository for
> the code and the program underdevelopment.
>
> I can manage the Github repository.
>
> Take care, be good to yourself and have fun,
>
> Joe
>

[joseph simpson]

Jon:

I tried to do the simplest thing that might work...

Which was...

Find a Pascal compiler, then compile and run the code..

I found...

https://www.freepascal.org/

Which has an up-to-date Pascal compiler and tool set...

Then I just tried to compile the code...

Making best guesses at how to fix each compiler error...

Until the system compiled...

And ran..

The screen displayed a small menu asking for a lex file.. and some other input..

But that is where I stopped to ask for more information..

I will try to get something up on Github in the next week or so...

Take care be good to yourself and have fun,

Joe

[Jon Awbrey]

Ontologists,

Here is my next installment —

Blog:
https://inquiryintoinquiry.com/2018/03/18/theme-one-%e2%80%a2-a-program-of-inquiry-10/

Wiki:
http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition#Expository_Note_5

Lexical, Literal, Logical
=========================

Theme One puts cactus graphs to work in three distinct but related ways,
called “lexical”, “literal”, and “logical” uses, and these applications
make use of three distinct but overlapping subsets of the broader species
of cacti. Thus we may find ourselves speaking of expressions, graphs, or
files of lexical, literal, or logical types, depending on our focus and
point of view at a given moment.

Logical cacti are the most inclusive class, encompassing the whole species
of structures described above, and so we have already seen a typical example
of a logical cactus, in its avatars as an abstract graph, a pointer structure,
and a string of characters suitable for storage in an external text file.

But being a logical cactus is not just a matter of syntactic form — it means
being subject to meaningful interpretations as a sign of a logical proposition.
From a logical perspective we expect our cactus expressions to express something,
to represent a proposition that can be true or false of something.

For present purposes it will speed things along to skip the discussion
of lexical and literal cacti and jump right to the logical and semantic
interpretation of cactus graphs. Readers seeking immediate enlightenment
about the details may peruse the outline of notes given below.

Lexical Cacti
=============
• http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition#Expository_Note_6
• http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition#Expository_Note_7
• http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition#Expository_Note_8
• http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition#Expository_Note_9
• http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition#Expository_Note_10

Literal Cacti
=============
• http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition#Expository_Note_11
• http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition#Expository_Note_12

Logical Cacti
=============
• http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition#Expository_Note_13
• http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition#Expository_Note_14
• http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition#Expository_Note_15
• http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition#Expository_Note_16

My next post in this series will take up the discussion at Note 13.

Regards,

Jon

[Jon Awbrey]

Theme One • A Program Of Inquiry : 11
http://inquiryintoinquiry.com/2018/03/28/theme-one-%e2%80%a2-a-program-of-inquiry-11/

Ontologists,

The portions of exposition just skipped over covered the
use of cactus graphs in the program's learning module to
learn sequences of characters called “words” or “strings”
and sequences of words called “sentences” or “strands”.
Leaving the matter of grammar to another time we turn to
the use of cactus graphs in the program's reasoning module
to represent logical propositions on the order of Peirce's
Alpha Graphs and Spencer Brown's calculus of indications.

(Please see the blog post linked above for the Tables mentioned below.)

Logical Cacti
=============

Up till now we've been working to hammer out a two-edged sword of syntax,
honing the syntax of cactus graphs and cactus expressions and turning it
to use in taming the syntax of two-level formal languages.

But the purpose of a logical syntax is to support a logical semantics,
which means, for starters, to bear interpretation as sentential signs
capable of denoting objective propositions about a universe of objects.

One of the difficulties we face is that the words “interpretation”, “meaning”,
“semantics”, and their ilk take on so many different meanings from one moment
to the next of their use. A dedicated neologician might be able to think up
distinctive names for all the aspects of meaning and all the approaches to
them that concern us, but I will do the best I can with the common lot of
ambiguous terms, leaving it to context and intelligent interpreters to
sort it out as much as possible.

The formal language of cacti is formed at such a high level of abstraction
that its graphs can bear at least two distinct interpretations as logical
propositions. The two interpretations that concern us here are descended
from the ones C.S. Peirce called the “entitative” and the “existential”
interpretations of his systems of graphical logics.

Existential Interpretation
==========================

Table 1 illustrates the existential interpretation of cactus graphs
and cactus expressions by providing English translations for a few
of the most basic and commonly occurring forms.

[Table 1]

Entitative Interpretation
=========================

Table 2 illustrates the entitative interpretation of cactus graphs
and cactus expressions by providing English translations for a few
of the most basic and commonly occurring forms.

[Table 2]

Resources
=========

* Theme One Program • Documentation
http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program

* Theme One Program • Exposition

http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition

* Theme One Program • Expository Note 13
http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition#Expository_Note_13

* Theme One Program • User Guide

https://www.academia.edu/5211369/Theme_One_Program_User_Guide

Regards,

Jon

[Jon Awbrey]

Theme One • A Program Of Inquiry : 12
http://inquiryintoinquiry.com/2018/04/03/theme-one-%e2%80%a2-a-program-of-inquiry-12/

Ontologists,

The main things to take away from the previous post are
the following two ideas, one syntactic and one semantic:

• The compositional structures of cactus graphs and
   cactus expressions are constructed from two kinds
   of connective operations.

• There are two ways of mapping these compositional structures
   into the compositional structures of propositional sentences.

The two kinds of connective operations are described as follows:

• The “node connective” joins a number of
   component cacti C_1, ..., C_k to a node:

Node Connective

• The “lobe connective” joins a number of
   component cacti C_1, ..., C_k to a lobe:

Lobe Connective

The two ways of mapping cactus structures to logical meanings
are summarized in Table 3, which compares the existential and
entitative interpretations of the basic cactus structures,
in effect, the graphical constants and connectives.

[See the following blog post for Table 3.]

https://inquiryintoinquiry.com/2018/04/03/theme-one-%e2%80%a2-a-program-of-inquiry-12/

Resources
=========

* Theme One Program • Expository Note 14
http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition#Expository_Note_14

* Theme One Program • User Guide

https://www.academia.edu/5211369/Theme_One_Program_User_Guide

[Jon Awbrey]

Theme One • A Program Of Inquiry : 13
http://inquiryintoinquiry.com/2018/04/16/theme-one-%e2%80%a2-a-program-of-inquiry-13/

Ontologists,

Logical Cacti (cont.)
=====================

The abstract character of the cactus language relative
to its logical interpretations makes it possible to give
abstract rules of equivalence for transforming one cactus
into another that partition the space of cacti into formal
equivalence classes. These transformation rules and the
resulting equivalence classes are “purely formal” in the
sense of being indifferent to the logical interpretation,
entitative or existential, one happens to choose.

Two definitions are useful here:

• A “reduction” is an equivalence transformation that applies
in the direction of decreasing graphical complexity.

• A “basic reduction” is a reduction that applies to a basic
connective, either a node connective or a lobe connective.

The two kinds of basic reductions are described as follows:

• A “node reduction” is permitted if and only if
every component cactus joined to a node
itself reduces to a node.

https://inquiryintoinquiry.files.wordpress.com/2018/04/cactus-graph-e280a2-node-reduction.jpg

• A “lobe reduction” is permitted if and only if
exactly one component cactus listed in a lobe
reduces to an edge.

https://inquiryintoinquiry.files.wordpress.com/2018/04/cactus-graph-e280a2-lobe-reduction.jpg

That is roughly the gist of the rules. More formal definitions
can wait for the day when we have to explain all this to a computer.

Resources
=========

• Theme One Program • Documentation
http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program

• Theme One Program • Exposition
http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition

• Theme One Program • Expository Note 14
http://intersci.ss.uci.edu/wiki/index.php/Theme_One_Program_%E2%80%A2_Exposition#Expository_Note_14

• Theme One Program • User Guide
https://www.academia.edu/5211369/Theme_One_Program_User_Guide

[Jon Awbrey]

Joe S, John B, All ...

Replying onlist to a few of your offlist comments
in case anyone else is interested in this project.

About the only nice thing about cleaning out my basement and
putting my belongings in storage is finding a trove of work
I thought had been lost, in a stash of 3½ floppies, no less.
I uploaded a sample to a couple of folders on Google Drive:

Theme One Program
https://drive.google.com/open?id=1aUHhcP5VDMR8OnvWSggwU2QozT2A1bve

Theme One Guide
https://drive.google.com/open?id=19K2pwRKXlrs_sGNyv1g4RAwx5IyDGp_j

The 1st contains a minimal set of files for running the program.
The 2nd contains all the example files mentioned in the User Guide.

Apologies in advance for Theme One being a bare prototype, text of concept
sort of program. The user interface is pre-mouse and very finicky but I,
its mother, was able to nurse it along far enough to learn a lot from it,
and many are lessons of still timely pertinence to our perennial issues.

Regards,

Jon

[joseph simpson]

Jon:

Thanks for making the effort to locate and make available this additional code and information.

My plan is to create a Github repository with the provided information.

Does the MIT license apply to all of the code files you have provided on the drive?

Before I create the Github repository, I need to get the original Pascal program compiling and producing the correct input/output.

I am currently working the file input data type issues.

In any case, I should have something up on Github in the next couple of weeks.

I will keep you posted of my progress.

Take care, be good to yourself and have fun,

Joe

--
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-forum+unsubscribe@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[joseph simpson]

Jon and All..

I set up a GitHub repository at:

https://github.com/jjs0sbw/ThemeOne

The current version of the code compiles using Free Pascal.

More later,

Joe

   

On Mon, May 7, 2018 at 11:08 AM, Jon Awbrey <jaw...@att.net> wrote:

--
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-forum+unsubscribe@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[Jon Awbrey]

Joe,

Thanks for your work in setting this up. Out our way we are
renovating our house to put on the market, putting things in
storage, and new-house hunting, so it will be a month or two
before I get more than snatches of time here and there. But
I'll try to get on GitHub this week and participate one way
or another. I've never worked there before so let me know
off list what I need to do.

I'll divide the rest of my discussion into the parts that
illustrate persistent and pervasive issues in applied logic,
AI, and computational tools for scientific inquiry, and the
parts that form mere details of a particular implementation.
I'll do my best to keep the 1st part on list and 2nd part off.

Regards,

Jon

On 5/12/2018 4:32 PM, joseph simpson wrote:
> Jon and All..
>
> I set up a GitHub repository at:
>
> https://github.com/jjs0sbw/ThemeOne
>
> The current version of the code compiles using Free Pascal.
>
> More later,
>
> Joe
>

[joseph simpson]

Jon:

Sounds great.

I will have more time toward the end of June ... first of July...

Looking forward to the information, discussion and interaction....

Take care, be good to yourself and have fun,

Joe

[Jon Awbrey]

Theme One Motivation • 1
http://inquiryintoinquiry.com/2018/05/15/theme-one-motivation-%e2%80%a2-1/

Ontologists,

The main idea behind the Theme One program is the efficient use
of graph-theoretic data structures for the tasks of “learning”
and “doing logic”.

I am thinking of “learning” in the sense of “learning about
an environment”, in other words, acquiring information about
the nature of an environment and being able to apply that
information to some purpose.

Under the heading of “doing logic” I am merely lumping together
all the ordinary sorts of practical activities that would probably
occur to most people under that name.

There is a natural relation between these tasks. Learning the character
of an environment leads to the recognition of laws that govern the environment
and making full use of this recognition requires the ability to reason logically
about these laws in abstract terms.

Regards,

Jon

[Jon Awbrey]

Theme One Motivation • 2
https://inquiryintoinquiry.com/2018/05/17/theme-one-motivation-%e2%80%a2-2/

Ontologists,

A side-effect of working on the Theme One program over the course
of a decade was the measure of insight it gave me into the reasons
why empiricists and rationalists have so much trouble understanding
each other, even when those two styles of thinking inhabit the very
same soul.

The way it came about was this. The code from which the program is
currently assembled initially came from two distinct programs, ones
I developed in alternate years, at first only during the summers.

In the “Learner” program I sought to implement a Humean empiricist
style of learning algorithm for the adaptive uptake of coded sequences
of occurrences in the environment, say, as codified in a formal language.
I knew all the theorems from formal language theory that tell how limited
any such strategy must ultimately be in terms of its generative capacity,
but I wanted to explore the boundaries of that capacity in concrete
computational terms.

In the “Modeler” program I aimed to implement a variant of Peirce’s
graphical syntax for propositional logic, making use of graph-theoretic
extensions I had developed over the previous decade.

As I mentioned, work on these two projects proceeded in a parallel series
of fits and starts through interwoven summers for several years, and then,
somewhere along the line, I can’t remember just when, I realized that the
Learner, one of whose other names happened to be “Index”, could be put to
work helping with sundry substitution tasks that needed to be done by the
Modeler, one of whose other names happened to be “Slate”, since it evoked
innate ideas of the tabula rasa.

So I began to integrate the Learner and the Modeler, at first still working on
the two component modules in an alternating manner, but devoting a portion of
effort toward the task of amalgamating their principal data structures, bringing
them into convergence with each other, and unifying them over a common basis.

Another round of seasons and many changes of mind and mood and programming style,
I arrived at basically the same graph-theoretical data structure, strung like
a wire through the far-flung pearls of my programmed wit. But the pearls I
polished in alternate years maintained their shine along axes of polarization
whose grains remained skew in regard to each other. That is to say, all the
strategies that appeared to be the smartest tricks to pull from the standpoint
of optimizing the program’s performance on the Learning task I found the next
year were the dumbest moves to pull from the standpoint of its performance on
the Reasoning task. I gradually came to appreciate this as a discovery ...

Regards,

Jon

[Jon Awbrey]

Ontologists,

Questions in another forum led me to say a little more
about the origin and early years of the Learner module:

Theme One Motivation • 3
https://inquiryintoinquiry.com/2018/05/19/theme-one-motivation-%e2%80%a2-3/

All through the 70s and 80s I spent many interesting hours
hanging out in John Eulenberg's Artificial Language Lab at
Michigan State. The lab did a lot of work on augmentative
communication technology for limited mobility users and the
observations I made there prompted the first inklings of my
Learner program. Early in that period I sat in on his course
in mathematical linguistics, which featured Laws of Form among
its readings(!), along with Wall, Chomsky, Jackendoff, and the
Unified Science volume by Charles Morris that mentioned Peirce
in a favorable light. I learned Zipf's Law relating the lengths
of codes to their usage frequencies and named the earliest avatar
of my Learner “XyPh”, alluding to Zipf and the Xylem and Phloem of
its tree data structures.

To be continued ...

[Jon Awbrey]

Ontologists,

Backtracking a bit and continuing ...

Theme One Motivation • 4
https://inquiryintoinquiry.com/2018/05/20/theme-one-motivation-%e2%80%a2-4/

Speaking of compression, either my present memory or my mind at the time
mushed together two different sorts of 1/f scaling laws under the heading
of Zipf's Law, but the overarching principle here is simply “things that
vary inversely to frequency”. Generally speaking, keeping track of usage
frequencies is part and parcel of building efficient codes.

In it's first application, then, the environment the Learner had to learn was
the usage behavior of its user, as given by finite sequences of characters from
a finite alphabet that we might as well call “words” and by finite sequences of
those words that we might as well call “phrases” or “sentences”. In other words,
the Learner had the job of constructing a “user model”.

In that frame of mind we are not seeking anything so grand as a
Universal Induction Algorithm but simply looking for any approach
that gives us a leg up, complexity wise, in Interactive Real Time.