[TeMPOraL]

Do pro/con trees actually work in real life? I played with something like this when using Kialo for a while, and my impression was that this technique doesn't help much. Shoehorning everything into a pro or con is one thing, duplication of points in many places in a tree is another.

I abandoned Kialo with a conclusion that pro/con trees don't map well to reality; we need graphs of facts and their relationships.

(Also, my gut feeling is that when you're talking about "arguments" instead of "facts", "evidence" and probabilities, you're in business of convincing, not truth seeking).

But that's not to diss this project. As an implementation of pro/con trees it's excellent, and I'd prefer typing in this language a millon times more than clicking around Kialo.

[derefr]

> duplication of points in many places in a tree

It seems (but I might be wrong) that this syntax allows for nodes to also reference other nodes rather than embedding them (see e.g. the third example on the page, though it’s too trivial to tell if that’s what it’s doing for sure.) I think they expect you to draft the argument map, then go back over it and iteratively reduce it by manually normalizing duplicate sub-arguments into one canonical sub-argument in one place + references to it in other places.

> Also, my gut feeling is that when you're talking about "arguments" instead of "facts", "evidence" and probabilities, you're in business of convincing, not truth seeking.

Usually the point of this kind of software (argument-mapping software) is to, first, efficiently capture an argument that exists, either as a sort of “court stenographer” during the argument, or from a recording after the fact. You want the tree of pros and cons (really, rebuttals / consequents / syllogisms / a bunch of other smaller categories) because you’re trying to capture the structure of the discussion itself.

Then, once you have captured that structure, argument-mapping software has tooling to allow you to massage (refactor!) the discussion from its original shape, into one that lets you more efficiently get at the truth. Turn things graphical, assign arguments weights, unify duplicate branches, etc.

Argument mapping is not just about pro/con trees; but pro/con trees are a nearly-lossless way to capture how people actually debate things, so they’re a good “ingested primary source” format to keep around and refer back to when you’re trying to summarize and judge a debate (rather than having to listen to the audio transcript over and over, or read through a linear stream of debate text.)

[ChrisKor]

> Argument mapping is not just about pro/con trees; but pro/con trees are a nearly-lossless way to capture how people actually debate things, so they’re a good “ingested primary source” format to keep around and refer back to when you’re trying to summarize and judge a debate (rather than having to listen to the audio transcript over and over, or read through a linear stream of debate text.)

We have used Kialo for exactly this. The parties that we suspect to start quarrelling about a decision have to capture their reasoning in a Kialo and send it to everybody before the actual meeting. And then we use the Kialo tree as a source document during the meeting. And if new arguments are brought up, the person taking notes just adds them.

Or if a heated debate ensues, one person starts mapping the arguments in Kialo, for later reference.

One problem we ran into though, is that older management folks seem to prefer traditional meeting notes, instead of hipster pro/con trees. Also, argument trees don't allow for nice print outs.

[TeMPOraL]

Huh, I haven't thought of using them as an input format, a form that matches the typical structure of a discussion. Thanks!

> I think they expect you to draft the argument map, then go back over it and iteratively reduce it by manually normalizing duplicate sub-arguments into one canonical sub-argument in one place + references to it in other places.

That can work with this application/language. It doesn't work with Kialo, unfortunately, where you had different people contributing different nodes of the tree and AFAIR maybe, sometimes, someone then going over the tree and cleaning it up.

> Then, once you have captured that structure, (...) massage (refactor!) the discussion (...) into one that lets you more efficiently get at the truth.

One thing I tried to say is that I believe an argument tree isn't a right end format here, both because it's about arguments (vs. facts and their relationships), and because it's a tree. I think the end format must be a directed graph, very likely containing cycles (mutually supporting arguments).

Why I don't like arguments in the final format? Because they're kind of like an applied function. They hide the parameters. You can decompose an individual argument into pieces of facts and their relationships; an argument takes those, and assigns hidden weights to them - you care about some facts and relationships more than others, and this is usually implicit in the argument (and a source of confusion when doing this multiplayer, a-la Kialo).

I think it'll be more productive to decompose the arguments and deduplicate the resulting graph, and then work at the facts-and-relationships level. The benefits are that all components are now much easier to objectively verify, and whatever conclusion you then read out of this graph could be validated easier.

Note I just think that it'll work better, I haven't really tried it. I have on my TODO list somewhere to take a particular nontrivial topic, like e.g. "animal suffering"[0], and try to decompose it this way to see whether this format will actually work in practice.

--

