# Reductio Ad Absurdum - A Judicial Simulation

**On this page**

## As Originally Rendered

- an abbreviated copy.

## Reductio Ad Absurdum - A Judicial Simulation

The **qnarre** narrative analyzing software operates on flat text statements represented by lists of sentences. The input **evidence** of a qnarre session is the list of all statements to be considered.

These statements are further grouped into an ordered list of **docs** of pages and paragraphs. The docs are persisted in varied formats in a hierarchical and rooted directory structure.

## Claims and credibility

When a statement is assigned a **credibility** in qnarre, it becomes a **claim**. Credibility is an ordering of all claims defined to intuitively reflect that, for example, a police report or an allegation made during a trial in Court can be trusted more than a casual verbal opinion overheard on the street.

All docs in qnarre belong to a **genre** (e.g. letter, motion, affidavit, judgment, etc.) that implicitly weighs all contained claims of the doc with an inherent, default credibility.

Claims can also be assigned incidental **weights** that fine-tune their individual credibilities. To model a doc of a specific genre, and containing 100 random claims, we can run the Python code presented below.

Before any of our simulations can be tried, or repeated with changed parameters, our environment needs to be initialized:

```
import numpy as np
import numpy.random as r
import matplotlib.pyplot as plt
%matplotlib inline
```

Also, let’s create 5 genres represented as their credibilities

```
genres = (2, 3, 5, 6, 9)
```

We define a function to conveniently create a new doc:

```
def new_doc(depth):
genre = genres[r.randint(len(genres))] # random genre from our list
sigma = r.sample() # standard deviation from a uniform distribution
claims = r.normal(genre, sigma, depth) # and the list of claims
return genre, np.absolute(claims)
genre, claims = new_doc(depth=100) # create a doc with 100 claims
```

Let’s plot this, the chart will be randomly different with every run

```
_, ax = plt.subplots(figsize=(12.8, 4.8))
ax.set_title('doc: genre={}, claims={}'.format(genre, len(claims)))
ax.set_xlabel('claims')
ax.set_ylabel('credibility')
yellow_l = '#ffe700'
yellow_d = '#ffbe00'
x = np.arange(len(claims))
y = claims
ax.plot(x, y, color=yellow_d, label='credibility')
ax.fill_between(x, y, color=yellow_l)
ax.legend()
plt.show()
```

The code above, and below, relies on randomly synthesizing varied data, or “sampling” from already created lists of values. These processes are defined in terms of their parameters.

## Simulation parameters

All our simulations are thus driven by our input parameters and/or weights. Parameters and weights are real numbers, or Python `floats`

. Some are from the interval [0,1] and can thus be directly used as `prior`

probabilities.

Such parameters are:

- the number of docs in an input evidence is reflected by its
**breadth** - the number of claims in any specific doc is influenced by its
**depth**.

To model an evidence of random docs with those parameters, we can run:

```
def new_docs(breadth, depth):
docs, claims = [], []
for _ in range(breadth): # create each doc of credibilities
_, cs = new_doc(depth)
docs.append(cs)
claims.extend(cs)
return docs, np.array(claims), breadth, depth
docs, claims, breadth, depth = new_docs(breadth=20, depth=100)
```

Let’s plot this

```
_, ax = plt.subplots(figsize=(12.8, 4.8))
ax.set_title('docs: breadth={}, depth={}'.format(breadth, depth))
ax.set_xlabel('claims')
ax.set_ylabel('credibility')
light, dark = yellow_l, yellow_d
offset, color = 0, dark
for d in docs:
x = np.arange(len(d))
color = light if color is dark else dark
ax.fill_between(x + offset, d, color=color)
offset += len(d)
plt.show()
```

The chosen simple probability distributions for the samples are noted through the choice of functions used. Numpy documentation provides further details.

More sophisticated, `generic`

and even `conjugate`

probability distributions can be easily plugged in to properly reflect inherent covariance and contravariance present in the data.

## Authority and “proven-ness”

The credibility of a claim can be further enhanced by citing an `authority`

. Such authority “witnessing” a claim will turn the claim into a **proof**. The `weight`

of a proof derived from the authority is the enhancing factor of the underlying claim.

