pure p-c mapper?

[jk11235]

I'm having trouble using argdown as just a premise conclusion argument mapper. The preview of the charts adds an extra "untitled" box and then crashes when I try to simplify one of your examples down to this:

(1) Freedom of speech is an absolute right. (2) Censorship violates freedom of speech. (3) Whatever violates an absolute right, is itself wrong in principle.

Modus Ponens, Specification {uses: [1,3]}

(4) Censorship is wrong in principle.

Maybe that is as designed, I am not sure. But is there a way to use it for pure simple p-c mapping? Or is there another tool you know of?

[christianvoigt]

This is definitely what Argdown is for. We use Argdown almost exclusively to reconstruct deductive inferences like that. As you have not used a fenced code block for your example it is hard for me to see what exactly went wrong, but there must be a syntax error in there (check the Problems view of VSCode or post it again as code block).

You can find a good example of how we use Argdown in the guide.

Argdown in itself is first and foremost a syntax for saving a certain kind of data that can be visualized in many different ways. You have complete freedom to choose which statements are visualized as nodes in your map.

By default, premise-conclusion-structures are not completely represented in our argument maps. This is by design as we are often visualizing complex debates where it is important to distinguish between what is really important to communicate and what is not. Adding all premises as nodes to the map, would make the map messy and reduce its usefulness (too many details can be confusing and the graph layout quickly gets messy). Our guideline is that we are only visualizing statements in the map that play an important role in the debate we are reconstructing (for example because they are at the center of the discussion or because they show the "weakest links" in an argument). It can make sense to produce different maps in which different aspects of a debate are visualized. These are all interesting "presentational" questions and most of the time putting everything in one map is the worst solution.

But if it makes sense to do so in your use case (maybe because you are printing a really big poster for example or because the reconstructed argumentation is not that complex) it is easy to configure Argdown to behave like you want it to. You will find all the details of how to select which statements are represented as nodes in your map in this section of the guide.

If you simply want to add all statements as nodes to your map, use the following option:

===
selection:
    statementSelectionMode: all
===

<a>

(1) [title]: I am selected
(2) I am selected
----
(3) I am selected
    -> I am selected
        + <b>

<a>
    - I am selected

[another title]: not very exciting, isn't it? // not selected

Don't hesitate to ask if you have more questions on how to make Argdown work for you.

[christianvoigt]

One more thing that might be confusing if you are coming from other mapping tools: In Argdown "arguments" are visualized as nodes in the argument map (and you should give them titles for a nice visualization). Arguments can contain single inferences but they can also contain chains of inferences. So they actually work like "inference folders" that can be used to "hide" complex inference chains (similar to how groups can be used to "hide" complex dialectical structures of several arguments).

All this is very useful to reduce the visual complexity of the map and focus on what are the important messages you want to communicate.

The closest you can get to the look of simpler argument mapping tools is to use arguments for only single inferences (as "links" between premises and conclusions) and use short titles for them (like "a1", "a2" and so on). Then use the statementSelectionMode "all".

Thinking about your question actually gave me an idea: I should add the option to hide argument titles completely so that they only appear as small connecting points between statements. That would make it easier to switch to Argdown coming from other tools that only represent single inferences as untitled nodes in the map (or visualize them like we visualize groups).

[jk11235]

(I was typing this when your second answer appeared.)

Thanks! Yes, I'm not wanting to represent whole debates at the moment, just one argument. (I can see how the larger units would be useful too, but it is something else. I'd found the " statementSelectionMode: all", so I've got that. Maybe the way to ask, if it is ok -- please feel free to say if this way of asking is not useful or helpful for you to consider -- to just say what I'm hoping for. I'd ideally like to type something as simple as this:

1. I exist
2. Everything has a cause
3. There is something that causes my existence (1, 2)
4. Some further premise
5. Some further conclusion (3,4)
6. Final conclusion (1,5) 

And then I'd love the preview to show some representation with arrows of the relations between these. I don't want any pros or cons or representations of a whole debate, for this purpose. And I don't think I want "titles" (I'm not sure what they are). I don't want to have to indicate "modus ponens" or similar. Just this kind of logical structure.

