Comparison Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comparison functions `<` `≤` `=` `≥` `>` `≠`\n",
    "\n",
    "In this Jupyter notebook we will go over 6 APL functions, the comparison functions `<` `≤` `=` `≥` `>` `≠`. As the name suggests, we use these functions to _compare_ their arguments.\n",
    "\n",
    "The comparison functions are _dyadic_ **scalar** functions. Being _dyadic_ means that they require both a left and a right argument and being **scalar** means they penetrate into nested arrays all the way down to the _simple_ scalars composing said arrays. These are the names of the six comparison functions:\n",
    "\n",
    " - `=` is the _Equal To_ function and `≠` is the _Not Equal To_ function;\n",
    " - `<` is the _Less Than_ function and `>` is the _Greater Than_ function;\n",
    " - `≤` is the _Less Than or Equal To_ function and `≥` is the _Greater Than or Equal To_ function;\n",
    " \n",
    "We start by exploring a bit these six scalar functions giving some brief examples on how to use them. After that, we explore some relationships these functions satisfy among themselves and some tips on simplifying the usage of these functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A foreword on logical values in APL\n",
    "\n",
    "Depending on what your programming background is (if any) this may come as a surprise to you... but in APL the logical values ― the _\"things\"_ we use to indicate if an expression is true or false ― are represented by the numbers $1$ and $0$.\n",
    "\n",
    "In languages like Python or Java we have keywords for those but in other languages like C and APL we use $0$ to represent _false_ and we use $1$ to represent _true_. This may seem like a step back if you are used to having `true/false` keywords but later on you will be shown that this in fact can be quite handy.\n",
    "\n",
    "For the purposes of this notebook, it means that if applying one of the comparison functions returns $1$ then it means the comparison is true and if the function returns $0$ then the comparison is false."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## _Equal To_\n",
    "\n",
    "The _Equal To_ function `=` checks if the left and right scalars are the same scalar. This function can be applied to more than just numbers!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0\n",
       "</span>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 = 1.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'u' = 'u'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0\n",
       "</span>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' = 'v'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0\n",
       "</span>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 = '2'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0J1 = 0J1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0\n",
       "</span>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1J3.4 = 1J3.3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also aggregate all these previous comparisons into a single statement. We just aggregate the left values into an array and the right values into another array and then compare the two arrays, scalar by scalar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 0 1 1 0 0 1 0\n",
       "</span>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 1 1 'u' 'a' 2 0J1 1J3.4 = 1 2 1.0 'u' 'v' '2' 0J1 1J3.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 2 3 1 2 3 1 2 3 1 2 3\n",
       "</span>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oneTwoThree ← 12⍴1 2 3\n",
    "oneTwoThree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another property we get from the fact that the comparison functions are scalar is that we can have a simple scalar on one of the sides and an array on the other side. To perform the comparison, the scalar is first _extended_ to match the shape of the array and then the two arrays are compared element by element."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 0 0 1 0 0 1 0 0 1 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oneTwoThree = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 0 0 1 0 0 1 0 0 1 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oneTwoThree = 12⍴1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also try to understand what happens when we have different types of nested arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌─────┬───────┬───────┐\n",
       "│0 1 0│┌─┬───┐│0 0 1 0│\n",
       "│     ││1│0 1││       │\n",
       "│     │└─┴───┘│       │\n",
       "└─────┴───────┴───────┘\n",
       "</span>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 = (1 2 3)(2 (1 2))(5 6 2 ¯1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌─────┬─────┬─────┐\n",
       "│1 1 1│0 1 0│0 1 0│\n",
       "└─────┴─────┴─────┘\n",
       "</span>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(2 3 4) = (2 2 2)(2 3 4)(3 4 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌─────┬───┬─────────┐\n",
       "│1 0 0│0 1│1 1 1 0 1│\n",
       "│     │0 0│         │\n",
       "└─────┴───┴─────────┘\n",
       "</span>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1 2 3) = (1 2 3)(2 2⍴⍳4)(3 3 3 5 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">┌─────┬───────────────────┬─────┐\n",
       "│1 0 0│┌─────┬─────┬─────┐│1 0 0│\n",
       "│     ││1 1 1│1 0 0│0 0 0││     │\n",
       "│     │└─────┴─────┴─────┘│     │\n",
       "└─────┴───────────────────┴─────┘\n",
       "</span>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1 2 3) = (1 2 3)((2 2 2)(2 3 4)(3 4 5))(3 4 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But this breaks down if the two outer arrays don't have matching lengths and one of them can't be _extended_ like we saw above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "LENGTH ERROR\n",
      "      (1 2)=(1 2 3)(2 3 4)(3 4 5)(4 5 6)\n",
      "           ∧\n"
     ]
    }
   ],
   "source": [
    "(1 2) = (1 2 3)(2 3 4)(3 4 5)(4 5 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## _Not Equal To_\n",
    "\n",
    "The _Not Equal To_ function `≠` checks if the left and right scalars are different from one another and, just like the _Equal To_ function, can be applied to scalars other than numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 1 0 0 1 1 0 1\n",
       "</span>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 1 1 'u' 'a' 2 0J1 1J3.4 ≠ 1 2 1.0 'u' 'v' '2' 0J1 1J3.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 1 1 0 1 1 0 1 1 0 1 1\n",
       "</span>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 ≠ oneTwoThree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 0 1 1 1 1 1 1 1 1 1\n",
       "</span>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oneTwoThree ≠ ⍳12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## _Less Than_\n",
    "\n",
    "The _Less Than_ function `<` checks if the left scalar is _to the left of_ the right scalar if the two scalars are seen on the number line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0\n",
       "</span>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 < 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0\n",
       "</span>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 < 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 < 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 1 0 0 1 0 0 1 0 0 1\n",
       "</span>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 < oneTwoThree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 0 0 0 1 1 1 1 1 1 1\n",
       "</span>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 < ⍳12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For how many positive integers $k$ is $e^k$ below $1000$?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">6\n",
       "</span>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+/ (*⍳10) < 1000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This means $e^7$ should be $1000$ or greater:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1096.63\n",
       "</span>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "*7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comparing things other than numbers\n",
    "\n",
    "This \"less than\" notion is a property of numbers, and thus `<` doesn't work on scalars other than numbers. This is also true for _Greater Than_ (`>`), _Less Than or Equal To_ (`≤`) and _Greater Than or Equal To_ (`≥`).\n",
    "\n",
    "Notice how you cannot run something like `'g' < 'G'` because of a _domain_ error, i.e. `<` was not expecting character scalars:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "DOMAIN ERROR\n",
      "      'g'<'G'\n",
      "         ∧\n"
     ]
    }
   ],
   "source": [
    "'g' < 'G'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can, however, use `⍋` and `⍒` to grade any type of array. This means you can check how the array `('g' 'G')` would be sorted and then compare the sorting indices, [for example](https://aplcart.info/?q=%2F%20lexically) with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0\n",
       "</span>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'g' {</⍋⍺⍵} 'G'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because we got a $0$ here, this means that in a character array `'g'` would come to the right of `'G'`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">DFGHJSabcghiwxyz\n",
       "</span>"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "charArray ← 'abcghizywxJHGFDS'\n",
    "charArray[⍋charArray]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## _Greater Than_\n",
    "\n",
    "The _Greater Than_ function `>` checks if the left scalar is greater than the right scalar, which on the number line checks if the left scalar is _to the right of_ the right scalar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 > 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0\n",
       "</span>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 > 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0\n",
       "</span>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 > 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 0 0 1 0 0 1 0 0 1 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 > oneTwoThree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 1 1 1 0 0 0 0 0 0 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 > ⍳12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the first integer $k$ for which $e^k$ is greater than $1000$?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">7\n",
       "</span>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⊃⍸ (*⍳10) > 1000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So $e^7$ should be greater than $1000$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1096.63\n",
       "</span>"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "*7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interchangeability of `<` and `>`\n",
    "\n",
    "The `<` and `>` functions have a really nice property: `⍺ < ⍵` is exactly the same as `⍵ > ⍺` so you can look for opportunities to change one with the other when changing the order of the expression allows you to remove, for example, a set of parentheses!\n",
    "\n",
    "Check how the two lines of code above can be simplified a bit by swapping the usages of `<` and `>` and by swapping their arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">6\n",
       "</span>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+/ (*⍳10) < 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">6\n",
       "</span>"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "+/  1000  > *⍳10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">7\n",
       "</span>"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⊃⍸ (*⍳10) > 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">7\n",
       "</span>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "⊃⍸  1000  < *⍳10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This also means you are highly unlikely to ever need to use `⍨` with `<` or `>`, as dyadic `<⍨` simplifies to `>` and dyadic `>⍨` simplifies to `<`.\n",
    "\n",
    "What if you want to use `<⍨` or `>⍨` but to call them monadically? `⍵ < ⍵` and `⍵ > ⍵` are always $0$ so there is also no need to do that!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## _Less Than or Equal To_\n",
    "\n",
    "The _Less Than or Equal To_ `≤` function checks if the left scalar is less than or equal to the right argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0\n",
       "</span>"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ≤ 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ≤ 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ≤ 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 1 1 0 1 1 0 1 1 0 1 1\n",
       "</span>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ≤ oneTwoThree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The _Less Than or Equal To_ `≤` function can be seen as the logical disjunction of the functions _Less Than_ and _Equal To_ ; in fact, _less than or equal to_ is comprised of (less than `<`) (or `∨`) (equal to `=`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 1 0 0 1 0 0 1 0 0 1\n",
       "</span>"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2   <   oneTwoThree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 1 0 0 1 0 0 1 0 0 1 0\n",
       "</span>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2   =   oneTwoThree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 1 1 0 1 1 0 1 1 0 1 1\n",
       "</span>"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 (<∨=) oneTwoThree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 1 1 0 1 1 0 1 1 0 1 1\n",
       "</span>"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2   ≤   oneTwoThree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## _Greater Than or Equal To_\n",
    "\n",
    "The _Greater Than or Equal To_ `≥` function checks if the left scalar is greater than or equal to the right argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ≥ 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ≥ 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0\n",
       "</span>"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ≥ 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 1 0 1 1 0 1 1 0 1 1 0\n",
       "</span>"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ≥ oneTwoThree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In a similar fashion to the _Less Than or Equal To_ function, the _Greater Than or Equal To_ function can be broken up in three parts: (greater than `>`) (or `∨`) (equal to `=`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 0 0 1 0 0 1 0 0 1 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2   >   oneTwoThree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 1 0 0 1 0 0 1 0 0 1 0\n",
       "</span>"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2   =   oneTwoThree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 1 0 1 1 0 1 1 0 1 1 0\n",
       "</span>"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 (>∨=) oneTwoThree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 1 0 1 1 0 1 1 0 1 1 0\n",
       "</span>"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2   ≥   oneTwoThree"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interchangeability of `≤` and `≥`\n",
    "\n",
    "We have in `≤` and `≥` a property just like what we have with `<` and `>`: `⍺ ≤ ⍵` is exactly the same as `⍵ ≥ ⍺` so, again, you can look for opportunities to change one with the other. Sometimes this means we can simplify an expression by swapping the arguments, for example by dropping a set of parentheses.\n",
    "\n",
    "From this we also see there is no point in using dyadic `≤⍨` and `≥⍨`. As for the monadic versions of those, notice that `⍵ ≤ ⍵` and `⍵ ≥ ⍵` always return $1$ so it isn't meaningful to consider monadic `≤⍨` or `≥⍨`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Logical opposites\n",
    "\n",
    "These six functions form three pairs of logical opposites:\n",
    "\n",
    " - `=` is the opposite of `≠` and vice versa;\n",
    " - `<` is the opposite of `≥` and vice versa;\n",
    " - `>` is the opposite of `≤` and vice versa.\n",
    "\n",
    "## _Equal_ and _Not Equal To_ are opposite from one another\n",
    "\n",
    "If you go back to the beginning, you will notice that the results for the examples with `=` are exactly the opposite of the results we get when using `≠`.\n",
    "\n",
    "This is because the _Not Equal To_ function `≠` is the logical negation of `=`, which means that using `=` and then negating is the same as using `≠`; it also means that using `≠` and then negating it is the same as using just `=`.\n",
    "\n",
    "By the way, notice the strikethrough over `=` that creates `≠`, also mimicking the mathematical notation for $=$ and $\\neq$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 0 0 1 0 0 1 0 0 1 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "notUnequal ← ~ 1≠oneTwoThree\n",
    "notUnequal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 0 0 1 0 0 1 0 0 1 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "equal ← 1 = oneTwoThree\n",
    "equal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "equal ≡ notUnequal ⍝ Check if the arrays are the same"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(~oneTwoThree=⍳12) ≡ (oneTwoThree ≠ ⍳12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(~oneTwoThree≠⍳12) ≡ (oneTwoThree = ⍳12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## _Less Than_ and _Greater Than or Equal To_ are opposite from one another\n",
    "\n",
    "This is fairly easy to deduce; in fact, for two numbers `⍵` and `⍺` we can imagine them on the number line. Then only one of three things can happen:\n",
    "\n",
    " 1. `⍵` is to the left of `⍺` which can be written as `⍵ < ⍺`;\n",
    " 2. `⍵` and `⍺` lie on the same point, which is `⍵ = ⍺`;\n",
    " 3. `⍵` is to the right of `⍺` which can be written as `⍵ > ⍺`;\n",
    " \n",
    "The _Less Than_ function returns $1$ for the case 1. above and $0$ for the cases 2. and 3.; on the other hand the _Greater Than or Equal To_ function returns $0$ for the case 1. above and $1$ for the cases 2. and 3. This shows `<` and `≥` are opposites from one another."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 2 3 4 5 1 2 3 4 5 1 2 3 4 5\n",
       "</span>"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oneToFive ← 15⍴⍳5\n",
    "oneToFive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 2 3 1 2 3 1 2 3 1 2 3 1 2 3\n",
       "</span>"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oneTwoThree ← 15⍴⍳3\n",
    "oneTwoThree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">0 0 0 0 0 1 0 0 0 0 1 1 0 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oneToFive < oneTwoThree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(~ oneToFive < oneTwoThree) ≡ (  oneToFive ≥ oneTwoThree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(  oneToFive < oneTwoThree) ≡ (~ oneToFive ≥ oneTwoThree)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## _Greater Than_ and _Less Than or Equal To_ are opposite from one another\n",
    "\n",
    "The reason why these two functions are opposite from one another is very similar to the explanation for `<` and `≥`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1 1 1 0 0 1 0 0 0 0 1 1 0 0 0\n",
       "</span>"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oneToFive ≤ oneTwoThree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(~ oneToFive ≤ oneTwoThree) ≡ (  oneToFive > oneTwoThree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<span style=\"white-space:pre; font-family: monospace\">1\n",
       "</span>"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(  oneToFive ≤ oneTwoThree) ≡ (~ oneToFive > oneTwoThree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Dyalog APL",
   "language": "apl",
   "name": "dyalog-kernel"
  },
  "language_info": {
   "file_extension": ".apl",
   "mimetype": "text/apl",
   "name": "APL"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}