<?xml version="1.0"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
	<id>https://machinelearning.subwiki.org/w/index.php?action=history&amp;feed=atom&amp;title=User%3AIssaRice%2FComputability_and_logic%2FMotivation_for_encoding</id>
	<title>User:IssaRice/Computability and logic/Motivation for encoding - Revision history</title>
	<link rel="self" type="application/atom+xml" href="https://machinelearning.subwiki.org/w/index.php?action=history&amp;feed=atom&amp;title=User%3AIssaRice%2FComputability_and_logic%2FMotivation_for_encoding"/>
	<link rel="alternate" type="text/html" href="https://machinelearning.subwiki.org/w/index.php?title=User:IssaRice/Computability_and_logic/Motivation_for_encoding&amp;action=history"/>
	<updated>2026-07-27T01:22:40Z</updated>
	<subtitle>Revision history for this page on the wiki</subtitle>
	<generator>MediaWiki 1.41.2</generator>
	<entry>
		<id>https://machinelearning.subwiki.org/w/index.php?title=User:IssaRice/Computability_and_logic/Motivation_for_encoding&amp;diff=2445&amp;oldid=prev</id>
		<title>IssaRice at 05:27, 20 August 2019</title>
		<link rel="alternate" type="text/html" href="https://machinelearning.subwiki.org/w/index.php?title=User:IssaRice/Computability_and_logic/Motivation_for_encoding&amp;diff=2445&amp;oldid=prev"/>
		<updated>2019-08-20T05:27:01Z</updated>

		<summary type="html">&lt;p&gt;&lt;/p&gt;
&lt;table style=&quot;background-color: #fff; color: #202122;&quot; data-mw=&quot;interface&quot;&gt;
				&lt;col class=&quot;diff-marker&quot; /&gt;
				&lt;col class=&quot;diff-content&quot; /&gt;
				&lt;col class=&quot;diff-marker&quot; /&gt;
				&lt;col class=&quot;diff-content&quot; /&gt;
				&lt;tr class=&quot;diff-title&quot; lang=&quot;en&quot;&gt;
				&lt;td colspan=&quot;2&quot; style=&quot;background-color: #fff; color: #202122; text-align: center;&quot;&gt;← Older revision&lt;/td&gt;
				&lt;td colspan=&quot;2&quot; style=&quot;background-color: #fff; color: #202122; text-align: center;&quot;&gt;Revision as of 05:27, 20 August 2019&lt;/td&gt;
				&lt;/tr&gt;&lt;tr&gt;&lt;td colspan=&quot;2&quot; class=&quot;diff-lineno&quot; id=&quot;mw-diff-left-l5&quot;&gt;Line 5:&lt;/td&gt;
&lt;td colspan=&quot;2&quot; class=&quot;diff-lineno&quot;&gt;Line 5:&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;* Encoding things verifies countability. In general, looking at sets/functions of the natural numbers gives us uncountable objects, but by being able to number all objects of interest, we make sure that our collection is countable.&lt;/div&gt;&lt;/td&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;* Encoding things verifies countability. In general, looking at sets/functions of the natural numbers gives us uncountable objects, but by being able to number all objects of interest, we make sure that our collection is countable.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;* Encoding allows for simulation/proving equivalences (allows different formalisms to talk to each other). For instance, we can encode Turing machine configurations using natural numbers, which allows partial recursive functions to simulate Turing machine computations.&lt;/div&gt;&lt;/td&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;* Encoding allows for simulation/proving equivalences (allows different formalisms to talk to each other). For instance, we can encode Turing machine configurations using natural numbers, which allows partial recursive functions to simulate Turing machine computations.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class=&quot;diff-marker&quot; data-marker=&quot;−&quot;&gt;&lt;/td&gt;&lt;td style=&quot;color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #ffe49c; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;* Encoding allows self-reference. Partial recursive functions take as input natural numbers, not other partial recursive functions. Similarly, first order formulas can quantify over natural numbers and do arithmetic, but don&#039;t have native access to talking about themselves. By numbering things, we create a way to do self-reference while avoiding the standard paradoxes of self-reference (like Russell&#039;s paradox). And once we have self-reference, we get a bunch of interesting diagonalization theorems.&lt;/div&gt;&lt;/td&gt;&lt;td class=&quot;diff-marker&quot; data-marker=&quot;+&quot;&gt;&lt;/td&gt;&lt;td style=&quot;color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #a3d3ff; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;* Encoding allows self-reference. Partial recursive functions take as input natural numbers, not other partial recursive functions. Similarly, first order formulas can quantify over natural numbers and do arithmetic, but don&#039;t have native access to talking about themselves. By numbering things, we create a way to do self-reference while avoiding the standard paradoxes of self-reference (like Russell&#039;s paradox). And once we have self-reference, we get a bunch of interesting diagonalization theorems&lt;ins style=&quot;font-weight: bold; text-decoration: none;&quot;&gt;, the universal partial recursive function, etc&lt;/ins&gt;.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;/table&gt;</summary>
		<author><name>IssaRice</name></author>
	</entry>
	<entry>
		<id>https://machinelearning.subwiki.org/w/index.php?title=User:IssaRice/Computability_and_logic/Motivation_for_encoding&amp;diff=2444&amp;oldid=prev</id>
		<title>IssaRice at 05:26, 20 August 2019</title>
		<link rel="alternate" type="text/html" href="https://machinelearning.subwiki.org/w/index.php?title=User:IssaRice/Computability_and_logic/Motivation_for_encoding&amp;diff=2444&amp;oldid=prev"/>
		<updated>2019-08-20T05:26:38Z</updated>

		<summary type="html">&lt;p&gt;&lt;/p&gt;
