Dialectic algorithm

From Wikiversity
Jump to navigation Jump to search
Graphic representation of a small debate tree, with sustained arguments painted green and refuted arguments painted red.

The dialectic algorithm[1] is a recursive algorithm[2] for computing the status (SUSTAINED or REFUTED) of any argument out of the structure of its debate tree. The algorithm captures the intuitive idea that an argument should be considered refuted when it has unrefuted objections, and sustained otherwise.

This article is aimed at merely describing the algorithm. To read about its usefulness, see the wikidebate here. To learn about the broader context of the algorithm, see the resources here.


Animation showing the dialectic algorithm as the debate grows. Notice how the leaves of the tree are always green.

Given a debate tree, the dialectic algorithm labels each argument as either SUSTAINED or REFUTED based on the following definitions:

Without sustained objections
With sustained objections

Considering that objections are also arguments, the algorithm will run recursively until the end of the debate (the leaves of the debate tree). Arguments at the end have no sustained objections (indeed, they have no objections at all) so they are labeled SUSTAINED, and the algorithm is then able to solve the status of all the other arguments.


The essence of the dialectic algorithm can be summed up in a simple, beautiful recursive function:

function getStatus( argument )
	let objections = getObjections( argument )
	for each objection in objections do
		if getStatus( objection ) === SUSTAINED then
			return REFUTED

The function calls itself recursively until it reaches the leaves of the debate tree. The leaves have no objections, so the algorithm returns SUSTAINED for each leaf and from there on solves the status for every other argument in the tree.

An alternative, boolean formulation may be:

function isSustained( argument )
	let objections = getObjections( argument )
	for each objection in objections do
		if isSustained( objection ) then
			return FALSE
	return TRUE


Below is an example of a small debate tree with the dialectic algorithm run on it.[3] Click on the argument to see the objections. The structure of the debate is the same as the structure of the graph in this article.

  • Causing unnecessary suffering on animals is morally wrong. Eating or otherwise exploiting animals is unnecessary and causes much suffering. Therefore, eating or otherwise exploiting animals is morally wrong and should be abolished.
    • Non-human animals have no feelings and suffer no pain.
      • Non-human animals behave very similar to us humans under circumstances that would cause us pain: they scream (or produce other loud noises), shake, contort, run, try to avoid the source of pain, etc.
      • Non-human animals, especially mammals and birds, have a nervous system very similar to our own.
    • Animals in the wild suffer more, as starvation and predation is a constant threat to them. For a natural equilibrium, all animal species living in the wild live at the brink of starvation, as an excess of food leads to their numbers increasing, then collapsing.
      • Animals in factory farms suffer guaranteed predation at a fraction of their natural life span. They don't lack food, true, but they are systematically mutilated, exploited, denied of basic freedom of movement, electrocuted, kicked, and many, many, many other atrocities. In traditional farms, animals are denied freedom of movement and reproduction, and also suffer guaranteed predation at a fraction of their natural life span.

See also[edit]

Notes and references[edit]

  1. The name of the algorithm comes from the concept of dialectics: a discourse between two or more people holding different points of view about a subject but wishing to establish the truth through reasoned arguments.
  2. A recursive algorithm is an algorithm which calls itself with "smaller (or simpler)" input values, and which obtains the result for the current input by applying simple operations to the returned value for the smaller (or simpler) input.
  3. The algorithm is run by DebateTree software for MediaWiki.