Following research notes #1

The goal is to perform symbolic inference over analogies recorded within the system.
Presently, associative analogies are the focus, though this also applies to other forms of analogies, like Catagorical analogies. More on that later.

Those associative analogies essentially contain two Symbols, corresponding to left and right. Each of these two Symbols is not one identifier, but rather a set containing potentially many Members. Members reference ClaimIDs made previously within the Mindbase system.

For a given Associative Analogy, There is no pairwise association between the Member in these two sets – Only a single association between the two sets as a whole. It has been clear for some time that fuzzy sets / fuzzy logic would be necessary as part of the mindbase system.

One way to think about this fuzzyness is in terms of confidence of "sameness" or "correctness" but this is problematic, insofar as it assumes that there exists some god's-eye, or approximation thereof which can be used to adjudicate relative sameness in an absolute sense. This perspective is fraught with problems.

One of the core ideas of this project is that all things which can be observed within the universe are similar (at least pairwise) along some axes, and dissimilar along others. Whether those dimensions are spatial or ontological; whether observed from the world, or made from whole cloth (noting that even fictions are observations first.)

With this in mind, another way to think about fuzzyness is in terms of metric proximity in some dimension within an abstract metric space.

A Symbol for Hygge is proximate to a Symbol for Cozy within this metric space, but they are not the same. We must derive this proximity through measurement of analogies and anti-analogies between those symbols, but also by omission, presumably in the form of a relative-strength analysis with other symbols.

For instance, There may be some categorical analogies made between the English Symbols for Caliente and Picante, but those should necessarily be fewer and/or weaker than those between Hot and Scalding.

The outcome of yesterday's experimentation (#1) strongly implies that this scoring isn't just something which happens at query time. Indeed, such symbols are constructed as the product of queries, but are themselves used construct new Analogies. As such, the partial matching of one side of the associative Analogy should result in ALL of the Members from the other side being retained for their bound symbol variables, albeit with a lesser score than if the opposing side were a perfect match.

Some questions which follow from this:

• How should this score be calculated within a single candidate Analogy?
  • This scoring can't just be from Left to Right. We have to do the inverse as well. How does bidirectional scoring work?
  • How do we reconcile left-side matching=right-side-scoring with right-side matching = left-side-scoring? Hypothesis: Narrowing of the set of Members is done by same-side matching. Scoring of the remaining Members is done by opposite-side matching.
• How should we compose the bound symbol variable Members across multiple Analogies which are under consideration?
  • What about identical ClaimIDs which originate from different Analogies with different scores?
  • Should these be averaged, or otherwise be combined via some weighted sigmoid function?

Code quality and testing at present is not satisfactory for publishing to crates.io, even after the other blocking issues are resolved. This issue intends to track the process of cleaning up and documenting the codebase such that it is of a vaguely usable quality, sufficient for publishing as a public alpha.

from #7 we discussed the FuzzySet Signal-to-noise-ratio problem

One thing within the experimental code which is almost certainly wrong is the way unions are being performed across the output of each candidate Analogy interrogation. We must explore a more appropriate means of composing these candidate Analogy interrogation outputs in a weighted fashion, rather than simply taking the maximum degree of each discrete matching member into the final output FuzzySet. This is screwy, because we likely don't want Members from a small subset of candidate Analogies with a high degree of matching to compete on equal footing with a corpus of thousands with a low matching degree, as a simple maximum-degree of membership union might provide. (current code does this) However, we also don't want to attenuate the signal of such a well-matching subset of candidate Analogies as a simple weighted score would suggest either. Presumably there is some middle ground which must be found, whereby these considerations are balanced. Not a simple weighted score, and not a maximum-degree of FuzzySet membership either.

Let's imagine we interrogate three candidate Analogies and we are left with the following Symbols, which we are constructing manually here, but would be typically be analogy interrogation outputs created by the query tree.

    let io1 = sym![Hot1~0.3,Sticky1~0.2];
    let io2 = sym![Hot1~0.5,Muggy1~0.9];
    let io3 = sym![Hot1~1, Sticky1~1];

    // union the interrogation outputs together
    let u = Symbol::null();
    u.union(io1);
    u.union(io2);
    u.union(io3);

What do we want to have in the end, and why?

Should include the max of each degree?

    u is [Hot1~1,Muggy1~0.9,Sticky~1]

This doesn't seem very good. We want small signals to be boosted, but this might be a bit too much

Hot 1 is present in all input Symbols. Should we average them?

    u is [Hot1~0.6,..]

What about Muggy1, and Sticky1 - which are only present in some of the inputs?
Should we treat the sets which lack them as degree 0, and include those in the average?

    u is [Hot1~0.6, Muggy1~0.3, Sticky1~0.4]

Or should we average them individually based on their non-null set membership?

    u is [Hot1~0.6, Muggy1~0.9, Sticky1~0.6]