&lt;table style=&quot;background-color: #fff; color: #202122;&quot; data-mw=&quot;interface&quot;&gt;
				&lt;col class=&quot;diff-marker&quot; /&gt;
				&lt;col class=&quot;diff-content&quot; /&gt;
				&lt;col class=&quot;diff-marker&quot; /&gt;
				&lt;col class=&quot;diff-content&quot; /&gt;
				&lt;tr class=&quot;diff-title&quot; lang=&quot;en&quot;&gt;
				&lt;td colspan=&quot;2&quot; style=&quot;background-color: #fff; color: #202122; text-align: center;&quot;&gt;← Older revision&lt;/td&gt;
				&lt;td colspan=&quot;2&quot; style=&quot;background-color: #fff; color: #202122; text-align: center;&quot;&gt;Revision as of 05:26, 20 August 2019&lt;/td&gt;
				&lt;/tr&gt;&lt;tr&gt;&lt;td colspan=&quot;2&quot; class=&quot;diff-lineno&quot; id=&quot;mw-diff-left-l5&quot;&gt;Line 5:&lt;/td&gt;
&lt;td colspan=&quot;2&quot; class=&quot;diff-lineno&quot;&gt;Line 5:&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;* Encoding things verifies countability. In general, looking at sets/functions of the natural numbers gives us uncountable objects, but by being able to number all objects of interest, we make sure that our collection is countable.&lt;/div&gt;&lt;/td&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;* Encoding things verifies countability. In general, looking at sets/functions of the natural numbers gives us uncountable objects, but by being able to number all objects of interest, we make sure that our collection is countable.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;* Encoding allows for simulation/proving equivalences (allows different formalisms to talk to each other). For instance, we can encode Turing machine configurations using natural numbers, which allows partial recursive functions to simulate Turing machine computations.&lt;/div&gt;&lt;/td&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;* Encoding allows for simulation/proving equivalences (allows different formalisms to talk to each other). For instance, we can encode Turing machine configurations using natural numbers, which allows partial recursive functions to simulate Turing machine computations.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class=&quot;diff-marker&quot; data-marker=&quot;−&quot;&gt;&lt;/td&gt;&lt;td style=&quot;color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #ffe49c; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;* Encoding allows self-reference. Partial recursive functions take as input natural numbers, not other partial recursive functions. Similarly, first order formulas can quantify over natural numbers and do arithmetic, but don&#039;t have native access to talking about themselves. By numbering things, we create a way to do self-reference while avoiding the standard paradoxes of self-reference (like Russell&#039;s paradox). And once we have self-reference, we a bunch of interesting diagonalization theorems.&lt;/div&gt;&lt;/td&gt;&lt;td class=&quot;diff-marker&quot; data-marker=&quot;+&quot;&gt;&lt;/td&gt;&lt;td style=&quot;color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #a3d3ff; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;* Encoding allows self-reference. Partial recursive functions take as input natural numbers, not other partial recursive functions. Similarly, first order formulas can quantify over natural numbers and do arithmetic, but don&#039;t have native access to talking about themselves. By numbering things, we create a way to do self-reference while avoiding the standard paradoxes of self-reference (like Russell&#039;s paradox). And once we have self-reference, we &lt;ins style=&quot;font-weight: bold; text-decoration: none;&quot;&gt;get &lt;/ins&gt;a bunch of interesting diagonalization theorems.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;/table&gt;</summary>
		<author><name>IssaRice</name></author>
	</entry>
	<entry>
		<id>https://machinelearning.subwiki.org/w/index.php?title=User:IssaRice/Computability_and_logic/Motivation_for_encoding&amp;diff=2443&amp;oldid=prev</id>
		<title>IssaRice at 05:25, 20 August 2019</title>
		<link rel="alternate" type="text/html" href="https://machinelearning.subwiki.org/w/index.php?title=User:IssaRice/Computability_and_logic/Motivation_for_encoding&amp;diff=2443&amp;oldid=prev"/>
		<updated>2019-08-20T05:25:20Z</updated>

		<summary type="html">&lt;p&gt;&lt;/p&gt;