[0] - It's a topic on which I have no formed opinion at this point, only bunch of inconsistent feelings and heuristics, so I shouldn't have too many preconceptions and biases here. It also seems hard enough to teach me something about myself.

[SiempreViernes]

>directed graph [...] containing cycles

Can you clarify what you mean with cycles? As written it sounds like you think sound arguments contain circular reasoning...

I can see a branching opening and closing in a unidirected graph being the result of a sound argument^, but since you cannot move freely in both directions I don't know if it would count as a cycle.

^ The argument being: some process has a positive an negative effect (one thing happens, another thing never happens), the positive and negative effects are observed in nature, supporting the conclusion that the process in fact is the cause of the two effects.

[TeMPOraL]

Feedback loops.

I don't think modelling "from argument X follows argument Y" is productive; what's productive is modelling that observable phenomenon X is correlated with Y, or causes Y, or has this-and-that impact on Y. At this level, things can be stuck in feedback loops, either positive or negative.

Will increase in coal exports of Poland increase Poland's CO₂ footprint? Let's try to model it the way I think about it:

     Coal exports
          ^
          | [provides Z coal to]
          |
          |     [needs α*X = A kWh for coal]
     Mining coal <---------------------\
          |                            |
          | [provides X coal to]       |
          v                            |
   Coal power plants                   |
    |     |                            |
    |     | [γ*X = Y kWh burning coal] |
    |     v                            |
    |  Electricity --------------------/
    |
    | [burned coal into β*X = N kg of CO₂]
    v
  CO₂ emissions

You have a cycle there: Mining coal -> Coal power plants -> Electricity -> Mining coal. Given A < Y, it's a negative feedback loop. It's a cycle that exists in real life (and the basis of the concept of EROI)!

If this were a reactive model, you could tweak the value of Z to see how X, Y, A and ultimately N change. But even without reactivity, you can clearly see that the answer to original question is "yes, increasing coal exports will increase Poland's carbon footprint". And there's little left open to interpretation or accusations of subjectivity.

If you don't like the answer that the model gives, it also makes some alternative strategies apparent! In this case: can we find a way to reduce α or β to compensate? Or increase γ? Or maybe add an alternative CO₂ sink for the Coal power plants -> CO₂ emissions edge? Note that these alternative strategies involve manipulating reality, not your argument.

I think we should be doing more of this kind of modelling. Building more accurate maps of the world, and reasoning straight from them, instead of trying to build complicated webs of arguments.

[blattimwind]

> (Also, my gut feeling is that when you're talking about "arguments" instead of "facts", "evidence" and probabilities, you're in business of convincing, not truth seeking).

Depending on context pro/contra is probably what can be generated from facts when comparing things, so facts should be persistent, pro/contra dynamically generated.

[TeMPOraL]

Yes, I came to the same conclusions. Pro/contra trees look like an answer to a query on the graph.

One thing I find manually written pro/contra trees don't capture is that the same observation can be simultaneously a pro and a contra, or can flip between being pro and a contra depending on strength of that observation, or surrounding context.

Ultimately, I find those trees a nice visualization, and writing them an interesting exercise in structuring your thoughts, but I'm not convinced whether or not they're helpful at getting to the truth.

[jmiskovic]

Are you aware of other tought structuring tools, that are better for 'getting to the truth' as you say it? I haven't yet found a proper structure for purposes of collecting and categorizing ideas, and for reasoning about them.

A tree structure is great for it's simplicity. It maps well to most use cases I need, but not all of them. A strict tree is too limiting and cannot avoid duplication. I'd like a tool that could build a structure that is almost-a-tree would be visualized as a tree, but it would allow a special case linking between any two nodes.

A general graph lacks the necessary structure. Without the structure, the tool isn't really supporting me and I can just use the yEd graph editor. I could use some queries on the graph to shape it into tree on demand, but then I lose mind's spatial ability to navigate the graph.

[TeMPOraL]

No, I'm not aware of better tools. I'm beginning to feel like I should start prototyping one.

I though about this topic a bit on numerous occasions, and I keep feeling that trees don't map well to this use case. I still think a directed graph is necessary, and likely one supporting cycles. The structure will be imposed by reality itself. Anything less than a directed graph will fail to capture causal relationships between entities.

yEd... well, I spent a lot of hours with yEd Live recently, and I have complaints :). Like, where's the ability to simply place a piece of text on a diagram as a node?! It's ironic, but it seems to me that in 2019, there still isn't a good tool implementing the simple concept of infinite, pannable, zoomable canvas for typing on it and building arbitrary directed graphs on it.