Let's take a step back. What do each of these input symbols represent?

Each symbol represents one side of an analogy which a trusted (ground) Agent previously Claimed. Each member of which had its degree determined by some prior query, presumably by that Agent, wherein a partial match of claims was had.

This could come about a number of different ways, but the simplest construction of events is:

a1hot : Symbol = Agent1.query("Hot");
    // TODO - construct a full chain of events (including genesis Claims) by which Symbol members of a degree <1 are constructed, and then Claimed as new Analogies
    // From there we can determine the most prudent implementation of union, such that we optimize the signal-to-noise ratio

As it turns out, binding symbol variables has opened an interesting can of worms regarding the matching of previously-defined analogies, and the representation of matched elements as a Fuzzy set within the resultant symbol. See #1 and #3 for details

In order to serve its purpose, Mindbase must perform symbolic inference over analogies recorded within the system.

In MBQL this would look like:

$x = Bind("Hot")
$y = Ground($x : "Cold")

This means we wish to construct a Symbol $x containing all Members which are referenced by previously-defined associative analogies opposite the text Artifact "Cold"

Crucially, note that the text Artifact itself is not what is being referenced, but rather an instantiation or Claim of the Artifact. Artifacts themselves are just buckets of bits, and are devoid of any kind of Internal Meaning

Symbol $y captures the set of those Alledged Analogies which contributed to the match – In the above case representing the relationship between the "Hot" and "Cold" symbols.

from mindbase/experiments/analogy_compare/main.rs:

    // In this experiment, we are approxmiating the following MBQL
    // $x = Bind("Hot")
    // $y = Ground($x : "Cold")

    let mut x = Symbol::null();
    let mut y = Symbol::null();

    // For simplicity, lets say these are all the analogies in the system
    let candidates = [Analogy::new("a1", sym!["Hot1"], sym!["Cold1"]),
                      Analogy::new("a2", sym!["Hot2"], sym!["Cold2"]),
                      Analogy::new("a3", sym!["Cold3"], sym!["Hot3"])];

    // NOTE - this should have an unassigned Spin, because it's a match pair
    let search_pair = FuzzySet::from_left_right("Hot", "Cold");
    println!("Searching for {}", search_pair.diag_lr());

    for candidate in &candidates {
        let v = candidate.intersect(&search_pair).expect("All of the above should match");
        x.members.extend(v.left());

        y.members.insert(Member { id:   candidate.id.clone(),
                              spin: Spin::Up, /* This is WRONG for a3. It should be Down because the order of the association
                                               * is reversed. how do we fix this? */
                              side: Side::Middle, });
    }

    println!("symbol x is: [{}]", x.members.diag());
    println!("symbol y is: [{}]", y.members.diag());

Which renders:

This is wrong, because we get an x value of [Cold3˱↓,Hot1˱↑,Hot2˱↑] when we should get [Hot1˱↑,Hot2˱↑,Hot3˲↓]

y is also wrong. We get [a1ᐧ↑,a2ᐧ↑,a3ᐧ↑] when we should get [a1ᐧ↑,a2ᐧ↑,a3ᐧ↓] indicating that a3 is included, but with reversed polarity, because the order of the associations is the opposite of the search criteria.

See this code in the rust playground

Questions and notes for next time:

• How do we fix Analogy::intersect to render the right results for x and y?
• How does this compose across multiple levels of Associative analogy? Eg ("Smile":"Mouth"):("Wink":"Eye")
• An associative Analogy involves two FuzzySets of Members (Left and Right) which are NOT associable pairwise as Members, only as whole sets. This is because each FuzzySet represents a symbol in its own right.
  • Given a perfect match of left-handed Members, all right-handed Members can be safely inferred.
  • Given a PARTIAL match of left-handed Members, The entirety of the subset the right is inferred, but with a lesser degree of confidence, commensurate with the number of left-handed matches. The inverse is true as well of right handed matches.
  • With what data structure do we represent this partial matching, and how does that compose in the aforementioned situation? Presumably via some recursive confidence score

At present, Mindbase uses sled, which works fine for native use cases.

This issue intends to track storage engine modularization, sufficient to use mindbase in HTML5 WASM environments.

Hello, Great work so far! I can't wait to try it out on my desktop.

When you get the chance, could you add build/run instructions so I can try it out?

Following on Notes #1 and #3 ...

Within the analogy_compare experiment, I have managed to get Analogy querying working, such that a candidate analogy may be tested against an AnalogyQuery struct.

This now successfully provides the correct results:

fn experiment() {
    // In this experiment, we are approximating the following MBQL
    // $x = Bind("Hot")
    // $y = Ground($x : "Cold")

    let mut x = Symbol::null();
    let mut y = FuzzySet::new();

    // For simplicity, lets say these are all the analogies in the system
    let candidates = [//
                      Analogy::from_left_right("a1", sym!["Hot1", "Hot2", "Heated1"], sym!["Mild1", "Mild2", "Cold3"]),
                      Analogy::from_left_right("a2", sym!["Hot3"], sym!["Cold1", "Cold2"]),
                      Analogy::from_left_right("a3", sym!["Cold3"], sym!["Hot3"])];

    // Imagine we looked up all ClaimIDs for all Claims related to Artifacts "Hot" and "Cold"
    // query is an AnalogyQuery struct, which contains a FuzzySet<AnalogyMember>. 
    // from_left_right constructs an AnalogyQuery with one AnalogyMember per each ClaimID "Hot1", "Hot2", etc 
    let query = AnalogyQuery::from_left_right(sym!["Hot1", "Hot2", "Hot3"], sym!["Cold1", "Cold2", "Cold3"]);
    println!("Query is: {}", query);

    for candidate in &candidates {
        let v: FuzzySet<analogy::AnalogyMember> = candidate.interrogate(&query).expect("All of the above should match");
        println!("v is {}", v);
        x.set.union(v.left());
        y.union(v);
    }

    println!("symbol x is: {}", x);
    println!("symbol y is: {}", y);
}

Which renders the following:

Query is: [Hot1~1.00, Hot2~1.00, Hot3~1.00 <-> Cold1~1.00, Cold2~1.00, Cold3~1.00]
v is [Hot1~0.33, Hot2~0.33 <-> Cold3~0.67]
v is [Hot3~0.67 <-> Cold1~0.33, Cold2~0.33]
v is [Hot3~0.33 <-> Cold3~0.33]
symbol x is: {Hot1~0.33, Hot2~0.33, Hot3~0.67}
symbol y is: [Hot1~0.33, Hot2~0.33, Hot3~0.67 <-> Cold1~0.33, Cold2~0.33, Cold3~0.67]

When both sides of the candidate analogy match the query to at least some degree, we are including the matching terms from each side, but we have to scale its degree within the output set based on the degree of the match on the opposite side.

With that in mind, we can see that the first candidate Analogy experiences a 2/3 match to the members of the left side of the AnalogyQuery and a 1/3 match to the right side. That means we want to scale those matching members of the right by the degree of the match on the left, and vice versa. Thus yielding [Hot1~0.33, Hot2~0.33 <-> Cold3~0.67]

(Of course, if either side of the AnalogyQuery has a zero degree of matching, then the candidate Analogy is fully rejected, and there is no resultant FuzzySet for that candidate.)

So, why do we want to do this scaling of output members within the set by the degree of the opposing side? This is because an Analogy creates an associative relationship between the Left Symbol and the right Symbol (both of which are themselves FuzzySets, at least before we convert them into a "sided" fuzzyset within the Analogy).

We expressly lack pairwise relationships between members of these two FuzzySets, because each one represents some abstract concept. We are inferring the applicability of the right side based on the matching of the left side, and vice versa. It therefore stands to reason that such inference be scaled by the strength of the match of the opposing symbol.

A brief digression on Symbols:

A Symbol represents / abstracts some concept by constraining degrees of freedom within a highly dimensional semantic space with its Members, and their respective degrees.

When I conjure the abstract notion of a "Dog" within my mind, there is some ephemeral meaning which is constrained in its degrees of freedom based on an elaborate unspoken context. Maybe I was thinking of the fur, plus a specific dog from childhood, plus the abstract idea of kinship with another creature, plus several other dimensions which I would have difficulty articulating.

Even if we imagine that a "Perfect" brain-computer interface magically existed, the concept which I conjured would still occupy a more or less fuzzy region within semantic space which has been constrained to some degree. This is not a question of perfect rendering. While the region within said semantic space may be more sharply or dully partitioned, said boundary cannot ever be fully crisp. That we clamp that degree between 0.0 and 1.0 is merely an implementation detail rather than a representation of actually-perfect confidence or non-confidence.

Weighted union of candidate Analogies

One thing within the experimental code which is almost certainly wrong is the way unions are being performed across the output of each candidate Analogy interrogation.

We must explore a more appropriate means of composing these candidate Analogy interrogation outputs in a weighted fashion, rather than simply taking the maximum degree of each discrete matching member into the final output FuzzySet.

This is screwy, because we likely don't want Members from a small subset of candidate Analogies with a high degree of matching to compete on equal footing with a corpus of thousands with a low matching degree, as a simple maximum-degree of membership union might provide. (current code does this)

However, we also don't want to attenuate the signal of such a well-matching subset of candidate Analogies as a simple weighted score would suggest either. Presumably there is some middle ground which must be found, whereby these considerations are balanced. Not a simple weighted score, and not a maximum-degree of FuzzySet membership either.

For the time being, I will call this the Fuzzyset-union signal-to-noise ratio problem.