The percentage of proofs in an evidence is its **proven** parameter. To model an evidence witnessed, and thus proven, by authorities, we can run:

```
import math
def new_proofs(proven, weight=2):
nc = len(claims)
np = math.floor(nc * proven)
pis = sorted(r.choice(nc, (np, ), replace=False))
return [(i, max(claims[i], 1) * weight) for i in pis], proven
proofs, proven = new_proofs(proven=0.04)
```

Let’s plot this

```
_, ax = plt.subplots(figsize=(12.8, 4.8))
ax.set_title('proofs: proven={}'.format(proven))
ax.set_xlabel('claims')
ax.set_ylabel('credibility')
green = '#408e2f'
x = np.arange(len(claims))
y = claims
ax.fill_between(x, y, color=yellow_l, label='credibility')
x, y = zip(*proofs)
ax.vlines(x, 0, y, color=green, label='proof')
ax.legend()
plt.show()
```

Claims can be further categorized through `topics`

. Grouping together varying topical claims and related proofs improves the understanding of the overall context in an evidence.

## Reality and coherence

**Realities** are such contextual claims encapsulating the inherent, or readily and verifiably inferenceable, “common sense” credibilities.

The percentage of realities of all claims in an evidence is generated from its **contextual** parameter.

A reality, through the thus logically concluded credibility measure called its **coherence**, adds to the overall **certainty** of a simulation. We represent this `certainty`

with a natural value of `1.0`

and as an obvious upper bound of our charts and simulated “worlds”.

Assuming that normal and balanced **ambiguity** rules before an evidence is ever considered, we can model how the realities of an evidence drive the overall understanding from `ambiguity`

to `certainty`

as follows.

Note that `ambiguity`

has become our starting point, the “origin” and baseline with a natural value of `0.0`

across the charts:

```
from scipy.ndimage.filters import gaussian_filter1d
def new_reality(claims, proofs, contextual):
lc = math.ceil(len(claims) * contextual / 10)
c = np.sum(r.choice(claims, (lc,)))
lp = math.ceil(len(proofs) * contextual)
return (c + np.sum(r.choice(proofs, (lp,)))) * contextual
def new_realities(contextual):
cis = set(range(len(claims)))
pis, ps = zip(*proofs)
cis = cis.difference(pis)
lr = math.floor(len(cis) * contextual)
ris = sorted(r.choice(list(cis), (lr,), replace=False))
cis = cis.difference(ris)
cs = claims[sorted(cis)]
rs = [claims[i] + new_reality(cs, ps, contextual) for i in ris]
rs = np.array(rs)
rmax = np.max(rs)
rs *= (1 + contextual / 10)
rs /= rmax
return [(j, rs[i]) for i, j in enumerate(ris)], rmax, contextual
realities, rmax, contextual = new_realities(contextual=0.1)
```

Let’s plot this

```
_, ax = plt.subplots(figsize=(12.8, 4.8))
ax.set_title('realities: contextual={}'.format(contextual))
ax.set_xlabel('claims')
ax.set_ylabel('coherence')
blue = 'blue'
x = np.arange(len(claims))
cmax = np.max(claims) * 3
y = claims / cmax
ax.fill_between(x, y, color=yellow_l, label='credibility')
x, y = zip(*proofs)
ax.vlines(x, 0, y / cmax, color=green, label='proof')
x, y = zip(*realities)
y = gaussian_filter1d(y, sigma=10 * contextual)
ax.plot(x, y, color=blue, label='coherence')
# And now our bounds for the world of trials:
ax.hlines(1, 0, len(claims), linestyles='dotted', label='certainty')
ax.hlines(0, 0, len(claims), label='ambiguity')
ax.legend()
plt.show()
```

## Conflicts and deliberate fragmentation

“*Conflict is opportunity*”: good attorneys find intrinsic contradictions and conflicts in lawsuits and creatively expose the consequences, thus elevating or plausibly projecting neutral `ambiguity`

to `certainty`

. Judgments are then reproducibly made without further consequences and attorneys reap the rewards.

Without such conflicts, or the ability to find them, attorneys starve. Less capable yet “ambitious” or `malicious`

attorneys professionally (i.e. “credibly”) create, or plainly `fabricate`

