I suppose we could assert that wherever a cycle is discovered, A subset of B subset of C subset of A, then all nodes in the cycle should be merged into a single node. Then we have a DAG. Any cycle that’s not so reduced would be breaking the rules, and the graph db would be not fully “normalized” (not sure if that’s the best word here). The reason for deviating from that and allowing cycles is UX. Suppose I develop the concept for cities. I want to arrange them by continent, and also by their official languages. And I want to visualize the tree of Sets in the page. On the left I arrange them by continent — cities in N America, cities in Europe, etc — and on the right I arrange them by language: cities that list English as an official language, cities that list French as an official language, etc. Any given city will be an element of more than one Set node. So at the top I’d have the Superset of all cities, then underneath two subsets: Cities that have an official language and Cities that are on a continent. Those two set nodes are each subsets of the other. (In theory they don’t have to be — there could be a city that’s not on any continent — but in reality, to the best of my knowledge, they are.) But we still keep them as separate nodes because it’s just better UX.

My guess (or at least my hope) is that you and I are coming at the same problem from two different angles. Like a theory of physics, where one person (me) starts with simple observations / physical assumptions, the other person (you) builds some abstract mathematical tools; at first these seem like totally unrelated ideas, and only later do they discover that the mathematical tools are needed to use (or even to state) the theory to its fullest extent. I still haven’t connected the dots. What do elliptic curves have to do with class threads? Should we expect a class thread to be points on an EC through embedding space? Or something like that?

Fiat: algos are hidden 🙈👎🏻 Freedom tech: algos are out in plain sight 😄👏🏻 How can we choose our algos if we have no idea how they work?

I just realized what I said is untrue: tapestry theory does not require the sets and subsets within a concept to be acyclic. The class_thread_propagation relationship type (one of the 3 main relationship types that define a class thread — the other two types being class_thread_initiation and class_thread_termination) can be interpreted as the statement that node A is a superset of node B (or conversely, node B is a subset of node A). And there is no rule that A and B cannot be subsets of each other, in which case they are equivalent (any element of one is an element of the other). I could say, for example, that the superset of all dogs (in my database) has subsets A and B, that A is a subset of B, and B is a subset of A. So I shouldn’t refer to it as a DAG. It’s directed, and a graph, and is probably acyclic in many cases, but definitely not always.

My 30-min talk at the first-ever Nostr Nights on Feb 2 about and our mission to bring decentralized reputation and web of trust to humanity is now available! https://bitcoinpark.com/nostr-nights/david-strayhorn-weaving-the-fabric-of-nostr.html

So “if this is true” — if time is quantized rather than continuous — then we don’t need to worry about our bitcoins being looted by the first person with a sufficiently powerful quantum computer … because why exactly? I am singularly unconvinced by this line of reasoning. It actually makes me worry that the smartest of us might have shifted gear from unraveling the delusions of the fiat narrative in favor of building new delusions of our own.

btw I messaged you in chat with some examples of basic cypher queries that we’ll want to use for the knowledge graph. That, and it would be useful for Orly to support bolt+s (I suppose I should add this as a feature request to the repo)

Reading you document … Part 4: Concept Lattice Seems closely related to the notion of a Concept, as defined by class threads in tapestry theory: a concept is the set of all nodes and edges traversed by the set of all class threads that emanate from a single node. So if the node is Widget, then an example of a class thread emanating from that node would be:. A second class thread might exist that starts and ends at the same nodes but traverses different subsets, eg: widget—>widgets—>round widgets—>my widget So class threads create a DAG that organizes things into sets and subsets. Which I think a lattice does too, right? The most important aspect of class threads is that the class header node (widget) and the superset node (widgets) must be distinct. The temptation is to merge them together into one node for the sake of simplicity, but that would be a mistake; you have to keep them separate if you want to integrate concepts the way that tapestry theory allows you to do. Seems like a mundane detail, but it’s important.

We’re live! https://zoom.us/j/91801428092?pwd=k5Gl2pYKX1X7GXPpiEdsEDaGIYsdvK.1

I don’t know the difference between a type and a category, or type theory and category theory, but I want to learn. Here’s a concept for you. Right now, in Orly, any single neo4j node probably has lots of information stored in multiple properties. Basically an entire nostr event, for the Event nodes. I have an idea that any given node can be “exploded”, or unpacked, or whatever we call it, which means we take the information in the node and put it into the graph. Which means it doesn’t need to be in the node anymore. Example: instead of each Event node having a tags property, we have Tag nodes (this is all stuff you’ve already built, of course). But here’s the question: how far can we take this process? Can we end up with a graph that is nodes and edges with *no data* inside any given node or edge? Other than — perhaps — a uuid? Or maybe instead of a uuid, a locally unique id? Suppose we call this state a “fully normalized” graph db. Will there be heuristics for when we desire full normalization and when we’ll want to break normalization, from a practical perspective? Like it’s more performant to retrieve tags when they’re packed as a property into an Event node than if we have to do a lot of cypher path queries?

#wotathon weekly community call starts in one hour!

Reasoning from first principles is always a good thing. But we have to recognize our cognitive limitations as individuals. I’d love to review every line of open source code that I’ll ever use but that’s never going to happen. The vast vast majority of what I know about the world is stuff that I’ve learned from other people. Topics like bitcoin I reason from first principles to the best of my ability, but I’ll never stop relying on trusted people to guide my thinking. I don’t have a strong opinion on core vs knots. And LukeJr can be kinda crazy. But he’ll always have my respect based on a few of the positions he’s taken in the past. Among them: the March 2013 unintentional chain split. Read the bitcoin-dev channel, he knew pretty much instantly what happened and what needed to be done, faster than most (including Gavin).

So step 1 is I gather all my files in a folder, then I point this tool at it? Is there a tool to help me gather them together? (Some are on nostr, some on github, some on substack, some on my local machine, etc)