|
|
| Line 1: |
Line 1: |
| {{Original research|date=September 2010}}
| | E-commerce is a cut throat business. You have to arm your self with the tools and the right know-how to make your website a cut that beats all others. Each day, more and more sites are clambering to boost their ratings in internet sites and left in the abyss full of therefore many failed e-commerce sites and be if you lose your guard, you might get trampled on. <br><br> |
|
| |
|
| | | Search Engine Optimization or SEO is a term popular today by many e-commerce sites. The next five years and for the past few years or therefore, se"s will be the most favored internet tool to obtain the sites that they need to go to or the merchandise or information they need. Get additional information on our affiliated website - Click here: [http://www.linkemperor.com/blog link building seo company]. <br><br>Most people that use search engines use only the five top search results in the initial page. Making it to the initial page, more so to the most effective three is a measure of an internet sites success in search engine optimization. You will get yourself a higher rate of probability in being clicked on when you rank high. The more traffic for the website, the more business you rake in. <br><br>But, it"s important to grab a hold of that position or make your rank even better. Each day is just a new day for several e-commerce sites to make their selves rank higher using seo, as i aforementioned. It is crucial to make your internet site better and better everyday. <br><br>Therefore precisely what have you got to make use of it and is search engine marketing? The clear answer to why you"ve to make use of it"s a straightforward one. You"ll need search engine optimization to be number 1, or even at least make your website revenue generating. <br><br>With search engine optimization you can get the benefit of generating a high traffic volume. Lets just say you receive only a prove of successful sales with 10 to 20 percent of your traffic. If you obtain a hundred hits or even more per day, you get yourself a good prove of revenue already. You only get one or two if not any at all, if you get only twenty to ten hits each day. <br><br>Therefore yet again, what is search engine optimization? Search engine optimization is employing tools and techniques for making your internet site top rank in the results of search engines. Getting yourself in the first page and better yet in the most effective 1 / 2 of the page will ensure that your internet site will generate public awareness of your sites existence and consequently generate more traffic, traffic that may lead to potential income and company. <br><br>Search engine marketing requires a lot of work to be fully realized. There are many factors you have to change in your internet site or include as well to get search engine optimization. These would include getting plenty of information about the keywords which are common in relation to your sites market or concept. <br><br>In order that you can obtain the right keywords in your website without which makes it too commercial but light and beneficial you may also need to edit your web sites contents. There are certain rules and instructions to be used with making your websites content favorable and applicable to search engine optimization. <br><br>To ensure that you may get link transactions and page transfers you"ll also need to collaborate with many other sites. The more inbound and outbound traffics made by sites among others are one of many elements search engines uses to rank sites. <br><br>Try to search the web for all useful support. Tips, methods and methods for seo are plenty to be found. Study many articles which will help you improve your website in search engine results. The more knowledge and information you gather the higher. This can all help you in getting these high rankings. To explore additional information, consider checking out: [http://www.linkemperor.com/ google seo]. This might demand a little time and effort in your part but the benefits is likely to be astonishing. <br><br>If you can part with some funds, there are lots of sites in the internet that can help you searching engine optimization. There are many sites that help in tracking keywords that can help your website. To research more, we understand you check-out: [http://www.linkemperor.com/high-pr-backlinks best link building services]. There are also some content authors that have lots of experience in making good keyword laden content for the sites that have good quality. <br><br>Act now and see the benefits win with seo. All of these may result to more business and greater traffic for your business and site..<br><br>In the event you cherished this information and you wish to get more info concerning [http://ugliestpage7555.pen.io health insurance for college students] generously go to our own web-site. |
| '''Binary lambda calculus''' ('''BLC''') is a technique for using the [[lambda calculus]] to study [[Kolmogorov complexity]], by working with a standard [[binary encoding]] of lambda terms, and a designated [[universal machine]]. Binary lambda calculus is a new idea introduced by John Tromp in 2004.<ref name="RAC">John Tromp, Binary Lambda Calculus and Combinatory Logic, in ''Randomness And Complexity, from Leibniz To Chaitin'', ed. Cristian S. Calude, World Scientific Publishing Company, October 2008. (The last reference, to an initial Haskell implementation, is dated 2004) [http://www.cwi.nl/~tromp/cl/LC.pdf (pdf version)]</ref>
| |
| | |
| ==Background==
| |
| BLC is designed to provide a very simple and elegant concrete definition of descriptional complexity (Kolmogorov complexity).
| |
| | |
| Roughly speaking, the complexity of an object is the length of its shortest description.
| |
| | |
| To make this precise, we take descriptions to be bitstrings, and identify a description
| |
| method with some computational device, or machine, that transforms descriptions into
| |
| objects. Objects are usually also just bitstrings, but can have additional structure as well,
| |
| e.g., pairs of strings.
| |
| | |
| Originally, [[Turing machine]]s, the most well known formalism for computation,
| |
| were used for this purpose. But they are somewhat lacking in ease of
| |
| construction and composability. Another classical computational formalism,
| |
| the [[Lambda calculus]], offers distinct advantages in ease of use.
| |
| The lambda calculus doesn't incorporate any notion of I/O though, | |
| so one needs to be designed.
| |
| | |
| ==Binary I/O==
| |
| Adding a readbit primitive function to lambda calculus, as [[Chaitin]] did for [[LISP]],
| |
| would destroy its [[Referential transparency (computer science)|referential transparency]],
| |
| unless one distinguishes between an I/O action and its result, as [[Haskell (programming language)|Haskell]] does
| |
| with its [[monad (functional programming)|monadic]] I/O. But that requires a type system, an unnecessary complication.
| |
| | |
| Instead, BLC requires translating bitstrings into lambda terms, to which the machine
| |
| (itself a lambda term) can be readily applied.
| |
| | |
| Bits 0 and 1 are translated into the standard [[Lambda_calculus#Logic_and_predicates|lambda booleans]]
| |
| ''B''<sub>0</sub> = True and ''B''<sub>1</sub> = False:
| |
| :True = <math>\lambda x\, \lambda y.\, x</math>
| |
| :False = <math>\lambda x\, \lambda y.\, y</math>
| |
| which can be seen to directly implement the [[if-then-else]] operator.
| |
| | |
| Now consider the pairing function
| |
| :<math>\langle,\rangle = \lambda x \,\lambda y \,\lambda z.\, z x y</math>
| |
| applied to two terms ''M'' and ''N''
| |
| :<math>\langle M, N \rangle = \lambda z.\, z M N</math>.
| |
| Applying this to a boolean yields the desired component of choice.
| |
| | |
| A string ''s'' = ''b''<sub>0</sub>''b''<sub>1</sub>…''b''<sub>n−1</sub> is represented by repeated pairing as
| |
| :<math>\langle B_0, \langle B_1 \ldots \langle B_{n-1}, z\rangle \ldots \rangle \rangle </math> which is denoted as <math>s:z\ </math>.
| |
| | |
| The ''z'' appearing in the above expression requires some further explanation.
| |
| | |
| ==Delimited versus undelimited==
| |
| Descriptional complexity actually comes in two distinct flavors,
| |
| depending on whether the input is considered to be delimited.
| |
| | |
| Knowing the end of your input makes it easier to describe objects.
| |
| For instance, you can just copy the whole input to output.
| |
| This flavor is called ''plain'' or ''simple'' complexity.
| |
| | |
| But in a sense it is additional information. A file system for instance needs to separately
| |
| store the length of files. The [[C (programming language)|C language]]
| |
| uses the [[null character]] to denote the end of a string,
| |
| but this comes at the cost of not having that character available within strings.
| |
| | |
| The other flavor is called ''prefix'' complexity, named after [[prefix code]]s,
| |
| where the machine needs to figure out, from the input read so far, whether it needs
| |
| to read more bits. We say that the input is self-delimiting.
| |
| This works better for communication channels, since one can send
| |
| multiple descriptions, one after the other, and still tell them apart.
| |
| | |
| In the I/O model of BLC, the flavor is dictated by the choice of ''z''.
| |
| If we keep it as a free variable, and demand that it appears as part of the output,
| |
| then the machine must be working in a self-delimiting manner.
| |
| If on the other hand we use a lambda term specifically designed to be easy
| |
| to distinguish from any pairing, then the input becomes delimited.
| |
| BLC chooses ''False'' for this purpose but gives it the more descriptive alternative name of ''Nil''.
| |
| Dealing with lists that may be Nil is straightforward: since
| |
| :<math>\langle x, y \rangle\ M\ N = M\ x\ y\ N</math>, and
| |
| :<math>Nil\ M\ N = N</math>
| |
| one can write functions ''M'' and ''N'' to deal with the two cases, the only caveat being that
| |
| ''N'' will be passed to ''M'' as its third argument.
| |
| | |
| ==Universality==
| |
| We can find a description method ''U'' such that for any other description method ''D'',
| |
| there is a constant ''c'' (depending only on ''D'') such that no object takes more than ''c'' extra
| |
| bits to describe with method ''U'' than with method ''D''.
| |
| And BLC is designed to make these constants relatively small.
| |
| In fact the constant will be the length of a binary encoding of a ''D''-interpreter written in BLC,
| |
| and ''U'' will be a lambda term that parses this encoding and runs this decoded interpreter on the
| |
| rest of the input. ''U'' won't even have to know whether the description is delimited or not;
| |
| it works the same either way.
| |
| | |
| Having already solved the problem of translating bitstrings into lambda calculus, we now
| |
| face the opposite problem: how to encode lambda terms into bitstrings?
| |
| | |
| ==Lambda encoding==
| |
| First we need to write our lambda terms in a particular notation using what is known as
| |
| [[De Bruijn indices]]. Our encoding is then defined recursively as follows
| |
| :<math>\widehat{\lambda M}= 00\widehat{M}</math>
| |
| :<math>\widehat{M\ N}=01\widehat{M}\widehat{N}</math>
| |
| :<math>\widehat{i}=1^i0</math>
| |
| | |
| For instance, the pairing function <math>\lambda x \lambda y \lambda z. z x y</math>
| |
| is written <math>\lambda \lambda \lambda. 1 3 2</math> in De Bruijn format, which has encoding <math>00\ 00\ 00\ 01\ 01\ 10\ 1110\ 110</math>. | |
| | |
| A '''closed''' lambda term is one in which all variables are bound, i.e. without any free variables.
| |
| In De Bruijn format, this means that an index ''i'' can only appear
| |
| within at least ''i'' nested lambdas.
| |
| The number of closed terms of size ''n'' bits is given by sequence {{OEIS2C|A114852}}
| |
| of the [[On-Line Encyclopedia of Integer Sequences]].
| |
| | |
| The shortest possible closed term is the identity function <math>\widehat{\lambda 1} = 0010</math>.
| |
| In delimited mode, this machine just copies its input to its output.
| |
| | |
| So what is this [[universal machine]] ''U''? Here it is, in De Bruijn format (all indices are single digit):
| |
| :<math>(\lambda 1 1) (\lambda \lambda \lambda 1 (\lambda \lambda \lambda \lambda 3 (\lambda 5 (3 (\lambda 2 (3 (\lambda \lambda 3 (\lambda 1 2 3))) (4 (\lambda 4 (\lambda 3 1 (2 1)))))) (1 (2 (\lambda 1 2)) (\lambda 4 (\lambda 4 (\lambda 2 (1 4))) 5)))) (3 3) 2) (\lambda 1 ((\lambda 1 1) (\lambda 1 1)))</math>
| |
| | |
| This is in binary:
| |
| | |
| :0101000110100000000101011000000000011110000101111110011110
| |
| :0001011100111100000011110000101101101110011111000011111000
| |
| :0101111010011101001011001110000110110000101111100001111100
| |
| :0011100110111101111100111101110110000110010001101000011010
| |
| :(only 232 bits long)
| |
| | |
| A detailed analysis of machine ''U'' may be found in.<ref name="RAC" />
| |
| | |
| ==Complexity, concretely==
| |
| In general, we can make complexity of an object conditional on several other objects
| |
| that are provided as additional argument to the universal machine.
| |
| Plain (or simple) complexity ''KS'' and prefix complexity ''KP'' are defined by
| |
| | |
| :<math>KS(x|y_1,\ldots,y_{k}) = \min \{ \ell(p)\ |\ U\ (p:Nil)\ y_1\ \ldots\ y_{k} = \ \,x\ \ \ \ \}</math>
| |
| :<math>KP(x|y_1,\ldots,y_{k}) = \min \{ \ell(p)\ |\ U\ (p:\ z\ \ )\ y_1\ \ldots\ y_{k} = \langle x,z \rangle \}</math>
| |
| | |
| ==Theorems, concretely==
| |
| | |
| The identity program <math>\lambda 1</math> proves that
| |
| :<math>KS(x) \leq \ell(x) + 4</math>
| |
| | |
| The program <math>\lambda \lambda 1 ((\lambda 1 1) (\lambda \lambda \lambda \lambda 2 (4 4) (\lambda \lambda 3 2 (3 2 (2 (5 1 (2 1))))))) (\lambda \lambda 1) (\lambda \lambda \lambda 1 (\lambda 4 (\lambda 4 (\lambda 1 3 2)))) (\lambda \lambda \lambda 1 (3 (\lambda \lambda 1)) 2) (\lambda 1) 2</math> proves that
| |
| :<math>KP(x|\ell(x)) \leq \ell(x)+188</math>
| |
| | |
| The program
| |
| :<math>(\lambda 1 1) (\lambda \lambda \lambda 1 (\lambda 1 (3 (\lambda \lambda 1)) (4 4 (\lambda 1 (\lambda \lambda \lambda 1 (\lambda 4 (\lambda \lambda 5 2 (5 2 (3 1 (2 1)))))) 4 (\lambda 1))))) (\lambda \lambda \lambda 1 (3 ((\lambda 1 1)</math> <math>(\lambda \lambda \lambda \lambda 1 (\lambda 5 5 (\lambda \lambda 3 5 6 (\lambda 1 (\lambda \lambda 6 1 2) 3)) (\lambda \lambda 5 (\lambda 1 4 3))) (3 1)) (\lambda \lambda 1 (\lambda \lambda 2) 2) (\lambda 1)) (\lambda \lambda 1)) 2)</math>
| |
| | |
| proves that
| |
| :<math>KP(x) \leq \ell(\overline{x})+338</math>
| |
| where <math>\overline{x}</math> is the [[Levenstein coding|Levenstein code]] code for ''x'' defined by
| |
| :<math>\begin{array}{ll}
| |
| \overline{0} & = 0 \\
| |
| \overline{n+1} & = 1\ \overline{\ell(n)}\ n\\
| |
| \end{array}</math>
| |
| in which we identify numbers and bitstrings according to lexicographic order. | |
| This code has the nice property that for all ''k'',
| |
| :<math>\ell(\overline{n}) \leq \ell(n)+\ell(\ell(n))+\cdots+ \ell^{k-1}(n) + O(\ell^k(n))</math>
| |
| Furthermore, it makes lexicographic order of delimited numbers coincide with numeric order.
| |
| | |
| {| class="wikitable" border="1"
| |
| |-
| |
| ! Number !! String !! Delimited
| |
| |-
| |
| | 0 || || 0
| |
| |-
| |
| | 1 || 0 || 10
| |
| |-
| |
| | 2 || 1 || 110 0
| |
| |-
| |
| | 3 || 00 || 110 1
| |
| |-
| |
| | 4 || 01 || 1110 0 00
| |
| |-
| |
| | 5 || 10 || 1110 0 01
| |
| |-
| |
| | 6 || 11 || 1110 0 10
| |
| |-
| |
| | 7 || 000 || 1110 0 11
| |
| |-
| |
| | 8 || 001 || 1110 1 000
| |
| |-
| |
| | 9 || 010 || 1110 1 001
| |
| |}
| |
| | |
| ==Complexity of Sets==
| |
| | |
| The complexity of a set of natural numbers is the complexity of its characteristic sequence,
| |
| an infinite lambda term in the [[Infinitary Lambda Calculus]].
| |
| | |
| The program
| |
| :<math>\lambda (\lambda 1 (1 ((\lambda 1 1) (\lambda \lambda \lambda 1 (\lambda \lambda 1) ((\lambda 4 4 1 ((\lambda 1 1) (\lambda 2 (1 1)))) (\lambda \lambda \lambda \lambda 1 3 (2 (6 4))))) (\lambda \lambda \lambda 4 (1 3))))) (\lambda \lambda 1 (\lambda \lambda 2) 2)</math>
| |
| | |
| whose first 100 bits of output are
| |
| | |
| :<math>0011010100010100010100010000010100000100010100010000010000010100000100010100000100010000010000000100</math>
| |
| | |
| proves that
| |
| :<math>\mathit{KS}(\mathit{PRIMES}) \leq 167</math> (a prime)
| |
| while a simple variation proves
| |
| :<math>\mathit{KP}(\mathit{PRIMES}) \leq 176</math>
| |
| | |
| This is even shorter than Haskell's 23 byte long
| |
| | |
| <source lang="haskell">
| |
| nubBy(((>1).).gcd)[2..]
| |
| </source>
| |
| | |
| ==Symmetry of information==
| |
| | |
| The program | |
| :<math>(\lambda 1 (\lambda \lambda 2) (\lambda 1 (\lambda \lambda 1)) (\lambda \lambda \lambda (\lambda 1 (3 2) (\lambda \lambda 3 1 (6 1 1 (4 ((\lambda 1 1) (\lambda \lambda \lambda \lambda \lambda 1 2 (\lambda 1 (\lambda \lambda 1) (\lambda \lambda \lambda 8 2) (\lambda \lambda 1) (4 (6 6) (\lambda 4 (\lambda 1 7 2)))))) 5) </math> <math> (\lambda \lambda 1) (\lambda \lambda \lambda \lambda 1) (\lambda \lambda 2) (\lambda \lambda 1)) (\lambda \lambda \lambda 1 (\lambda 1 6 4) 2))) (4 (\lambda 1) (\lambda 1) (\lambda 1) 1)) (\lambda 1)) (\lambda \lambda (\lambda 1 1) (\lambda \lambda \lambda \lambda 1 (\lambda (\lambda \lambda \lambda \lambda 3 (\lambda 6 (3 (\lambda 2 (3 </math> <math> (\lambda 14 (\lambda 3 (\lambda 1 2 3)))) (4 (\lambda 4 (\lambda 14 (3 1) (2 1)))))) (1 (2 (\lambda 1 2)) (\lambda \lambda 5 (\lambda 5 (\lambda 2 (1 5))) 7 6)) (\lambda 6 (\lambda 1 3 2)))) (\lambda 4 (\lambda 1 3 2))) (4 4) 3))</math>
| |
| | |
| proves that
| |
| :<math>KP(x,y) \leq KP(x) + KP(y|x^{\ast}) + 657</math>
| |
| where <math>x^{\ast}</math> is a shortest program for ''x''.
| |
| | |
| This inequality is the easy half of an equality (up to a constant) known as '''Symmetry of information'''.
| |
| Proving the converse
| |
| :<math> KP(y|x^{\ast}) \leq KP(x,y) - KP(x) + O(1)</math>
| |
| involves simulating infinitely many programs in [[Dovetailing (computer science)|dovetailing]] fashion,
| |
| seeing which ones halt and output the pair of ''x'' (for which a shortest program is given) and any ''y'',
| |
| and for each such program ''p'', requesting a new codeword for ''y'' of length <math>\ell(p)-KP(x)</math>. | |
| The [[Kraft inequality]] ensures that this infinite enumeration of requests can be fulfilled, | |
| and in fact codewords for ''y'' can be decoded on the fly, in tandem with the above enumeration. | |
| Details of this fundamental result by Chaitin can be found in.<ref>G J Chaitin, ''Algorithmic information theory'', Volume I in Cambridge Tracts in Theoretical Computer Science, Cambridge University Press, October 1987, [http://www.cs.auckland.ac.nz/~chaitin/cup.pdf (pdf version)]</ref>
| |
| | |
| ==A quine==
| |
| The term <math>Q=\lambda 1 ((\lambda 1 1) (\lambda \lambda \lambda \lambda \lambda 1 4 (3 (5 5) 2))) 1</math> concatenates two copies of its input, proving that
| |
| :<math>KS(x x) \leq \ell(x) + 66</math>
| |
| Applying it to its own encoding gives a 132 bit [[Quine (computing)|quine]]:
| |
| :<math>U (\widehat{Q}\widehat{Q}:Nil) = \widehat{Q}\widehat{Q}</math>
| |
| | |
| ==Compression==
| |
| So far, we've seen surprisingly little in the way of actually compressing an object into a shorter description; in the last example, we were only breaking even.
| |
| For <math>\ell(x)>66</math> though, we do actually compress <math>xx</math> by <math>\ell(x)-66</math> bits.
| |
| | |
| What could be the shortest program that produces a larger output?
| |
| The following is a good candidate: the program
| |
| <math>(\lambda 1 1 1 1 (\lambda \lambda 1 (\lambda \lambda 1) 2)) (\lambda \lambda 2 (2 1))</math>,
| |
| of size 55 bits, uses [[Church numerals]] to output exactly <math>2^{2^{2^2}}=65536</math> ones.
| |
| That beats both [[gzip]] and [[bzip2]], compressors that need 344 and 352 bits respectively, to describe the same output
| |
| (as a 8192 byte file with a single letter name).
| |
| | |
| ==Halting probability==
| |
| The [[halting probability]] of the prefix universal machine is defined as the probability it will output any term that has a normal form (this includes all translated strings):
| |
| :<math>\Omega_{\lambda} = \sum_{U (p:z) = \langle x,z \rangle,\,x\in NF} 2^{-\ell(p)}</math>
| |
| | |
| With some effort, we can determine the first 4 bits of this particular number of wisdom:
| |
| :<math>\Omega_{\lambda} = .0001\ldots_2</math>
| |
| where probability .0001<sub>2</sub> = 2<sup>−4</sup> is already contributed by programs ''00100'' and ''00101'' for terms True and False.
| |
| | |
| ==BLC8: byte sized I/O==
| |
| | |
| While bit streams are nice in theory, they fare poorly in interfacing with the real world.
| |
| The language BLC8 is a more practical variation on BLC in which programs operate on a stream of bytes,
| |
| where each byte is represented as a delimited list of 8 bits in [[big-endian]] order.
| |
| | |
| BLC8 requires a more complicated universal machine:
| |
| | |
| <math>U8 = \lambda 1 ((\lambda 1 1) (\lambda (\lambda \lambda \lambda 1 (\lambda \lambda \lambda 2 (\lambda \lambda \lambda (\lambda 7 (10 (\lambda 5 (2 (\lambda \lambda 3 (\lambda 1 2 3))) (11 (\lambda 3 (\lambda 3 1 (2 1))))) 3)</math> <math>(4 (1 (\lambda 1 5) 3) (10 (\lambda 2 (\lambda 2 (1 6))) 6))) 8) (\lambda 1 (\lambda 8 7 (\lambda 1 6 2)))) (\lambda 1 (4 3))) (1 1)) (\lambda \lambda 2 ((\lambda 1 1) (\lambda 1 1))))</math>
| |
| | |
| The parser in U8 keeps track of both remaining bytes, and remaining bits in the current byte, discarding the latter when parsing is completed. Thus the size of U8, which is 355 bits as a BLC program, is 45 bytes in BLC8.
| |
| | |
| ==Brainfuck==
| |
| | |
| The following BLC8 program
| |
| :<math>
| |
| (\lambda 1 1) (\lambda (\lambda \lambda \lambda 1 (\lambda (\lambda 2 1 1 1 (\lambda \lambda 1 3 3 (\lambda \lambda 1 (\lambda \lambda (\lambda 7 (1 (3 (\lambda \lambda \lambda \lambda \lambda \underline{10} (1 (\lambda 6 1 4 3)) (\lambda 1 5 (6 5 4 3 2))) (\lambda \lambda 2 ((\lambda 1 1) (\lambda \lambda \lambda 2
| |
| </math> <math>
| |
| (\lambda \lambda \lambda 6 6 2 (\lambda \lambda 6 (\lambda 1 (2 6) 3) (\underline{15} (5 1 (\lambda 1)) (5 (\lambda 1) 1)))) (1 2 (\lambda \lambda \lambda 3 1 2))) 1 (\lambda \lambda 2))))) (3 (1 (\lambda \lambda \lambda \lambda 9 (1 (\lambda 5 1 (\lambda 1 5 4)))
| |
| </math> <math>
| |
| (2 4 (\lambda 1 4 2)))) (5 (\underline{11} (\lambda 1)) (\underline{12} (\lambda 2 ((\lambda 1 1) (\lambda \lambda \lambda 1 ((\lambda 1 1) (\lambda \lambda \lambda 2 (1 (3 3)) (\lambda 8 (7 7 1)))) 2 1))))))) (\lambda \underline{12} (\lambda \underline{12} (\lambda 3
| |
| </math> <math>
| |
| (2 1)))))))) (\lambda \lambda 1))) (1 1)) (\lambda (\lambda 1 1) (\lambda \lambda 1 ((\lambda 1 (1 (1 (\lambda \lambda 1 (\lambda \lambda 2) 2)))) (\lambda \lambda 2 (2 1)) (\lambda \lambda 1)) (2 2)) (1 (\lambda \lambda \lambda \lambda \lambda \lambda 1)) 1)
| |
| </math>
| |
| | |
| is an unbounded tape [[Brainfuck]] interpreter in 829 bits (under 104 bytes).
| |
| The formatting obscures the occurrence of double digit indices: a 10 on line 1, a 15 on line 2, and an 11 and three 12s on line 3. These indices are marked with underlines to distinguish them from single digit indices.
| |
| | |
| This provides a nice example of the property that universal description methods differ by at most
| |
| a constant in complexity. Writing a BLC8 interpreter in Brainfuck, which would provide a
| |
| matching upper bound in the other direction, is left as an exercise for die-hard Brainfuck programmers.
| |
| | |
| The interpreter expects its input to consist of a Brainfuck program followed by a <code>]</code> followed by the input for the Brainfuck program. The interpreter only looks at bits 0,1,4 of each character to determine which of <code>,-.+<>][</code> it is, so any characters other than those 8 should be stripped from a Brainfuck program.
| |
| Consuming more input than is available results in an error (the non-list result <math>\lambda x.x</math>).
| |
| | |
| This interpreter is a rough translation of the following version written in [[Haskell (programming language)|Haskell]]
| |
| <source lang="haskell">
| |
| import System.Environment(getArgs)
| |
| import Control.Monad.State
| |
| import Control.Monad.Writer
| |
| import Control.Applicative hiding ((<|>),many)
| |
| import Text.ParserCombinators.Parsec
| |
| | |
| putc = do ( _, _,b, _) <- get; tell [b]
| |
| getc = do ( left, right,_,b:input) <- get; put ( left, right, b,input)
| |
| prev = do (l:left, right,b, input) <- get; put ( left,b:right, l,input)
| |
| next = do ( left,r:right,b, input) <- get; put (b:left, right, r,input)
| |
| decr = do ( left, right,b, input) <- get; put ( left, right,pred b,input)
| |
| incr = do ( left, right,b, input) <- get; put ( left, right,succ b,input)
| |
| loop body = do (_,_,b,_) <- get; when (b /= '\0') (body >> loop body)
| |
| parseInstr = liftM loop (between (char '[') (char ']') parseInstrs)
| |
| <|> prev <$ char '<'
| |
| <|> next <$ char '>'
| |
| <|> decr <$ char '-'
| |
| <|> incr <$ char '+'
| |
| <|> putc <$ char '.'
| |
| <|> getc <$ char ','
| |
| <|> return () <$ noneOf "]"
| |
| parseInstrs = liftM sequence_ (many parseInstr)
| |
| main = do [name] <- getArgs
| |
| source <- readFile name
| |
| input <- getContents
| |
| let init = ("", repeat '\0', '\0', input)
| |
| putStrLn $ either show (execWriter . (`evalStateT` init)) (parse parseInstrs name source)
| |
| </source>
| |
| | |
| ==See also==
| |
| * [[Binary combinatory logic]]
| |
| | |
| ==References==
| |
| <references/>
| |
| | |
| ==External links==
| |
| * [http://homepages.cwi.nl/~tromp/cl/cl.html John's Lambda Calculus and Combinatory Logic Playground]
| |
| * [http://www.ioccc.org/2012/tromp/hint.html A Binary Lambda Calculus interpreter in C for the IOCCC]
| |
| | |
| {{DEFAULTSORT:Binary Lambda Calculus}}
| |
| [[Category:Algorithmic information theory]]
| |
| [[Category:Lambda calculus]]
| |