Introduction

Going over the hilarious insults generated by ScrollSeek, he identifies the following insult patterns:

Pattern 1: [You] [compound expression]
Pattern 2: Verb [You|noun] [adverb], [compound expression]. ( Predicate and subject, complete sentence. )
Pattern 3: [Why don't] [you] [imperative verb], [You] [compound expression]
Pattern 4: [If I] [modal verb] [phrasal verb] [possessive pronoun] noun, [future simple verb] verb [You|possessive pronoun noun] [preposition] [possessive pronoun] noun [You] [compound expression]. ( Predicate and subject, complete sentence.)

we note that a compound expression can be a:

permutations of two nouns (dickweed)
permutations of a noun and a verb (shiteater)
permutations of an adverb and a verb (cheap fuck)
permutations of an adjective and a noun (scumbag)
combinations of the above (cheap buttfuck) - used rarely, since the insult redundancy makes the expression seem funny, rather than insulting.

We use the term compound expression since the term is used in a larger sense than compound nouns, allowing expressions such as "cheap fuck" which consist of a verb and a noun as well as being separated. However, such compound expressions belong to the language's insults and are commonly grouped in an idiom. Some examples include:

buttfuck 
fuckup 
fuckface 
dickweed 
fuckwad 
dipshit 
fucknut 
fat fuck 
scumbag 
scumball 
scumbucket 
cheeseball 
skeezball 
sleazefuck 
cornball 
cornhole 
dumbass 
dumbfuck 
dumbshit 
fuckface 
shitbrain 
shitface 
dickhead

These are usually created by permuting free morphemes with insults or grotesque terms, such as fucker and shit. Then again, how come that the association with animals or body-parts seem much more insulting than free individual morphemes?

Etymology of Insults

In many ways, insults are an expression of style themselves governed by phonetic rules (rhyme and rhythm) as well as combining different universal elements of culture. For example, "shitting", "pissing", "fucking" or words that describe body parts which are predominantly subject to matters of morality can be easily transferred universally from one language to the other. The son of a bitch idiom can also, apparently, be universally translated and still appear offensive - although, that applies to some cultures more than others.

Another good example of that would be by comparing the English assface to the German arschgesicht which in both cultures can be considered sufficiently insulting. Some idioms, although they translate perfectly from one language to the other and are a valid insult, may be more insulting in one culture than another. It is sensible to assume that different events or changes during the evolution of the two cultures have rendered some of these idioms more insulting or less insulting than other idioms. [Example]. Similarly, we could also venture to observe that cultures with a history of agrarian development tend to use animals in the idioms themselves - naturally, this would be due to the awareness gained by dealing with them on an universal scale.

Based on that, let us extend the list by assuming that many societies are predominantly agrarian and let us compose idioms consisting of an animal and "fucker":

pigfucker
dogfucker
goatfucker
sheepfucker
cowfucker
duckfucker

which all seem insultingly valid. Let us try now the association between a characteristic or identifying body part and an animal:

pigface
goatface
cowface
horseface
fishface

which, again, seem to be generally derogatory. How about feet?

chickenfeet
pigfeet
cowfeet

And how about identifying behavioral human patterns such as duckwalk. The same works for vegetables, think about it, you have heard those before.

The explanation that we give is that animals, plants and even concepts such as machines are deeply rooted within the knowledge base of many cultures. They all have distinct behavioral patterns as well as varying shapes that become grotesque and when associated with fairly standard human traits making humans appear abnormal. However, that is still not enough and the final icing on the cake is the universal morality revolving around these concepts. A cow is considered dumb, a pig is an universal symbol of gluttony, and a chicken walks in trivially identifiable patterns which hints to rudimentary motor skills. "chickenrobot", hey what do you know, you can insult selfless objects as well.

We would wager that hyperbolas in the creation of insults do not play that much of a role than the cultural meanings encoded in the free morphemes and cannot achieve the same level of insulting appearance.

Dictionaries

Based on the etymology, we build the dictionary files.

Animals

chicken
cow
dog
donkey
duck
goat
goose
horse
pig
sheep
turkey
fish
rat
monkey

Body-parts

face
ass
brain
cunt

Obscene

shit
cum
piss

Character

arrogant
obnoxious
surly
sarcastic
ignorant
guilible
confused
immature
insipid
stubborn
spiteful
insensitive
prejudiced
spoilt

Imperatives

go eat
go drink
go lick
go suck

The Compound Expressions

Using two dictionaries containing animals and body-parts, we can write the following generator:

using System;
using System.IO;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
 
public class compounds {
  public static void Main() {
    List<string> animals = ReadWords("animals.txt");
    List<string> bodypartss = ReadWords("bodyparts.txt");
 
    var rnd = new Random();
    new List<int>(new int[20]).ForEach(e =>
      System.Console.WriteLine(String.Format("{0}{1}",
        (string)animals[rnd.Next(animals.Count)], 
        (string)bodypartss[rnd.Next(bodypartss.Count)]))
    );
  }
 
  private static List<string> ReadWords(string file) {
    try {
      return File.ReadAllText(file).Trim().Split(new char[] {'\n'}).ToList();
    } catch(Exception e) {
      Console.WriteLine("Could not read file: " + e.Message);
    }
    return null;
  }
}

we get the following set of 20-pointwise associations output:

horseface
donkeybutt
fishass
donkeybrain
fishass
horseass
sheepass
duckbrain
fishass
duckbutt
goatface
goosebutt
cowbrain
dogbrain
fishbrain
chickenass
chickenface
donkeyass
cowbrain
dogbrain

which do not seem too polite for starters.

Canonizing Swearing Sentences

As ScrollSeek did, we observe that we need to establish a few typical sentence dispositions which we can permute in order to generate any length of profanity. Thus, we will write a program that combines several smaller modules which generate typical swearing sentences.

We list the sentence dispositions here as a reference in order to build the modules:

Module Number	Description	Used Dictionaries	Generated Example
1	Telling people to get lost.	Animals, Body-parts, Obscene, Character and Imperatives.	Go suck shit you spiteful cumrat!
			Go drink piss you confused cumturkey!
			Go eat shit you arrogant fishbrain!

If every module is designed to create a complete sentence, then we can canonize the modules in order to generate chains of insults.

For example, an insult chain could be:

Chain = M1 M2 M4 M1 M5 M2

where M1 to M5 represent the self-standing modules.

Rules

We immediately can deduce that chain sub-sequences should not contain a repetition of a module. For example, the chain: M1 M1 is not valid because it would sound repetitive and redundant. For example, a chain insult such as "Go lick shit you obnoxious donkeyass! Go eat cum you spoilt sheepcunt! Go suck piss you guilible shitdonkey!" contains too many M1 modules which are imperative by nature and the succinct repetition makes the insult boring. It becomes obvious that given a number of modules, they must be disposed so that every module is as far away as possible from its own reoccurrence.

Furthermore, due to people's ability to recognize re-occurring patterns, we cannot just repeat a good sequence. For example, for three modules, the sequence M1 M2 M3 M1 M2 M3 M1 M2 M3 always maintains a distance of $3$ (which is incidentally the best possible distance) between two modules. However, it has an obviously dull repeating pattern which is easy to spot.

Given a set $S$ of $p$ elements and suppose that we draw elements from that set to generate a new set $O$ with $n$ -elements, what is the optimal order of elements so that the $n$ -th element will be as far away as possible from the rest of $(n-1)$ elements?

For example, taking a set of four elements $S=(1, 2, 3, 4)$ , the best sequence is the one that has the smallest distance between two modules $3$ :

O=4 2 3 1 2 3 4 1 2 3 4 1 . . .
    |     |
    +-----+
       3

Or, a wrongly ordered sequence could have a distance of $1$ between two modules:

O=1 1 2 4 3 2 1 4 2 . . .
  | |
  +-+
   1

The distances are given by:

max = |S|+1
min = |S|-1
  for |S| >= 1

First Solution

Algorithm

Take a set $S$ with $4$ elements so that:

         * * = roundUp(|S|/2)
S1 = 1 2 3 4
       | | |
       +---+
        C1 = 3 4 => 1 or 2
        C2 = 2 3 4 => 1
           => C = 1 or 2

Always pick farthest:

S2 = 1 2 3 4 2
           | |       
           +-+
            C = 3 or 1

S3 = 1 2 3 4 2 1
             | |
             +-+
              C = 3 or 4

S4 = 1 2 3 4 2 1 3
               | |
               +-+
                C = 2 or 4

S4 = 1 2 3 4 2 1 3 4
                 | |
                 +-+
                  C = 1 or 2
                  
             seq     seq
           +-----+ +-----+
           |     | |     |
S5 = 1 2 3 4 2 1 3 4 2 1 

=> seq repeats, have max=|S+1|

thus C must be a random choice -> harmonic decreasing probability of being a sequence (coin toss).

Take a set $S$ with $4$ elements so that:

         * * = roundUp(|S|/2)
S1 = 1 2 3 4
       | | |
       +---+
        C1 = 3 4 => 1 or 2
        C2 = 2 3 4 => 1
           => C = 1 or 2

Always pick closest:

S2 = 1 2 3 4 2
           | |       
           +-+
            C = 3 or 1

S3 = 1 2 3 4 2 3
             | |
             +-+
              C = 1 or 4

S4 = 1 2 3 4 2 3 4
               | |
               +-+
                C = 1 or 2

S4 = 1 2 3 4 2 1 3 2
                 | |
                 +-+
                  C = 1 or 4
             
            seq   seq      
           +---+ +---+
           |   | |   |
           +   + +   +
S5 = 1 2 3 4 2 3 4 2 3 4 2 3 4 2 ... 1?

=> seq repeats, max=inf and element lost.

depending on the choice or farthest and closest, with a certain probability, (an amount of subsequent closest selections) an element may be lost. Probability?

General

Given a set $S$ of $n$ elements:

$S=(p_{1}, p_{2}, p_{3}, p{4}, ..., p_{n})$

We shuffle the set $S$ by drawing elements from $S$ , placing them in the new set $O$ and discarding them from the set $S$ :

$O_{0} = shuffle(S) = \{p_{i}, p_{ii}, ... p_{m}\}$

We take the $(m-2)$ th element from O_{0} and append it to the new set $O_{1}$ :

$O_{1} = O_{0} \cup \{\ p_{m-2} \mbox{ | } m=|O_{0}| \mbox{ and } p \in O_{0} \}$

We repeat and take the $(m-2)$ th element and append it to the new set $O_{2}$ and repeat up to $O_{n}$ observing that the general formula for the $n$ th element is given by:

$O_{n} = O_{n-1} \cup \{\ p_{i-1} \mbox{ | } p_{i-1} \in O_{n-1} \mbox{ and } i=|S_{n}| \}$

Testing

$S_{0} = \epsilon => n...$

…

$S_{1} = \{ 1 \} => O_{1} = O_{0} \cup...$

…

$S_{2} = \{ 1, 2 \} => O_{2} = O_{1} \cup$

Proof

Module 1

using System;
using System.IO;
using System.Text;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
 
public class compounds {
  public static void Main() {
 
    // Compounds
    List<string> animals = ReadWords("animals.txt");
    List<string> bodyparts = ReadWords("bodyparts.txt");
    List<string> obscene = ReadWords("obscene.txt");
 
    // Verbs and Adjectives
    List<string> character = ReadWords("character.txt");
    List<string> imperatives = ReadWords("imperatives.txt");
 
    StringBuilder str = new StringBuilder();
 
    str.Append((string)imperatives[rnd.Next(imperatives.Count)] + " " + (string)obscene[rnd.Next(obscene.Count)] + " ");
    str.Append("you " + (string)character[rnd.Next(character.Count)] + " ");
 
    switch(rnd.Next(3)) {
      case 0:
        str.Append(String.Format("{0}{1}", 
          (string)animals[rnd.Next(animals.Count)],
          (string)bodyparts[rnd.Next(bodyparts.Count)]));
        break;
      case 1:
        str.Append(String.Format("{0}{1}",
          (string)bodyparts[rnd.Next(bodyparts.Count)],
          (string)obscene[rnd.Next(obscene.Count)]));
        break;
      case 2:
        str.Append(String.Format("{0}{1}",
          (string)obscene[rnd.Next(obscene.Count)],
          (string)animals[rnd.Next(animals.Count)]));
        break;
      default:
        System.Console.WriteLine("Module is broken.");
        System.Exit(1);
        break;
    }
 
    string line = str.ToString().Trim().ToUpper();
    Console.WriteLine(line[0] + line.Substring(1, line.Length-1).ToLower() + "!");
  }
 
  private static List<string> ReadWords(string file) {
    try {
      return File.ReadAllText(file).Trim().Split(new char[] {'\n'}).ToList();
    } catch(Exception e) {
      Console.WriteLine("Could not read file: " + e.Message);
    }
    return null;
  }
}