I'm not using any other tools at the moment -- they seem all to be graphically based, rather than text based. A thousand mouse clicks for one box.

One use for what I'm looking for is teaching. I often find myself (when in person, working with a computer and a projector), typing steps of an argument analysis into Word while students suggest ideas. Or I type a few steps and ask what is needed. Etc. And the class analyzes the argument together. Typing into word is fast, which is key in teaching. I don't want to have to click for boxes or draw arrows.

Actually, the dream (I know this is probably against the idea of a markdown language) would be to type text like the code above into a text editor which dynamically renumbers steps, if new ones are inserted in the middle, and dynamically renumbers references in parens, if the step numbers change), and dynamically draws arrows right next to the text to connect lines via those references.

Anyway, thanks for all you do and your answers.

[christianvoigt]

I totally get your use case it is exactly how @ggbetz and other philosophers in Germany are using Argdown in their argumentation courses. If you want to use the "statementSelectionMode" in all your Argdown files you can simply put a argdown-config.json in the directory you are saving your Argdown files in. The VSCode extension will automatically use your settings.

Here is an example:

{
  "selection": {
    "excludeDisconnected": false,
    "statementSelectionMode": "all"
  },
  "map": {
    "statementLabelMode": "text"
  },
  "model": {
    "removeTagsFromText": "true"
  }
}

Here is your example with using correct Argdown syntax:

<Title of this argument in angle brackets>: Some optional short description of the gist of the argument (simply remove this text and the colon if you don't want to use it)

(1) I exist
(2) Everything has a cause
----
(3) There is something that causes my existence (1, 2)
(4) Some further premise
----
(5) Some further conclusion (3,4)
----
(6) [Some statement title]: Final conclusion (1,5) 

Your dream features are sadly not implemented in the Argdown VSCode extension (because it is not easy to do so in VSCode). I agree that these features would be nice. Maybe someday someone writes a different editor for Argdown files that will support them.

(Edited: I misspelled the filename argdown-config.json. You can read about configuration files here.) (Edited again: Sorry, I used the wrong list format (no brackets))

[jk11235]

Interesting! Some day I'd like to learn more about @ggbetz 's teaching. When I try your sample:

 <Title of this argument in angle brackets>: Some optional short description of the gist of the argument (simply remove this text and the colon if you don't want to use it)

(1) I exist
(2) Everything has a cause
----
(3) There is something that causes my existence (1, 2)
(4) Some further premise
----
(5) Some further conclusion (3,4)
----
(6) [Some statement title]: Final conclusion (1,5) 

I can't get it to work. Both map previews are empty, and the html shows just this:

<Title of this argument in angle brackets>: Some optional short description of the gist of the argument (simply remove this text and the colon if you don't want to use it)
I exist
Everything has a cause

[christianvoigt]

I just copy & pasted it into the sandbox and it showed the argument and conclusion as nodes in the Viz.js map (the conclusion is added because it has a title and by default, titled statements are visualized). Please check the Problems view in VSCode for any syntax errors.

Be careful about separating Argdown blocks with empty lines, not single line breaks (in this case there has to be at least one empty line between the argument title and the first premise and no empty line between the statements in the premise conclusion structure).

Normally Gregor Betz would probably be glad to tell you more about his teaching methods, but at the moment I fear he is too occupied because of the pandemic...

[jk11235]

Ok, I got it to render again.

One thing: where you say "simply remove this text and the colon if you don't want to use it", if it is removed preview keeps an extra square there and just calls it "untitled"

More importantly for my purposes, the logical structure is not represented: each premise just has an arrow going to the final conclusion. There's no arrows to show which premises support a mediate conclusion, etc. I take it that this is by design, and that it isn't made to represent this kind of logical structure, but thought I would check.

I'm pretty overwhelmed by the pandemic as well. But I'm normally (non-pandemic) in Germany in May/June so maybe will look for events of his group if I'm in SW Germany again.

[christianvoigt]

One thing: where you say "simply remove this text and the colon if you don't want to use it", if it is removed preview keeps an extra square there and just calls it "untitled"

If there is no description, an argument title looks like this (by the way, the documentation of the syntax is really extensive, have a look! ;)):

<My title>

(1) first premise
...

More importantly for my purposes, the logical structure is not represented: each premise just has an arrow going to the final conclusion. There's no arrows to show which premises support a mediate conclusion, etc. I take it that this is by design, and that it isn't made to represent this kind of logical structure, but thought I would check.

Yes, semantic relations to/from intermediary conclusions can not be visualized. This is why you have to put every inferential step into its own argument if you want to visualize the internal logical structure of a complex argumentation.

I'm pretty overwhelmed by the pandemic as well. But I'm normally (non-pandemic) in Germany in May/June so maybe will look for events of his group if I'm in SW Germany again.

Great! I am closing this issue for now. I hope you will find Argdown useful and it would be great to hear about your user experience if you decide to try it out in a teaching context.

[christianvoigt]

Hi @zoechow, I have just released v1.7.0.

Our discussion here was the inspiration for new features that should make Argdown much more useful for your use case. I wrote a new chapter in the guide about this, but among other things I added the option to split arguments into their inferential steps so that you can visualize their inference trees.

Take a look and tell me what you think!

[jk11235]

Wow! Ok. This is looking pretty cool. I attach a pic of me trying to throw some complexity at it, and (once I got the hang of it) argdown visualizing it nicely!

As for the other aspects of my dream tool, I think we have already discussed that a markdown approach isn’t going to give them. That was, in particular, auto-numbering and re-numbering—as when you type a list into Word, and add an extra item in the middle. And, also, auto-re-numbering of what statements were used. E.g. if I add a statement in between 1 and 2, the old 2 is automatically numbered 3, and anything below that uses 2 is automatically revised as now using 3.

So I will have to think about whether I can teach my fingers to write argdown fast enough to use this in teaching when working collaboratively with a group of students to analyze arguments on the fly – and whether the complexity involved in adding a missing step, and catching all the needed revision to the uses: codes – would this just be too much of a time-sync for teaching? Or, maybe, it would actually be really good for the students – getting them to actually focus better on the logic in the argument. It might be really good! For they would find renumbering easier than understanding e.g. Spinoza, or whatever we are looking at. And getting the students who have more trouble to engage with the easier task might actually trick them, as it were, into engaging more with e.g. Spinoza. (Incidentally, about Spinoza, his geometrical method in writing is kind of argdown-like, and I thought I’d forward this beatiful visualization in case you hadn’t seen it: http://ethica.bc.edu/#/visualization)

I will certainly report back if I try to use this in class. I don’t teach until Fall. And no one knows what the conditions will be. I’m hopeful that everything will go well, most profs and students will be fully vaccinated by then, and we will be mostly back to normal in the Fall. But there’s any number of biology, business, or political curve balls that could hit us.

Thanks!! Jim

---

Jim Kreines Professor of Philosophy Claremont McKenna (he, him, his) [cid:image002.png@01D7100F.A3FC8C30]

From: Christian Voigt notifications@github.com Sent: Monday, March 1, 2021 10:52 AM To: christianvoigt/argdown argdown@noreply.github.com Cc: Kreines, James James.Kreines@ClaremontMcKenna.edu; Mention mention@noreply.github.com Subject: Re: [christianvoigt/argdown] pure p-c mapper? (#209)

Hi @zoechowhttps://github.com/zoechow, I have just released v1.7.0https://argdown.org/changes/.

Our discussion here was the inspiration for new features that should make Argdown much more useful for your use case. I wrote a new chapterhttps://argdown.org/guide/creating-oldschool-argument-maps-and-inference-trees.html in the guide about this, but among other things I added the option to split arguments into their inferential steps so that you can visualize their inference trees.

Take a look and tell me what you think!

— You are receiving this because you were mentioned. Reply to this email directly, view it on GitHubhttps://github.com/christianvoigt/argdown/issues/209#issuecomment-788185027, or unsubscribehttps://github.com/notifications/unsubscribe-auth/ADILZGBY3QADCKHRFJBJIWDTBPO6LANCNFSM4XQ7JAIQ.