Unary numeral system

The unary numeral system is the bijective base-1 numeral system. It is the simplest numeral system to represent natural numbers:[1] in order to represent a number N, an arbitrarily chosen symbol representing 1 is repeated N times.[2]

For example, in this system the number 0 (zero) would be represented as the empty string, i.e. the absence of symbols, and the numbers 1, 2, 3, 4, 5, 6... would be represented as:

1, 11, 111, 1111, 11111, 111111...[3]

These numbers should be distinguished from repunits, which are also written as sequences of ones but have their usual decimal numerical interpretation.

This system is used in tallying. For example, using the tally mark |, the number 3 is represented as |||. In East Asian cultures, the number three is represented as “三”, a character that is drawn with three strokes.[4] (One and two are represented similarly.) In China and Japan, the character "正" is used to represent "five" in some situations because it is drawn with 5 strokes.[5][6]

Operations

Addition and subtraction are particularly simple in the unary system, as they involve little more than string concatenation.[7] The Hamming weight or population count operation that counts the number of nonzero bits in a sequence of binary values may also be interpreted as a conversion from unary to binary numbers.[8] However, multiplication is more cumbersome and has often been used as a test case for the design of Turing machines.[9][10][11]

Complexity

Compared to standard positional numeral systems, the unary system is inconvenient and hence is not used in practice for large calculations. It occurs in some decision problem descriptions in theoretical computer science (e.g. some P-complete problems), where it is used to "artificially" decrease the run-time or space requirements of a problem. For instance, the problem of integer factorization is suspected to require more than a polynomial function of the length of the input as run-time if the input is given in binary, but it only needs linear runtime if the input is presented in unary.[12][13] However, this is potentially misleading. Using a unary input is slower for any given number, not faster; the distinction is that a binary (or larger base) input is proportional to the base 2 (or larger base) logarithm of the number while unary input is proportional to the number itself. Therefore, while the run-time and space requirement in unary looks better as function of the input size, it does not represent a more efficient solution.[14]

In computational complexity theory, unary numbering is used to distinguish strongly NP-complete problems from problems that are NP-complete but not strongly NP-complete. A problem in which the input includes some numerical parameters is strongly NP-complete if it remains NP-complete even when the size of the input is made artificially larger by representing the parameters in unary. For such a problem, there exist hard instances for which all parameter values are at most polynomially large.[15]

Applications

Unary numbering is used as part of some data compression algorithms such as Golomb coding.[16] It also forms the basis for the Peano axioms for formalizing arithmetic within mathematical logic.[17] A form of unary notation called Church encoding is used to represent numbers within lambda calculus.[18]

gollark: Fun thing to do #1258916: randomly apply Latin pluralizations to any word ending in `-us` even when it's not really appropriate.
gollark: (rhombi? rhombos? rhombis?)
gollark: So Hexagony with rhombuses?
gollark: Who pinged me?
gollark: Hello?

See also

References
  1. Hodges, Andrew (2009), One to Nine: The Inner Life of Numbers, Anchor Canada, p. 14, ISBN 9780385672665, The simplest way to write the natural numbers is by the unary notation.
  2. Davis, Martin; Sigal, Ron; Weyuker, Elaine J. (1994), Computability, Complexity, and Languages: Fundamentals of Theoretical Computer Science, Computer Science and Scientific Computing (2nd ed.), Academic Press, p. 117, ISBN 9780122063824, the base 1 (or unary) representation of the number x is simply a string of ones of length x.
  3. Hext, Jan (1990), Programming Structures: Machines and programs, Programming Structures, 1, Prentice Hall, p. 33, ISBN 9780724809400.
  4. Woodruff, Charles E. (1909), "The evolution of modern numerals from ancient tally marks", American Mathematical Monthly, 16 (8–9): 125–133, doi:10.2307/2970818, JSTOR 2970818.
  5. Hsieh, Hui-Kuang (1981) "Chinese tally mark", The American Statistician, 35 (3), p. 174, doi:10.2307/2683999
  6. Ken Lunde, Daisuke Miura, L2/16-046: Proposal to encode five ideographic tally marks, 2016
  7. Sazonov, Vladimir Yu. (1995), "On feasible numbers", Logic and computational complexity (Indianapolis, IN, 1994), Lecture Notes in Comput. Sci., 960, Springer, Berlin, pp. 30–51, doi:10.1007/3-540-60178-3_78, ISBN 978-3-540-60178-4, MR 1449655. See in particular p.  48.
  8. Blaxell, David (1978), "Record linkage by bit pattern matching", in Hogben, David; Fife, Dennis W. (eds.), Computer Science and Statistics--Tenth Annual Symposium on the Interface, NBS Special Publication, 503, U.S. Department of Commerce / National Bureau of Standards, pp. 146–156.
  9. Hopcroft, John E.; Ullman, Jeffrey D. (1979), Introduction to Automata Theory, Languages, and Computation, Addison Wesley, Example 7.7, pp. 158–159, ISBN 978-0-201-02988-8.
  10. Dewdney, A. K. (1989), The New Turing Omnibus: Sixty-Six Excursions in Computer Science, Computer Science Press, p. 209, ISBN 9780805071665.
  11. Rendell, Paul (2015), "5.3 Larger Example TM: Unary Multiplication", Turing Machine Universality of the Game of Life, Emergence, Complexity and Computation, 18, Springer, pp. 83–86, ISBN 9783319198422.
  12. Arora, Sanjeev; Barak, Boaz (2007), "The computational model —and why it doesn't matter" (PDF), Computational Complexity: A Modern Approach (January 2007 draft ed.), Cambridge University Press, §17, pp. 32–33, retrieved May 10, 2017.
  13. Feigenbaum, Joan (Fall 2012), CPSC 468/568 HW1 Solution Set (PDF), Computer Science Department, Yale University, retrieved 2014-10-21.
  14. Moore, Cristopher; Mertens, Stephan (2011), The Nature of Computation, Oxford University Press, p. 29, ISBN 9780199233212.
  15. Garey, M. R.; Johnson, D. S. (1978), "'Strong' NP-completeness results: Motivation, examples, and implications", Journal of the ACM, 25 (3): 499–508, doi:10.1145/322077.322090, MR 0478747.
  16. Golomb, S.W. (1966), "Run-length encodings", IEEE Transactions on Information Theory, IT-12 (3): 399–401, doi:10.1109/TIT.1966.1053907.
  17. Magaud, Nicolas; Bertot, Yves (2002), "Changing data structures in type theory: a study of natural numbers", Types for proofs and programs (Durham, 2000), Lecture Notes in Comput. Sci., 2277, Springer, Berlin, pp. 181–196, doi:10.1007/3-540-45842-5_12, ISBN 978-3-540-43287-6, MR 2044538.
  18. Jansen, Jan Martin (2013), "Programming in the λ-calculus: from Church to Scott and back", The Beauty of Functional Code: Essays Dedicated to Rinus Plasmeijer on the Occasion of His 61st Birthday, Lecture Notes in Computer Science, 8106, Springer-Verlag, pp. 168–180, doi:10.1007/978-3-642-40355-2_12, ISBN 978-3-642-40354-5.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.