FrontPage SiteMap RecentChanges RecentNearChanges HowTo Blog

Matching Pages:

RSS

Eritrea, Independence Day

ArcleModelling

This is a discussion fork from AlternativesToHierarchy, describing a new way to look at the graph / diagramming / thought mapping problem. It should lead to “next generation mind mapping” tools. Currently it’s not more than insight and the final concept. Sketches to come. Feedback, collaboration and co-ownership invited. I would be interested to elaborate this in the community and find collaboration to put this into a “OS Java applet for wiki” project to make this generally available in our everyday work.

The idea started from experienced problems with diagramming and data structures, the dichotomy between vertices (“arcs”) and nodes (“circles”) and their corresponding record structure implementations. Experiences over the course of 25 years of programming and thinking. This intensified while cross-reading 5000 contributions/5 years from the MinciuSodas “working in parallel” mailing list of “tool makers” in early 2006. The idea doesn’t have its origin there, but it is nevertheless owed to or founded in - to a large extent, let’s say 40-60% - the work of AndriusKulikauskas. Therefore I put it in the EthicalPublicDomain.

HelmutLeitner

The Simple Idea

There is only one element, the “Arcle” which can fill the role of an node or vertex (object or relation, box or connection) at will.

Symbol and Philosphy

http://www.prowiki2.org/upload/HelmutLeitner/arcle_icon.gif

The symbol is derived from the arc and the circle. It has the power of a circle but connected with the idea of dynamic movement. It is enclosing but it is open at the same time. It symbolizes the holistic thought.

It also reflects the neighborhood to its two aspects. Close it completely and you get the circle, the static structure, the object, the node, the system. Stretch it and you get the arc, the pure dynamic movement, the vertex, the change or relationship.

The Name

Should be obvious: ARCLE = ARc+cirCLE.

Data Structure

The corresponding data structure is a dynamic list of algorithms.

Typical (classical) node/vertex record elements like “label: xyz” or “from: x to: y” are just seen as very simple, hard coded algorithms (no need to say that any hard coding is limiting and counter-productive).

The Goal

The goal of ArcleModelling is thought modelling, nothing less.

Hypothesis: thinking consists of recursive algorithms, not data. Data is a necessary medium for expression, not more. To stay in sync with the Arcle concept one must always be aware of that.

Simple Example

The Arcle symbols show the internal structure. They should be part of the user interface, showing the logical grouping but should not be part of printed graph.

http://www.prowiki2.org/upload/HelmutLeitner/SimpleIsomorph300.jpg

(1)   arcle unnamed
        algorithm CREATE "A"
        algorithm CREATE "B"
        algorithm FROM "A" TO "B"

(2)   arcle "A"
      arcle "B"
      arcle unnamed
        algorithm FROM "A" TO "B"

(3)   arcle "A"
        algorithm TO "B"  
      arcle "B"

(4)   arcle "A"
      arcle "B"
        algorithm FROM "A"

The point is that for a given graph you can still define you perspective and have isomorphic transformations.

An Arcle represents an idea, not a part of a graph primarily. So an arcle may result in no visual effect at all, or it may effect the whole graph, or part of it:

    arcle 
      algorithm SET color=blue FOR "all text"
      algorithm DISPLAY FOR "all comments"

    arcle vertices_blue
      algorithm SELECT "all algorithms" 
        algorithm SET linewidth=2pt

Of course this is just experimental syntax.

The Formal Structure of Thoughts

“Thoughts are fractal structures of arcles containing algorithms (and arcle references) recursively”.

The Biological structure of Thoughts

Our brain is a tremendous pattern processing system. Inputs form patterns which form other patterns in turn, on and on. There is a 1:1 relationsship between an Arcle (as a conceptual model, useful for implementation) and the Pattern (as a biological building block of our thinking, which is not yet fully understood in its mechanisms).

Wiki

Wiki can be interpreted as a free text Arcle modelling system without a visualization component. That is the reason why wikizens can feel this resonance of “thinking and learning” in community.

Discussion

Sounds good to me. Understanding understanding, yes. The earlier the better.