&lt;table style=&quot;background-color: #fff; color: #202122;&quot; data-mw=&quot;interface&quot;&gt;
				&lt;col class=&quot;diff-marker&quot; /&gt;
				&lt;col class=&quot;diff-content&quot; /&gt;
				&lt;col class=&quot;diff-marker&quot; /&gt;
				&lt;col class=&quot;diff-content&quot; /&gt;
				&lt;tr class=&quot;diff-title&quot; lang=&quot;en&quot;&gt;
				&lt;td colspan=&quot;2&quot; style=&quot;background-color: #fff; color: #202122; text-align: center;&quot;&gt;← Older revision&lt;/td&gt;
				&lt;td colspan=&quot;2&quot; style=&quot;background-color: #fff; color: #202122; text-align: center;&quot;&gt;Revision as of 05:25, 20 August 2019&lt;/td&gt;
				&lt;/tr&gt;&lt;tr&gt;&lt;td colspan=&quot;2&quot; class=&quot;diff-lineno&quot; id=&quot;mw-diff-left-l1&quot;&gt;Line 1:&lt;/td&gt;
&lt;td colspan=&quot;2&quot; class=&quot;diff-lineno&quot;&gt;Line 1:&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;The idea of numbering things/encoding things comes up a lot in computability and logic, but many books don&amp;#039;t really seem to discuss why we do this in the first place (the answer is only implicit in the theorems which are presented).&lt;/div&gt;&lt;/td&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;The idea of numbering things/encoding things comes up a lot in computability and logic, but many books don&amp;#039;t really seem to discuss why we do this in the first place (the answer is only implicit in the theorems which are presented).&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;br&gt;&lt;/td&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;br&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class=&quot;diff-marker&quot; data-marker=&quot;−&quot;&gt;&lt;/td&gt;&lt;td style=&quot;color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #ffe49c; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;I think the &lt;del style=&quot;font-weight: bold; text-decoration: none;&quot;&gt;two &lt;/del&gt;main reasons are:&lt;/div&gt;&lt;/td&gt;&lt;td class=&quot;diff-marker&quot; data-marker=&quot;+&quot;&gt;&lt;/td&gt;&lt;td style=&quot;color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #a3d3ff; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;I think the &lt;ins style=&quot;font-weight: bold; text-decoration: none;&quot;&gt;three &lt;/ins&gt;main reasons are:&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;br&gt;&lt;/td&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;br&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;* Encoding things verifies countability. In general, looking at sets/functions of the natural numbers gives us uncountable objects, but by being able to number all objects of interest, we make sure that our collection is countable.&lt;/div&gt;&lt;/td&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;* Encoding things verifies countability. In general, looking at sets/functions of the natural numbers gives us uncountable objects, but by being able to number all objects of interest, we make sure that our collection is countable.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;* Encoding allows for simulation/proving equivalences (allows different formalisms to talk to each other). For instance, we can encode Turing machine configurations using natural numbers, which allows partial recursive functions to simulate Turing machine computations.&lt;/div&gt;&lt;/td&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;* Encoding allows for simulation/proving equivalences (allows different formalisms to talk to each other). For instance, we can encode Turing machine configurations using natural numbers, which allows partial recursive functions to simulate Turing machine computations.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;tr&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;* Encoding allows self-reference. Partial recursive functions take as input natural numbers, not other partial recursive functions. Similarly, first order formulas can quantify over natural numbers and do arithmetic, but don&amp;#039;t have native access to talking about themselves. By numbering things, we create a way to do self-reference while avoiding the standard paradoxes of self-reference (like Russell&amp;#039;s paradox). And once we have self-reference, we a bunch of interesting diagonalization theorems.&lt;/div&gt;&lt;/td&gt;&lt;td class=&quot;diff-marker&quot;&gt;&lt;/td&gt;&lt;td style=&quot;background-color: #f8f9fa; color: #202122; font-size: 88%; border-style: solid; border-width: 1px 1px 1px 4px; border-radius: 0.33em; border-color: #eaecf0; vertical-align: top; white-space: pre-wrap;&quot;&gt;&lt;div&gt;* Encoding allows self-reference. Partial recursive functions take as input natural numbers, not other partial recursive functions. Similarly, first order formulas can quantify over natural numbers and do arithmetic, but don&amp;#039;t have native access to talking about themselves. By numbering things, we create a way to do self-reference while avoiding the standard paradoxes of self-reference (like Russell&amp;#039;s paradox). And once we have self-reference, we a bunch of interesting diagonalization theorems.&lt;/div&gt;&lt;/td&gt;&lt;/tr&gt;
&lt;/table&gt;</summary>
		<author><name>IssaRice</name></author>
	</entry>
	<entry>
		<id>https://machinelearning.subwiki.org/w/index.php?title=User:IssaRice/Computability_and_logic/Motivation_for_encoding&amp;diff=2442&amp;oldid=prev</id>
		<title>IssaRice: Created page with &quot;The idea of numbering things/encoding things comes up a lot in computability and logic, but many books don&#039;t really seem to discuss why we do this in the first place (the answ...&quot;</title>
		<link rel="alternate" type="text/html" href="https://machinelearning.subwiki.org/w/index.php?title=User:IssaRice/Computability_and_logic/Motivation_for_encoding&amp;diff=2442&amp;oldid=prev"/>
		<updated>2019-08-20T05:24:54Z</updated>

		<summary type="html">&lt;p&gt;Created page with &amp;quot;The idea of numbering things/encoding things comes up a lot in computability and logic, but many books don&amp;#039;t really seem to discuss why we do this in the first place (the answ...&amp;quot;&lt;/p&gt;
&lt;p&gt;&lt;b&gt;New page&lt;/b&gt;&lt;/p&gt;&lt;div&gt;The idea of numbering things/encoding things comes up a lot in computability and logic, but many books don&amp;#039;t really seem to discuss why we do this in the first place (the answer is only implicit in the theorems which are presented).&lt;br /&gt;
&lt;br /&gt;
I think the two main reasons are:&lt;br /&gt;
&lt;br /&gt;
* Encoding things verifies countability. In general, looking at sets/functions of the natural numbers gives us uncountable objects, but by being able to number all objects of interest, we make sure that our collection is countable.&lt;br /&gt;
* Encoding allows for simulation/proving equivalences (allows different formalisms to talk to each other). For instance, we can encode Turing machine configurations using natural numbers, which allows partial recursive functions to simulate Turing machine computations.&lt;br /&gt;
* Encoding allows self-reference. Partial recursive functions take as input natural numbers, not other partial recursive functions. Similarly, first order formulas can quantify over natural numbers and do arithmetic, but don&amp;#039;t have native access to talking about themselves. By numbering things, we create a way to do self-reference while avoiding the standard paradoxes of self-reference (like Russell&amp;#039;s paradox). And once we have self-reference, we a bunch of interesting diagonalization theorems.&lt;/div&gt;</summary>
		<author><name>IssaRice</name></author>
	</entry>
</feed>