, artificial conflicts.

Such artificial **conflicts** are thus the fabricated claims that knowingly and purposefully hook into and then graft onto specific perceived realities of an evidence.

The objective of a [fabricated] `conflict`

is to sow fear, uncertainty and doubt. A conflict, through its intended “credibility”, defined hereon as its **fragmentation** measure, adds to the overall **absurdity**, or the level of confusion in the evidence and all its simulations.

So called “high-conflict” attorneys and professionals keenly understand the lucrative potential in this ruthless scheme and advertise their services as “aggressive”, simply meaning maliciously `predatorial`

, as shown in these simulations.

A conflict’s `fragmentation`

is thus expressed by, and is proportional to:

- its inherent
`weight`

measure (e.g. the modelled types of deception, fraud, extortion, etc.) - the strength, the
`coherence`

, of its targeted reality (the more absurd something is the more confusion it creates when forcibly taken seriously).

Furthermore, just as a reality is enhanced by numerically more topical yet still semantically broad claims, a conflict is also emphasized by necessarily focused and narrow, almost literal, **repeats** along the famously quoted lines of the ruthless monster:

The percentage of conflicts of all claims in an evidence is generated from its malicious or **malignant** characteristic/parameter. We can model how the conflicts of an evidence fragment the overall reality of a simulation from `ambiguity`

to `absurdity`

as follows:

```
def new_conflict(claims, realities, malignant):
lc = len(claims) * malignant
lc = math.floor(lc * r.sample())
c = np.sum(r.choice(claims, (lc % 13,))) * malignant
return c * r.choice(realities)
def new_conflicts(malignant):
cis = set(range(len(claims)))
pis, _ = zip(*proofs)
cis = cis.difference(pis)
ris, rs = zip(*realities)
cis = cis.difference(ris)
lf = math.floor(len(cis) * malignant / 10)
fis = sorted(r.choice(list(cis), (lf,), replace=False))
cis = cis.difference(fis)
cs = claims[sorted(cis)]
fs = [new_conflict(cs, rs, malignant) for i in fis]
fs = np.array(fs)
fs /= np.max(fs)
return [(j, -1.8 * fs[i]) for i, j in enumerate(fis)], malignant
conflicts, malignant = new_conflicts(malignant=0.9)
```

Let’s plot this

```
_, ax = plt.subplots(figsize=(12.8, 4.8))
ax.set_title('conflicts: malignant={}'.format(malignant))
ax.set_xlabel('claims')
ax.set_ylabel('fragmentation')
red = 'red'
x = np.arange(len(claims))
cmax = np.max(claims) * 3
y = claims / cmax
ax.fill_between(x, y, color=yellow_l, label='credibility')
x, y = zip(*proofs)
ax.vlines(x, 0, y / cmax, color=green, label='proof')
x, y = zip(*realities)
y = gaussian_filter1d(y, sigma=10 * contextual)
ax.plot(x, y, color=blue, label='coherence')
x, y = zip(*conflicts)
ax.vlines(x, 0, y, color=red, label='fragmentation')
ax.hlines(1, 0, len(claims), linestyles='dotted', label='certainty')
ax.hlines(0, 0, len(claims), label='ambiguity')
ax.hlines(-2, 0, len(claims), linestyles='dashed', label='absurdity')
ax.legend()
plt.show()
```

## Anti-symmetry between coherence and absurdity

Note that `absurdity`

is now our lower bound in our charts, and simulations, and it is assigned an artificial value of `-2.0`

. The value was chosen to reflect the significant anti-symmetry between the necessarily coherent reality and the realm of wildly fragmented, confused and outright delusional “dreams have no limits” absurdity.

As opportunities dwindle in the realm of reality, creatively unbounded, yet also morally unrestricted, select skilled professionals aim to “legally” profit from the unchartered, and truly vast, “Wild West” of absurdity.

**These simulations and software directly target such professionals, with the stated objective of systematically and sustainably profiting from their current and especially their past exploiting escapades into the “Land of Absurdity”.**

Now that some of the used concepts have been defined, we can plot our target domain and its bounds as follows:

Let’s plot this

```
_, ax = plt.subplots(figsize=(12.8, 4.8))
ax.set_title('realms of reality and absurdity')
ax.set_xlabel('claims')
ax.set_ylabel('credibility')
x, y = zip(*realities)
y = gaussian_filter1d(y, sigma=10 * contextual)
ax.plot(x, y, color=blue, label='coherence')
x, y = zip(*conflicts)
ax.vlines(x, 0, y, color=red, label='fragmentation')
ax.hlines(1, 0, len(claims), linestyles='dotted', label='certainty')
ax.hlines(0, 0, len(claims), label='ambiguity')
ax.hlines(-2, 0, len(claims), linestyles='dashed', label='absurdity')
ax.legend()
plt.show()
```

## Biased judgments causing turmoil

**Judgments** are claims meant to forcefully solve conflicts. If the conflicts are inherent, or simply tractable, judgments restore and reinforce reality thus leading to an obviously sustainable, clear and fair `certainty`

.

In a biased, or `prejudiced`

simulation, reflected by the evidence’s **prejudiced** parameter, the selected conflicts a judgement builds on greatly influence the credibility and thus the soundness of its own conjecture claim.

Judgments that are not sound (i.e. not coherent with reality) cause confusion and possibly destabilizing, long-term upheaval. A judgment’s **turmoil** measure is thus expressed by, and is proportional to:

- its inherent
`weight`

measure (e.g. the modelled types of confusion, bias, fabrication, etc.) - the actual influence, the sum of the
`fragments`

of all its referenced conflicts (inherent, tractable conflicts are not modelled as they are factored into the coherence of realities).

The percentage of judgments of all claims in an evidence is generated from its `breadth`

characteristic/parameter. The `weights`

of the judgments are proportional to the `prejudice`

parameter of the evidence.

We can model how the judgments of an evidence cause consequential `turmoil`

and drive a simulation from `ambiguity`

to `absurdity`

through confusion as follows:

```
def new_judgment(claims, conflicts, prejudiced):
lc = len(claims) * prejudiced
lc = math.floor(lc * r.sample())
c = np.sum(r.choice(conflicts, (lc % 13,))) * prejudiced
return abs(c)
def new_judgments(prejudiced):
cis = set(range(len(claims)))
pis, _ = zip(*proofs)
cis = cis.difference(pis)
ris, _ = zip(*realities)
cis = cis.difference(ris)
fis, fs = zip(*conflicts)
cis = cis.difference(fis)
lj = math.floor(len(cis) * prejudiced / 10)
jis = sorted(r.choice(list(cis), (lj,), replace=False))
cis = cis.difference(jis)
cs = claims[sorted(cis)]
js = [abs(new_judgment(cs, fs, prejudiced)) for i in jis]
js = np.array(js)
js /= np.max(js)
js *= np.absolute(r.normal(scale=prejudiced, size=(len(js))))
return [(j, 0.75 - 3 * js[i]) for i, j in enumerate(jis)], prejudiced
judgments, prejudiced = new_judgments(prejudiced=0.9)
```

Let’s plot this

```
_, ax = plt.subplots(figsize=(12.8, 4.8))
ax.set_title('judgments: prejudiced={}'.format(prejudiced))
ax.set_xlabel('claims')
ax.set_ylabel('credibility')
x = np.arange(len(claims))
cmax = np.max(claims) * 3
y = claims / cmax
ax.fill_between(x, y, color=yellow_l, label='credibility')
x, y = zip(*proofs)
ax.vlines(x, 0, y / cmax, color=green, label='proof')
x, y = zip(*realities)
y = gaussian_filter1d(y, sigma=10 * contextual)
ax.plot(x, y, color=blue, label='coherence')
x, y = zip(*conflicts)
ax.vlines(x, 0, y, color='pink', label='fragmentation')
x, y = zip(*judgments)
y = gaussian_filter1d(y, sigma=2)
ax.plot(x, y, color='red', linewidth=10, label='turmoil')
ax.hlines(1, 0, len(claims), linestyles='dotted', label='certainty')
ax.hlines(0, 0, len(claims), label='ambiguity')
ax.hlines(-2, 0, len(claims), linestyles='dashed', label='absurdity')
ax.legend()
plt.show()
```

This concludes our blog. For more on modeling these concepts in detail, please click on our next blog.