I’d changed your nice symbol just a little for making it work better with the metafore of streching out a open circle to an arch. The floor is on the bottom of a picture, the heaven on top of it - a pretty general agreement.

http://static.flickr.com/97/249737039_9cccb56c35_s.jpg

Mattis, thank you for the suggestion, but I tried a lot of variations and prefer the “psychologically positive direction” for the opening. We also have it already in logos

http://www.wikiservice.at/prowiki/ProWikiGold96.gif

which I read as “holistic thinking about Wiki”. Or the interesting 10-year-pre-Arcle logo of GIVE:

http://www.give.at/basisgrafik/logo_big.jpg

So I hope that you are not offended when I stick to current form of the symbol.

I suppose you are trying to not make it look like an “Undo” icon :).

No, I never saw this similarity, although it’s good to avoid this too. We saw the similarity to the CreativeCommons ShareAlike symbol, which we tried to avoid, not because the idea of sharing is far off, but because CC has a bad reputation with respect to their copyrighted materials like icons.

I’ve been doing a lot of SemanticNetwork modeling in the last couple of weeks, and I have hit upon basically the same thing as the Arcle.

Points of reference: SemanticNetworksForSearch, TriplesBad.

The Arcle solves the engineers ContextProblem: You stretch an arcle out to a big circle, and put all your statements in it, that you want to be part of that context.

The only difference I perceive between what I’m creating, and the Arcle, is that what I’m creating allows for the duple – two nodes side by side, without a named connection between them. Well, the duple, and other structures without wires connecting them. Basically, “arrays,” or other geometries, without explicit connections.

I’m putting together a parser that accepts inputs such as:

 helmut name "Helmut Leitner";
 lion name "Lion Kimbro";
 helmut says (arcle a datastructure;
              arcle canbea node;
              arcle canbea arrow;
              arcle cancontain arcle);
 lion says (arcle solves contextproblem;
            triples bad)