[jmiskovic]

Lately I've started using DrawExpress mobile app. It fits your description. A bit finicky, but I've adapted to its quirks. Swiping keyboard on phones is a quick way to enter a bit of text on node, and it fits well with gesture-based interface. The only problem, I find myself spending too much time manually arranging node positions.

Regarding structure, I agree with you that directed graph is most powerful. But for visualization and editing I would propose shaping graph into a tree. This reshaping can be done many ways, it's like a query into a DB. Here's a quick mockup made in yEd: https://i.imgur.com/LGTNbuz.png

While directed graph is necessary for internal data representation, tree structure is a perfect fit for many specific cases: categorization; argumentation (like this HN thread); tagging/grouping; lisp s-expressions. Trees capture those things beautifully, while enabling easy navigation with arrow keys or finger swipe.

Reshaping into tree allows for some neat layouts. For example, by scaling geometry down with each child, your whole graph can fit inside predictable area, without any node overlapping. See more here: http://treevis.net/

One could add a reactive capabilities to each graph node. The node would respond to different triggers by changing it's attributes, or relations to other nodes. The graph/tree can be built step by step via triggering specific node responses (add child, delete node, connect/disconnect). Responses could also change node attributes, to bring interactivity and ability to simulate mental models.

This is what I'm working on in spare time, but these days the bread-bringing job drains my energy away :( \

Great thread, BTW.

[nathan_f77]

I've also been thinking about building a tool like this for a really long time. I would be interested in collaborating, so I'll send you an email!

[jmiskovic]

I've described a tool I'm currently designing in the sibling thread. I'm planning on building it in re-frame, which is basically React + Redux made for ClojureScript. I've learned Clojure just for this project, I could not make it work with any other language I knew. I'm currently learning Datomic because it might be the ideal way of capturing, growing and querying this knowledge graph.

We should join some kind of communication group to see if we are after the same thing, and to track each others progress. Maybe a new reddit group?

[fragmede]

I've used https://whimsical.com/ (no affiliation) to do mind maps, which is a GUI tool, and it supports doing arbitrary lines/arrows, but it's not super happy with doing that.

GraphViz will go from text to whatever tree-ish graphical representation you want, but naturally there is some time investment required, especially if you want pretty output.

[jmiskovic]

Just tried whimsical. It's impressive for online tool, but the UX is too slow for me. I need a fast visual tool to create graphs, GraphViz is just the rendering part. Thanks for suggestions, though.

[Brendinooo]

One thing I've been considering is that facts are used to support underlying assumptions that would be useful if coaxed out. Facts aren't arguments, they're neutral things that people pick and choose from to shape their worldview.

If I could conclusively establish that, on average, there's a 3% chance that your house is robbed this year, some people will view that as a risk to mitigate and some won't.

[manx]

I build a graph-based argument mapping system with community moderation with a friend as our CS master theses: https://github.com/woost/wust

I'm happy to discuss this whole topic with interested people, as I think it is a very important problem. I believe it may be possible in the long-term to fix politics with these kinds of technology. I wanted to do my PhD in this area, but wasn't able to get any funding. So I'm starting a Startup now, that does graph-based collaboration software (with the future hope to bring more focus into arugment mapping): https://app.woost.space

If interested, I can also send you my master thesis, just reach out per email.

[Brendinooo]

I have similar feelings about Kialo. I've been experimenting with a site concept that seeks to make canonical statements (fact/value statements, policy statements, questions) that could be associated with others while avoiding the pro/con binary. After all, one man's con can often be another man's pro, depending on the underlying assumptions, and things don't always fit neatly into those categories.

[Errancer]

"(Also, my gut feeling is that when you're talking about "arguments" instead of "facts", "evidence" and probabilities, you're in business of convincing, not truth seeking)."

That's funny since for me it's the other way around, in philosophy "facts" are taken with great suspicion but arguments are fine.

[duxup]

Some analytical types love these things and if they make a decision.... maybe that is enough.

I do find people who are analytical types sometimes greatly overestimate the "known" and underestimate the unknown / nuances.

[rcorrear]

A very long time ago I worked in https://groupidea.com/ where we tried solving this in a way much like the one you proposed.

[ChrisKor]

They actually do have linking[0] and map creators are usually quite anal about only having one instance of each argument in a map. So instead of accepting your suggestion they will just link the already present one there, which can be a bit annoying.

[0] https://www.kialo.com/its-possible-that-early-belief-in-the-...