44:["$","title",null,{"children":"Mindshift: Part 7 | Chris Whealy | Observable"}] 4c:Tb57,md`# Mindshift: Part 7 Republished on Feb 2nd, 2018 # Ordering a Takeaway ## Subtraction, That Is, Not Fish & Chips… In the [previous Mindshift blog](https://beta.observablehq.com/@chriswhealy/mindshift-part-6), we looked at how minimal JavaScript arrow functions can be used to define firstly a PAIR of values, and secondly how extracting the first or second item from such a PAIR yields a definition of the Boolean values of TRUE and FALSE. So now that we have these definitions under our belt, we can look at how subtraction is implemented. In the same way that the addition of a and b is defined as the b’th successor of a, so subtracting b from a amounts to nothing more than finding the b’th predecessor of a. So the task for this blog is to develop a PREDecessor function (see footnote 1) and then from that, develop a SUBTRACT function. ## Counting Backwards, Or Not… First however, we must understand the constraints of our current counting system. 1. We always start counting from zero 1. We can only count upwards. I.E. this system currently provides no way to represent negative numbers This does restrict the functionality of our SUBTRACT function, but that’s not an issue here for two reasons: 1. We said we are only going to define the counting numbers, and by definition, these are the positive integers. 1. Our primary focus is to understand the use of abstract functions, not create a full mathematical toolbox. So given that our implementation cannot actually count *backwards*, we will have to think of the predecessor of a number in a different way. The way we do can this is to think of numbers as pairs such as (n-1,n). Then, to derive the predecessor of a number, we start counting up from zero – but always keeping track of the numbers as pairs. This means that when we’ve finished counting up to n (the second number in our pair), the required predecessor will be the first number of the pair. In the previous blog, we saw how the PAIR function operates, so now we need to apply that function to our situation. ## Counting in Pairs What we need now is a function that creates not just the successor of a single quantity function, but creates the successors of a PAIR of quantity functions. So what we need here is a SUCC_PAIR function. Here, we will implement the “*shift and increment*” principle by which a new pair is constructed as follows: - The first number in the new pair is the second number from the old pair - The second number of the new pair is the successor of the second number of the old pair But first, we must define some basic functions with which to work `4d:Tace,md`Uh, there seems to be a mistake here. How can 5 minus 8 equal 0? It should be -3, right? Well, if we were working in a calculation system that can represent negative numbers, then yes, this would be a mistake. However, we have already stated that at the moment, we have no way to represent negative numbers. So for the time being, this is the best answer we can provide. Strangely enough, we will actually find that this "incorrect" result becomes helpful when comparing the magnitude of two quantity functions - but I digress... Now that we have the ability to perform any subtraction whose answer is greater than or equal to zero (see footnote 2), we can start to look at other arithmetic operations such as modulus and division; but, as always, there’s a catch – in fact there are two catches caused by the fact that both the modulus and division operators are implemented using repeated subtraction: 1. In both cases, we must perform the SUBTRACT operation until the divisor becomes bigger than the remainder – but we do not yet have any functions such as IS_ZERO or IS_LTE (is less than or equal to). 1. Then there’s the thornier problem that we have no idea how many times the SUBTRACT function needs to be called. In such cases, we must use recursion. Teeny weeny problem though… Our ground rules state that all functions must be anonymous. Therefore, how can we get SUBTRACT to call itself if it's not allowed to know its own name? This is where something called the Y-Combinator comes in; but more of that later. Chris W

### Footnotes 1. The definition of the predecessor function shown in this blog is not the only way this functionality could be implemented, but it is the simplest to understand. The following definition of the predecessor function is also widely used: PRED = n => f => x => n(g => h => h(g(f)))(y => x)(y => y) Whilst this definition is equally valid, it is much harder to understand because it involves the use of nested wrapper functions – so we won’t look at this implementation here. 2. It might seem ridiculous that we have created a SUBTRACT function that yields zero when asked to calculate 5 - 8. But this is not as wacky as it might seem. For more information on this type of operation, look up [Monus](https://en.wikipedia.org/wiki/Monus) – but be warned – you’ll be venturing into the land of Abstract Algebra and Group Theory. Here be dragons! `4e:T113a,lib = { // ******************************************************************** // Generic operations // ******************************************************************** var adder = val1 => val2 => val1 + val2; var multiplier = p => q => q*p; var str_concatenate = char => acc => acc.concat(char); var asPlusChar = str_concatenate('+'); // The increment and decrement functions can now be created var incr = adder(1); var decr = adder(-1); // Use the multiplier function to create partial functions that // double, triple and quadruple their subsequent operand var double = multiplier(2); // -> double = q => q*p (p = 2) var triple = multiplier(3); // -> triple = q => q*p (p = 3) var quadruple = multiplier(4); // -> quadruple = q => q*p (p = 4) var add5 = adder(5); // -> add5 = q => q+5 // ******************************************************************** // Function Composition // ******************************************************************** var compose = fn1 => fn2 => val => fn2(fn1(val)); // Now we can "compose" double and add5 into a single function var doubleAndAdd5 = compose(double)(add5); // ******************************************************************** // Reification functions // ******************************************************************** var to_integer = qtyFn => qtyFn(incr)(0); var to_string = qtyFn => qtyFn(asPlusChar)(''); var to_boolean = fn => fn(true)(false); // ******************************************************************** // Functions that operate on pairs // ******************************************************************** var PAIR = val1 => val2 => fn => fn(val1)(val2); var TRUE = true_part => false_part => true_part; var FALSE = true_part => false_part => false_part; var HEAD = pair => pair(TRUE); var TAIL = pair => pair(FALSE); // ******************************************************************** // Define an abstract quantity function for ZERO. // ******************************************************************** var ZERO = transform => start_value => start_value; // ******************************************************************** // Successor and predecessor functions // ******************************************************************** var SUCC = qtyFn => transform => start_value => transform(qtyFn(transform)(start_value)); // ******************************************************************** // Now each quantity function can be defined simply as the successor // of the quantity function before it. // ******************************************************************** var ONE = SUCC(ZERO); var TWO = SUCC(ONE); var THREE = SUCC(TWO); var FOUR = SUCC(THREE); var FIVE = SUCC(FOUR); var SIX = SUCC(FIVE); var SEVEN = SUCC(SIX); var EIGHT = SUCC(SEVEN); var NINE = SUCC(EIGHT); var TEN = SUCC(NINE); // ******************************************************************** // Arithmetic operations based on abstract quantity functions // ******************************************************************** var ADD = qtyFn1 => qtyFn2 => qtyFn1(SUCC)(qtyFn2); var MULTIPLY = qtyFn1 => qtyFn2 => qtyFn1(ADD(qtyFn2))(ZERO); var POWER = qtyFn1 => qtyFn2 => qtyFn2(MULTIPLY(qtyFn1))(ONE); return { adder : adder, multiplier : multiplier, str_concatenate: str_concatenate, asPlusChar : str_concatenate('+'), incr : adder(1), decr : adder(-1), to_integer : to_integer, to_string : to_string, to_boolean : to_boolean, PAIR : PAIR, TRUE : TRUE, FALSE : FALSE, HEAD : HEAD, TAIL : TAIL, ZERO : ZERO, SUCC : SUCC, ONE : SUCC(ZERO), TWO : SUCC(ONE), THREE : SUCC(TWO), FOUR : SUCC(THREE), FIVE : SUCC(FOUR), SIX : SUCC(FIVE), SEVEN : SUCC(SIX), EIGHT : SUCC(SEVEN), NINE : SUCC(EIGHT), TEN : SUCC(NINE), ADD : ADD, MULTIPLY : MULTIPLY, POWER : POWER } }4f:[] 48:{"id":"ccb01fa1b7aa5335","slug":"mindshift-blog-part-7","title":"Mindshift: Part 7","thumbnail":"fbacfece38d569a416461288ac0f0b8fd334bb36efc5ac4284aa7c4f243c83d4","access_level":"public","create_time":"$D2018-02-01T23:39:11.308Z","update_time":"$D2020-01-10T18:23:38.336Z","view_time":null,"first_public_time":"$D2018-02-02T00:41:46.541Z","has_unpublished_edits":null,"fork":false,"stars":0,"starred":false,"owner":{"type":"team","id":"224d52e60cffa1e1","login":"chriswhealy","name":"Chris Whealy","avatar_url":"https://avatars-next.observableusercontent.com/fe4f3dea84e903c1f07bbfa1cc8292304033a736d3ab9d0e5c009d1340bfefb8","tier":"starter_2024","bio":"","followed_by_you":false,"follows_you":false},"version":188,"publish_version":188,"role":null,"authored":false,"authors":[{"type":"individual","id":"c2414676c206a65f","login":"chriswhealy","name":"Chris Whealy","avatar_url":"https://avatars-next.observableusercontent.com/fe4f3dea84e903c1f07bbfa1cc8292304033a736d3ab9d0e5c009d1340bfefb8","tier":null,"bio":"","followed_by_you":false,"follows_you":false}],"members":[{"type":"individual","id":"c2414676c206a65f","login":"chriswhealy","name":"Chris Whealy","avatar_url":"https://avatars-next.observableusercontent.com/fe4f3dea84e903c1f07bbfa1cc8292304033a736d3ab9d0e5c009d1340bfefb8","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"lapsed":null,"subscribed":null,"forks":0,"collection":null,"type":"notebook","body":{"titling":"auto","title":"Mindshift: Part 7","cells":[{"id":0,"value":"$4c","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":163,"value":"SUCC_PAIR = pair => lib.PAIR(pair(lib.FALSE))(lib.SUCC(pair(lib.FALSE)))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":47,"value":"md`Now let’s use this new SUCC_PAIR function to create the next two successor pairs to PAIR(ZERO)(ZERO) – which we expect to be PAIR(ZERO)(ONE) and PAIR(ONE)(TWO).`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":33,"value":"p00 = lib.PAIR(lib.ZERO)(lib.ZERO)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":44,"value":"p01 = SUCC_PAIR(p00)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":35,"value":"p12 = SUCC_PAIR(p01)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":40,"value":"{\n return {\n \"head\" : lib.to_integer(p01(lib.TRUE)),\n \"tail\" : lib.to_integer(p01(lib.FALSE))\n }\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":63,"value":"{\n return {\n \"head\" : lib.to_integer(p12(lib.TRUE)),\n \"tail\" : lib.to_integer(p12(lib.FALSE))\n }\n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":66,"value":"md`## When Did Last See Your Father – Or Any Other Predecessor?\n\nLastly, to find the predecessor of any particular number n, we need to pass the quantity function of magnitude n the transformation function SUCC_PAIR and a starting value of PAIR(ZERO)(ZERO). The required predecessor will then be the first item in the resulting pair.\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":68,"value":"// The predecessor of a quantity function of magnitude n can be found by SUCC_PAIR as the transformation\n// function, and PAIR(ZERO)(ZERO) as the starting value.\n// This will return a number PAIR in which we are interested only in the first number.\n// Therefore, pass the resulting pair to TRUE in order to extract the required value.\nPRED = qtyFn => qtyFn(SUCC_PAIR)(lib.PAIR(lib.ZERO)(lib.ZERO))(lib.TRUE)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":81,"value":"// The predecessor of seven is...\nlib.to_integer(PRED(lib.SEVEN))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":83,"value":"md`Phew! That was a lot of hard work just to create a predecessor function, but finally we’re in a position to define a SUBTRACT function.\n\n## Subtraction Engine\nSince subtraction is non-commutative, we must stipulate that SUBTRACT always takes the second parameter away from the first; but apart from that, we’re using exactly the same principle as has been used before. In other words, to subtract b from a, apply the PRED function b times starting from a.`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":87,"value":"SUBTRACT = qtyFn1 => qtyFn2 => qtyFn2(PRED)(qtyFn1)","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":105,"value":"// 8 minus 5 is...\nlib.to_integer(SUBTRACT(lib.EIGHT)(lib.FIVE))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":107,"value":"// And 5 minus 8 is...\nlib.to_integer(SUBTRACT(lib.FIVE)(lib.EIGHT))","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":114,"value":"$4d","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"},{"id":159,"value":"$4e","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined","tool":"$undefined","providerMetadata":"$undefined","attachments":"$undefined","output":"$undefined","database":"$undefined"}],"files":"$W4f","stdlib":"1"}} 24:null