… and turns them into:

 [("helmut", "name", "Helmut Leitner"),
  ("lion", "name", "Lion Kimbro"),
  ("helmut", "says", [("arcle", "a", "datastructure"),
                      ("arcle", "canbea", "node"),
                      ("arcle", "canbea", "arrow"),
                      ("arcle", "cancontain", "arcle")],
  ("lion", "says", [("arcle", "solves", "contextproblem"),
                    ("triples", "bad")]]

If anyone knows a pre-made something that does basically this, it would, of course, be appreciated.

Note that I don’t want XML; the syntax needs to be very lean, because I’m using it for my next iteraction of my SemanticNetworksForSearch program. That is, I am personally going to be writing these statements continuously.

Actually, I’d like to hook it up to CommunityWiki after some testing, and index CW with it.

Lion, I wrote this page as an answer to typical graph problems, therefore I dealt with the relative interpretation of the connection A->B. But this doesn’t mean that the connection is a necessary part of the Arcle concept. Elements (Arcles, triples) can always stand side-by-side just as you did it, or can be put in an enclosing structure, or are in such an enclose implicitely (like drawing elements on a page are implicitely enclosed by the page, or all tables and records in a database).

What I aimed at with the Arcle concept is to free the mind from the search for the final data structure, to separate conceptional thinking from implementational thinking. I’m no data structure expert but I assume that one can put anything into a relational database or a triple systems. The concepts are powerful enough to hold any information. But I feel that it is not efficient to do so. If it were, we would probably talk in triples, not in natural language sentences.

What would happen if we now talked about what you modelled (what “helmut” and “lion” said) and I just say that you perceive it that an arcle is a data structure but I think it is a (1) conceptual structure that I just have put (2) into a drawing and (3) in some kind of syntactical notation. What if we talk about the status of what have been said (is it proven, hypthetical, …) and how we feel about this emotionally (affirmative, contradicting, …).

Then in the drawing I would put an arcle around the elements and attach some new information to it (I create a new arcle of arbitray content). In a notation I must now have a way to add aan ID (handle) to any substructure to be able to name and reference it.

 "Helmut Leitner" = helmut
    "Arcle concept" = AC
      textorigin CommunityWiki:ArcleModelling
      compare to "Mathematical Graph concept" = MGC
        Arcle corresponds to MGC.(node OR arrow) 
      Arcle is "list of Arcles"
        property "recursive"
        property "dynamic"
 "Lion Kimbro" = lion
    says "AC solves contextproblem" = LS1
    says "triples bad" = LS2
 helmut
   thinks "LS1 affirms AC"
     feeling is positive
   intentions
     continue discussion
     learn more
   thinks LS2 connects to HS1
   says "There can be no universal static data structure" = HS1
     status hypthetical
     effect "against Triples"
       affirming LS2
   says "Arcle is a recursive dynamic structure" = HS2
     status should be provable
   says "Triple is a recursive static data structure" = HS3
     status probably agreement
       agreement_group (lion, helmut) = ThisPageDiscussionGroup
 arcle = VISUALIZATION
   target "all arcles except VISUALIZATION"
     put into drawing
       status suggestion 
         from helmut 
           reason thinks "is positive (only test case)"
       rendering suggestions
         text default Verdana 12pt bold black
         render 
           LS2 red 14pt    
         box default outlines 1px oval blue
         arcles default green          

Wonder how you put that into triple form. Of yourse this is unfair, because I invented the syntax on the fly. Sorry.

  • (A → B)
  • A → B
  • (A → )B
  • A(→ B)

can you tell me, what’s the difference to “Simple Example” above?

sigi, I would put it slightly different in this way

  • (A → B)
  • (A)( → )(B)
  • (A → )(B)
  • (A)(→ B)

to directly correspond. But otherwise I see no difference, this is an alternative notation for this simple case.

I chose the drawing to introduce the Arcle symbol to introduce it and to indicate this layer of reflection or interpretation.

I would do it;

 helmut label "Helmut Leitner";
 AC label "Arcle concept";
 AC textorigin "CommunityWiki:ArcleModelling";
 MGC label "Mathematical Graph concept";
 MGCnode partof MGC;
 MGCarrow partof MGC;
 arcle partof AC;
 AC comparedto MGC;
 arcle comparedto MGCnode/MGCarrow;
 arcle a "list of Arcles";
 arcle property recursive;
 arcle property dynamic;

At this level of complexity, I think things can be completely performed within a flat SemanticNetwork– I don’t really encounter the ContextProblem, in this sort of expression.

Wanted to say more- gotta run.

I’m curious how this continues. I see an object definition emerging, however complex it will become it is still a consistent definition of objects. But our thinking is not an object that can be described and enhanced the same way. It’s not easy to go from a single object to multiple different views of the same object and relating that in an unfolding process, to which you can add incrementally as we do when thinking or talking.

What I would like to see is how you naturally add such information like “Lion says (…) and thinks that (…) is hypothetical. Helmut has a different view of (…) and interprets it (…). and sigi evaluates this and thinks that what Lion and Helmut think about (…) is not much different and adds an explanation of the difference. Now Lion and Helmut refer to what sigi says…”

That goes beyond the capabilities of triples.

But if we take the arcles, or “n-tuples with contexts,” one way we could do it is with:

 lion says e1;
 lion thinks e2;
 
 e1 about subject1;
 e1 philosophy philosophy1;
 helmut thinks e3;
 e3 about subj1;
 e3 philosophy P2;
 helmut thinks (e3 leadsto e4);
 helmut says (e4 contradicts e1);

To introduce “sigi evaluates this,” we wrap the whole thing into a context. Or, in your language, an arcle.

Here’s a go:

 first (lion says e1;
        lion thinks e2);
 
 second (e1 about subject1;
         e1 philosophy philosophy1;
         helmut thinks e3;
         e3 about subj1;
         e3 philosophy P2;
         helmut thinks (e3 leadsto e4);
         helmut says (e4 contradicts e1));
 
 third (sigi sees first/second;
        sigi thinksabout e1/4;
        sigi thinks (e4 doesntcontradict e1);
        sigi says e5;
        e5 explains (e4 doesntcontradict e1;
                     P3 contains P2/P1);
        e5 about subj1;
        e5 philosophy P3;
        P3 contains P2;
        P3 contains P1;
 
 first happened; second happened; third happened;
 second follows first; third follows second

At this point, I run into a problem. I have basically successfully modeled everything up to this point. But there’s this last sentence: “Now Lion and Helmut refer to what sigi says…”

How do I say that something is spoken in reference to something else?

With the arcle, we would hypothetically crack open a “says,” and then circle the something else that was said elsewhere.

By the way of modeling the data just above, I think I have to do some re-engineering: I need to change how “says” works.

Well, wait, no, not necessarily.

I could:

 fourth (helmut/lion sees third;
         helmut says (...) withreference e5;
         lion says (...) withreference e5);
 
 ?who says ?statements withreference ?referred
   ==> ?who says ?statements

Another way we could do it is say:

 fourth (helmut/lion sees third;
         helmut (say (...); reference e5);
         lion (say (...); reference e5));
 
 ?who (say ?statements; reference ?referred)
   ==> ?who says ?statements;

There are other ways; We could timestamp, and introduce timestamps as a basic type, and then teach it about how to compare timestamps, and so on.

Data modeling is, to my mind, MetaPhysics. There are a lot of ways to do it. That said, this expression with arcles or (n-tuples + contexts) is a lot more efficient, to me, than many other ways.

Let’s take the arcle story, and see what it inspires.

 ?someone said ?something

Now, we want to say that it was in reference to something else.

I was taking the n-tuples way, and creating:

 ?someone said ?something referencing ?referred

This is not a very good approach, because…

 ?someone said ?something in-response-to ?priorsaid referencing ?ref-a referencing ?ref-b referencing ?ref-c

…will not work very will with the way that we express rules:

 ?someone said ?something in-response-to ?priorsaid

…would not match the pattern, because it is a 5-tuple, not an 11-tuple.

What we would ideally make here, is something decomposable:

 ?expr (spokenby ?speaker; in-reponse-to ?other-expr; referencing ?ref-1; referencing ?ref-2; referencing ?ref-3)

…now we can say things like:

 ?expr (spokenby ?speaker; referencing ?ref-3)
   => ?speaker probably well-read

But back to the arcle: What might the idea of the arcle inspire?

Our puzzle is adding references to:

 ?someone said ?something

For me, the arcle concept inspires the vision of opening up the arcle around “said,” and enclosing a reference:

 ?someone (said referencing ?ref-1) ?something

Now, can we reason with this? I think so:

 ?someone (said referencing ?ref-1) ?something
   => someone said ?something

The form templates and asks: “Who & what did someone say, referencing what?”

The only trick is that we need to consistently express our “saids” like this.

Or, make a bridge between this “said,” and a more regular form that rules and searchers are set for.

I think no matter how we format our data, structure must be consistently repeated. (I don’t have a proof; I’d be interested in seeing one.)

We can bridge inconsistencies with reasoners. I think we can even make statistical analysis tools that show, “Oh, this is probably a consistent pattern, and that thing over there seems like an inconsistency of form.”

But I don’t think there’s any running away from consistency, arcle or no.

I think the most natural thing to do is express things like we know how to.

When we find a contradiction between the model, and what we want to say:

  1. Make a more appropriate frame, and express what you want in the new frame.
  2. Write rules to convert from the old frame to the new frame, as possible.

But I now see in the summary line:

  • Helmut wants recursive reflective information as is common with thinking processes.

So the question then is: “How can we express recursive reflective statements, to a computer, like in thinking processes?”

I now have new appreciation of the question.

I’ll keep thinking about this question, but I do have an immediate observation:

  • Humans create and destroy recursive reflexive statements regularly.

Most of the SemanticNetworks that we describe, though, are “statements for all time,” existing on one plane, even if it contains nesting.

Humans just throw away (in our minds) the specific lines of reasoning. We replace great nesting structures with a single symbol, and then, should we need to go back into the nesting structures, simply recreate the graphs and subgraphs of reasoning, rather than pulling them out of a library.

So I think that:

  • …the answer to the question must have an incremental form.

I’m imagining:

  • “line numbers,” like in old BASIC programs.
  • line-number addressed objects: Things aren’t just addressed by name, but by line-number as well.
  • tree-structure, or a tree containing graphs.

I think that this might work.

I’ll get back with an approach.

 10 lion says expr;
    lion thinks (expr hypothetical)
 20 helmut thinks (expr about subj;
                   expr misinterpretation subj;
                   expr2 interpretation subj)
 30 sigi sees 10/20;
    sigi thinks (expr notmuchdifferent expr2);
    sigi explains (expr notmuchdifferent expr2);
 40 helmut says expr3;
    expr3 references (30 sigi explains ?x)=>(?x)
    lion says expr4;
    expr4 references (30 sigi explains ?x)=>(?x)

How’s that?

The critical values may be to:

  • Support questions as nodes.
  • Express time in the model.

Lion, you’re way of putting it looks very good. And formalizing a syntax is necessary. But i need more time to think this through and really understand this and its implications or limitations.

The point that we shouldn’t lose is that ArcleModelling means that the formal syntax is not the goal (let’s refer to Gödels’s incompleteness theoreme) and that the elements of the system should not be treated as a record structure of predefined fields (because this will always necessarily lead into restictions) but as algorithmic command patterns, that should be interpreted by something that is extendable.

So, as an example, something like

  graph
    data from CommunityWiki
    nodes are "all homepages"
      red
    vertices between "all names coexisting on any page"
      black
    arrangement circle

should be a natural expression. It’s not important that algorithms can be expresed as data (somehow everything can and must be expressed that way), but that even simple data like “Spain isa Country” or even “bad” is interpreted as an algorithm, soemthing that is executed not just stored, however simple.

Then you can for example to

  reinterpret
    original "$1"
    as "is $1"
  reinterpret
    original "is $1"
    as "self is $1"

to say

  Triples    
    concept
    good 
      context of ...
    bad
      context of ...

Modelling thought processes doesn’t mean to deal with structured data, but to deal with structured algorithms. Often this means pattern matching as a basic method of interpretation. Maybe there is a connection to the AlexandrianMethod on the pattern level.

Hm; Well, if we allow for queries to be nodes, I don’t see why full rule expressions couldn’t be nodes as well.

For instance:

 10 helmut says (?x original ?y
                 => ?x a ?y)
 20 lion says (triples bad)
 30 helmut says expr;
    expr clarifies (20 lion says ?x)=>(?x);
    expr reads (context1 (triples bad);
                context2 (triples good))
 40 we note (?x says ?expr,
             ?expr reads ?statements
             => ?x says ?statements)

So here, we have two examples of rules:

  • (?x original ?y ⇒ ?x a ?y) – which I think matches your first example,
  • (?x says ?expr, ?expr reads ?statements ⇒ ?x says ?statements)

Is this a mechanical example of the structured algorithms that you are talking about?

We could also:

 ?x a name,
 ?x on CommunityWiki,
 ?x a namepage
 => ?x rednode

I’m not sure what you meant by:“all names coexisting on any page” --

I originally thought:

 ?x/?y a word,
 ?page a page,
 ?x/?y on ?page

…which would give us pairs of words that co-exist on a page, but I think you must have meant something else.

Perhaps: ?x/?y rednode, ?x links ?y ⇒ ?x blackvertex ?y

 render specialpage
 => content circle rednode blackvertex

We find ourselves squarely in declarative programming.

What kinds of things are you thinking of, when you put together the phrase, structured algorithms?

I know that, I personally, have been looking for what I call “IncrementalIntelligence?” – things that get smarter, bit by bit, as you go through time, and train the system.

I think that’s perfect, to keep such a system fluid and extendable.

Sorry, that I was unclear in my example. By “co-existing homepage names” I meant “co-existing signatures” as a quick shot towards “people knowing each other from discussions”.

Define external redirect: IncrementalIntelligence

EditNearLinks: MeatballWiki ShareAlike EthicalPublicDomain MinciuSodas WikiMatrix PatrickAnderson AndriusKulikauskas

Languages: