Algorithms tag - LessWrong 2.0 viewer
https://www.greaterwrong.com/
Algorithms tag - LessWrong 2.0 viewerxml-emitteren-usRevisiting algorithmic progress by Tamay
https://www.greaterwrong.com/posts/Cvr723R7DmKcLiAzQ/revisiting-algorithmic-progress
<p>How much progress in ML depends on algorithmic progress, scaling compute, or scaling relevant datasets is relatively poorly understood. <a href="https://arxiv.org/abs/2212.05153">In our paper</a>, we make progress on this question by investigating algorithmic progress in image classification on ImageNet, perhaps the most well-known test bed for computer vision. </p><p>Using a dataset of a hundred computer vision models, we estimate a model—informed by neural scaling laws—that enables us to analyse the rate and nature of algorithmic advances. We use Shapley values to produce decompositions of the various drivers of progress computer vision and estimate the relative importance of algorithms, compute, and data. </p><p><strong>Our main results include:</strong></p><ul><li><p>Every nine months, the introduction of better algorithms contributes the equivalent of a doubling of compute budgets. This is much faster than the gains from Moore’s law; that said, there’s uncertainty (our 95% CI spans 4 to 25 months)</p></li></ul><figure><div class="imgonly"><img src="http://res.cloudinary.com/lesswrong-2-0/image/upload/v1670968791/mirroredImages/Cvr723R7DmKcLiAzQ/lbkydfbasndixptxxcrd.png" srcset="https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/5954aaf61abe4d2406440b34db01930d815346a1439c1350.png/w_90 90w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/5954aaf61abe4d2406440b34db01930d815346a1439c1350.png/w_180 180w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/5954aaf61abe4d2406440b34db01930d815346a1439c1350.png/w_270 270w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/5954aaf61abe4d2406440b34db01930d815346a1439c1350.png/w_360 360w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/5954aaf61abe4d2406440b34db01930d815346a1439c1350.png/w_450 450w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/5954aaf61abe4d2406440b34db01930d815346a1439c1350.png/w_540 540w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/5954aaf61abe4d2406440b34db01930d815346a1439c1350.png/w_630 630w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/5954aaf61abe4d2406440b34db01930d815346a1439c1350.png/w_720 720w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/5954aaf61abe4d2406440b34db01930d815346a1439c1350.png/w_810 810w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/5954aaf61abe4d2406440b34db01930d815346a1439c1350.png/w_856 856w" loading="lazy"></div><figcaption>Pareto frontiers for training models to achieve the performance of well-known models over time.</figcaption></figure><ul><li><p>Roughly, progress in image classification has been ~45% due to the scaling of compute, ~45% due to better algorithms, ~10% due to scaling data</p></li></ul><figure><div class="imgonly"><img src="http://res.cloudinary.com/lesswrong-2-0/image/upload/v1670968791/mirroredImages/Cvr723R7DmKcLiAzQ/jbbp4grtiuxnwgwkmzyy.png" srcset="https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/d7fbc56f5503ae728b46495c48ce5e542615115c8dfa849a.png/w_90 90w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/d7fbc56f5503ae728b46495c48ce5e542615115c8dfa849a.png/w_180 180w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/d7fbc56f5503ae728b46495c48ce5e542615115c8dfa849a.png/w_270 270w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/d7fbc56f5503ae728b46495c48ce5e542615115c8dfa849a.png/w_360 360w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/d7fbc56f5503ae728b46495c48ce5e542615115c8dfa849a.png/w_450 450w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/d7fbc56f5503ae728b46495c48ce5e542615115c8dfa849a.png/w_540 540w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/d7fbc56f5503ae728b46495c48ce5e542615115c8dfa849a.png/w_630 630w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/d7fbc56f5503ae728b46495c48ce5e542615115c8dfa849a.png/w_720 720w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/d7fbc56f5503ae728b46495c48ce5e542615115c8dfa849a.png/w_810 810w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/d7fbc56f5503ae728b46495c48ce5e542615115c8dfa849a.png/w_856 856w" loading="lazy"></div><figcaption>Attribution of progress to algorithmic progress, compute scaling and data scaling between model pairs based on Shapley decomposition. “NS” indicates that there was no scaling of the relevant input between these models. Numbers may not all add up to 100 due to rounding.</figcaption></figure><ul><li><p>The majority (>75%) of algorithmic progress is compute-augmenting (i.e. enabling researchers to use compute more effectively), a minority of it is data-augmenting</p></li></ul><figure><div class="imgonly"><img src="http://res.cloudinary.com/lesswrong-2-0/image/upload/v1670968791/mirroredImages/Cvr723R7DmKcLiAzQ/xvf7gi7jejbvqzboyana.png" srcset="https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/08b7e70b5457860a48a144344cfc1bcbb86202fda7d2b107.png/w_110 110w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/08b7e70b5457860a48a144344cfc1bcbb86202fda7d2b107.png/w_220 220w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/08b7e70b5457860a48a144344cfc1bcbb86202fda7d2b107.png/w_330 330w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/08b7e70b5457860a48a144344cfc1bcbb86202fda7d2b107.png/w_440 440w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/08b7e70b5457860a48a144344cfc1bcbb86202fda7d2b107.png/w_550 550w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/08b7e70b5457860a48a144344cfc1bcbb86202fda7d2b107.png/w_660 660w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/08b7e70b5457860a48a144344cfc1bcbb86202fda7d2b107.png/w_770 770w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/08b7e70b5457860a48a144344cfc1bcbb86202fda7d2b107.png/w_880 880w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/08b7e70b5457860a48a144344cfc1bcbb86202fda7d2b107.png/w_990 990w, https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/08b7e70b5457860a48a144344cfc1bcbb86202fda7d2b107.png/w_1015 1015w" loading="lazy"></div><figcaption>Shares of algorithmic progress that is compute- vs. data-augmenting.</figcaption></figure><p>In our work, we revisit a question previously investigated by <a href="https://openai.com/blog/ai-and-efficiency/">Hernandez and Brown (2020)</a>, which had been discussed on LessWrong by <a href="/posts/MPXqewDipXHY3j7we/ai-and-efficiency-oa-44-improvement-in-cnns-since-2012">Gwern</a>, and <a href="/posts/R6gPKJAq6dbuLNkwG/an-99-doubling-times-for-the-efficiency-of-ai-algorithms">Rohin Shah</a>. <a href="https://openai.com/blog/ai-and-efficiency/">Hernandez and Brown (2020)</a> re-implement 15 open-source popular models and find a 44-fold reduction in the compute required to reach the same level of performance as AlexNet, indicating that algorithmic progress outpaces the original Moore’s law rate of improvement in hardware efficiency, doubling effective compute every 16 months.</p><p>A problem with their approach is that it is sensitive to the exact benchmark and threshold pair that one chooses. Choosing easier-to-achieve thresholds makes algorithmic improvements look less significant, as the scaling of compute easily brings early models within reach of such a threshold. By contrast, selecting harder-to-achieve thresholds makes it so that algorithmic improvements explain almost all of the performance gain. This is because early models might need arbitrary amounts of compute to achieve the performance of today’s state-of-the-art models. We show that the estimates of the pace of algorithmic progress with this approach might vary by around a factor of ten, depending on whether an easy or difficult threshold is chosen. <span class="footnote-reference" role="doc-noteref" id="fnrefudff0iwykk"><sup><a href="#fnudff0iwykk">[1]</a></sup></span></p><p>Our work sheds new light on how algorithmic efficiency occurs, namely that it primarily operates through relaxing compute-bottlenecks rather than through relaxing data-bottlenecks. It further offers insight on how to use observational (rather than experimental) data to advance our understanding of algorithmic progress in ML.</p><ol class="footnotes" role="doc-endnotes"><li class="footnote-item" role="doc-endnote" id="fnudff0iwykk"><span class="footnote-back-link"><a href="#fnrefudff0iwykk">^</a></span><div class="footnote-content"><p>That said, our estimates is consistent with <a href="https://openai.com/blog/ai-and-efficiency/">Hernandez and Brown (2020)</a>’s estimate that algorithmic progress doubles the amount of effective compute every 16 months, as our 95% confidence interval ranges from 4 to 25 months.</p></div></li></ol>TamayCvr723R7DmKcLiAzQTue, 13 Dec 2022 01:39:19 +0000Logical induction for software engineers by Alex Flint
https://www.greaterwrong.com/posts/jtMXj24Masrnq3SpS/logical-induction-for-software-engineers
<style>.mjx-chtml {display: inline-block; line-height: 0; text-indent: 0; text-align: left; text-transform: none; font-style: normal; font-weight: normal; font-size: 100%; font-size-adjust: none; letter-spacing: normal; word-wrap: normal; word-spacing: normal; white-space: nowrap; float: none; direction: ltr; max-width: none; max-height: none; min-width: 0; min-height: 0; border: 0; margin: 0; padding: 1px 0}
.MJXc-display {display: block; text-align: center; margin: 1em 0; padding: 0}
.mjx-chtml[tabindex]:focus, body :focus .mjx-chtml[tabindex] {display: inline-table}
.mjx-full-width {text-align: center; display: table-cell!important; width: 10000em}
.mjx-math {display: inline-block; border-collapse: separate; border-spacing: 0}
.mjx-math * {display: inline-block; -webkit-box-sizing: content-box!important; -moz-box-sizing: content-box!important; box-sizing: content-box!important; text-align: left}
.mjx-numerator {display: block; text-align: center}
.mjx-denominator {display: block; text-align: center}
.MJXc-stacked {height: 0; position: relative}
.MJXc-stacked > * {position: absolute}
.MJXc-bevelled > * {display: inline-block}
.mjx-stack {display: inline-block}
.mjx-op {display: block}
.mjx-under {display: table-cell}
.mjx-over {display: block}
.mjx-over > * {padding-left: 0px!important; padding-right: 0px!important}
.mjx-under > * {padding-left: 0px!important; padding-right: 0px!important}
.mjx-stack > .mjx-sup {display: block}
.mjx-stack > .mjx-sub {display: block}
.mjx-prestack > .mjx-presup {display: block}
.mjx-prestack > .mjx-presub {display: block}
.mjx-delim-h > .mjx-char {display: inline-block}
.mjx-surd {vertical-align: top}
.mjx-surd + .mjx-box {display: inline-flex}
.mjx-mphantom * {visibility: hidden}
.mjx-merror {background-color: #FFFF88; color: #CC0000; border: 1px solid #CC0000; padding: 2px 3px; font-style: normal; font-size: 90%}
.mjx-annotation-xml {line-height: normal}
.mjx-menclose > svg {fill: none; stroke: currentColor; overflow: visible}
.mjx-mtr {display: table-row}
.mjx-mlabeledtr {display: table-row}
.mjx-mtd {display: table-cell; text-align: center}
.mjx-label {display: table-row}
.mjx-box {display: inline-block}
.mjx-block {display: block}
.mjx-span {display: inline}
.mjx-char {display: block; white-space: pre}
.mjx-itable {display: inline-table; width: auto}
.mjx-row {display: table-row}
.mjx-cell {display: table-cell}
.mjx-table {display: table; width: 100%}
.mjx-line {display: block; height: 0}
.mjx-strut {width: 0; padding-top: 1em}
.mjx-vsize {width: 0}
.MJXc-space1 {margin-left: .167em}
.MJXc-space2 {margin-left: .222em}
.MJXc-space3 {margin-left: .278em}
.mjx-test.mjx-test-display {display: table!important}
.mjx-test.mjx-test-inline {display: inline!important; margin-right: -1px}
.mjx-test.mjx-test-default {display: block!important; clear: both}
.mjx-ex-box {display: inline-block!important; position: absolute; overflow: hidden; min-height: 0; max-height: none; padding: 0; border: 0; margin: 0; width: 1px; height: 60ex}
.mjx-test-inline .mjx-left-box {display: inline-block; width: 0; float: left}
.mjx-test-inline .mjx-right-box {display: inline-block; width: 0; float: right}
.mjx-test-display .mjx-right-box {display: table-cell!important; width: 10000em!important; min-width: 0; max-width: none; padding: 0; border: 0; margin: 0}
.MJXc-TeX-unknown-R {font-family: monospace; font-style: normal; font-weight: normal}
.MJXc-TeX-unknown-I {font-family: monospace; font-style: italic; font-weight: normal}
.MJXc-TeX-unknown-B {font-family: monospace; font-style: normal; font-weight: bold}
.MJXc-TeX-unknown-BI {font-family: monospace; font-style: italic; font-weight: bold}
.MJXc-TeX-ams-R {font-family: MJXc-TeX-ams-R,MJXc-TeX-ams-Rw}
.MJXc-TeX-cal-B {font-family: MJXc-TeX-cal-B,MJXc-TeX-cal-Bx,MJXc-TeX-cal-Bw}
.MJXc-TeX-frak-R {font-family: MJXc-TeX-frak-R,MJXc-TeX-frak-Rw}
.MJXc-TeX-frak-B {font-family: MJXc-TeX-frak-B,MJXc-TeX-frak-Bx,MJXc-TeX-frak-Bw}
.MJXc-TeX-math-BI {font-family: MJXc-TeX-math-BI,MJXc-TeX-math-BIx,MJXc-TeX-math-BIw}
.MJXc-TeX-sans-R {font-family: MJXc-TeX-sans-R,MJXc-TeX-sans-Rw}
.MJXc-TeX-sans-B {font-family: MJXc-TeX-sans-B,MJXc-TeX-sans-Bx,MJXc-TeX-sans-Bw}
.MJXc-TeX-sans-I {font-family: MJXc-TeX-sans-I,MJXc-TeX-sans-Ix,MJXc-TeX-sans-Iw}
.MJXc-TeX-script-R {font-family: MJXc-TeX-script-R,MJXc-TeX-script-Rw}
.MJXc-TeX-type-R {font-family: MJXc-TeX-type-R,MJXc-TeX-type-Rw}
.MJXc-TeX-cal-R {font-family: MJXc-TeX-cal-R,MJXc-TeX-cal-Rw}
.MJXc-TeX-main-B {font-family: MJXc-TeX-main-B,MJXc-TeX-main-Bx,MJXc-TeX-main-Bw}
.MJXc-TeX-main-I {font-family: MJXc-TeX-main-I,MJXc-TeX-main-Ix,MJXc-TeX-main-Iw}
.MJXc-TeX-main-R {font-family: MJXc-TeX-main-R,MJXc-TeX-main-Rw}
.MJXc-TeX-math-I {font-family: MJXc-TeX-math-I,MJXc-TeX-math-Ix,MJXc-TeX-math-Iw}
.MJXc-TeX-size1-R {font-family: MJXc-TeX-size1-R,MJXc-TeX-size1-Rw}
.MJXc-TeX-size2-R {font-family: MJXc-TeX-size2-R,MJXc-TeX-size2-Rw}
.MJXc-TeX-size3-R {font-family: MJXc-TeX-size3-R,MJXc-TeX-size3-Rw}
.MJXc-TeX-size4-R {font-family: MJXc-TeX-size4-R,MJXc-TeX-size4-Rw}
.MJXc-TeX-vec-R {font-family: MJXc-TeX-vec-R,MJXc-TeX-vec-Rw}
.MJXc-TeX-vec-B {font-family: MJXc-TeX-vec-B,MJXc-TeX-vec-Bx,MJXc-TeX-vec-Bw}
@font-face {font-family: MJXc-TeX-ams-R; src: local('MathJax_AMS'), local('MathJax_AMS-Regular')}
@font-face {font-family: MJXc-TeX-ams-Rw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_AMS-Regular.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_AMS-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_AMS-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-cal-B; src: local('MathJax_Caligraphic Bold'), local('MathJax_Caligraphic-Bold')}
@font-face {font-family: MJXc-TeX-cal-Bx; src: local('MathJax_Caligraphic'); font-weight: bold}
@font-face {font-family: MJXc-TeX-cal-Bw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_Caligraphic-Bold.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_Caligraphic-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_Caligraphic-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-frak-R; src: local('MathJax_Fraktur'), local('MathJax_Fraktur-Regular')}
@font-face {font-family: MJXc-TeX-frak-Rw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_Fraktur-Regular.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_Fraktur-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_Fraktur-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-frak-B; src: local('MathJax_Fraktur Bold'), local('MathJax_Fraktur-Bold')}
@font-face {font-family: MJXc-TeX-frak-Bx; src: local('MathJax_Fraktur'); font-weight: bold}
@font-face {font-family: MJXc-TeX-frak-Bw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_Fraktur-Bold.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_Fraktur-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_Fraktur-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-math-BI; src: local('MathJax_Math BoldItalic'), local('MathJax_Math-BoldItalic')}
@font-face {font-family: MJXc-TeX-math-BIx; src: local('MathJax_Math'); font-weight: bold; font-style: italic}
@font-face {font-family: MJXc-TeX-math-BIw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_Math-BoldItalic.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_Math-BoldItalic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_Math-BoldItalic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-sans-R; src: local('MathJax_SansSerif'), local('MathJax_SansSerif-Regular')}
@font-face {font-family: MJXc-TeX-sans-Rw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_SansSerif-Regular.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_SansSerif-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_SansSerif-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-sans-B; src: local('MathJax_SansSerif Bold'), local('MathJax_SansSerif-Bold')}
@font-face {font-family: MJXc-TeX-sans-Bx; src: local('MathJax_SansSerif'); font-weight: bold}
@font-face {font-family: MJXc-TeX-sans-Bw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_SansSerif-Bold.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_SansSerif-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_SansSerif-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-sans-I; src: local('MathJax_SansSerif Italic'), local('MathJax_SansSerif-Italic')}
@font-face {font-family: MJXc-TeX-sans-Ix; src: local('MathJax_SansSerif'); font-style: italic}
@font-face {font-family: MJXc-TeX-sans-Iw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_SansSerif-Italic.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_SansSerif-Italic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_SansSerif-Italic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-script-R; src: local('MathJax_Script'), local('MathJax_Script-Regular')}
@font-face {font-family: MJXc-TeX-script-Rw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_Script-Regular.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_Script-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_Script-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-type-R; src: local('MathJax_Typewriter'), local('MathJax_Typewriter-Regular')}
@font-face {font-family: MJXc-TeX-type-Rw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_Typewriter-Regular.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_Typewriter-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_Typewriter-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-cal-R; src: local('MathJax_Caligraphic'), local('MathJax_Caligraphic-Regular')}
@font-face {font-family: MJXc-TeX-cal-Rw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_Caligraphic-Regular.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_Caligraphic-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_Caligraphic-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-main-B; src: local('MathJax_Main Bold'), local('MathJax_Main-Bold')}
@font-face {font-family: MJXc-TeX-main-Bx; src: local('MathJax_Main'); font-weight: bold}
@font-face {font-family: MJXc-TeX-main-Bw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_Main-Bold.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_Main-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_Main-Bold.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-main-I; src: local('MathJax_Main Italic'), local('MathJax_Main-Italic')}
@font-face {font-family: MJXc-TeX-main-Ix; src: local('MathJax_Main'); font-style: italic}
@font-face {font-family: MJXc-TeX-main-Iw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_Main-Italic.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_Main-Italic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_Main-Italic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-main-R; src: local('MathJax_Main'), local('MathJax_Main-Regular')}
@font-face {font-family: MJXc-TeX-main-Rw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_Main-Regular.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_Main-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_Main-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-math-I; src: local('MathJax_Math Italic'), local('MathJax_Math-Italic')}
@font-face {font-family: MJXc-TeX-math-Ix; src: local('MathJax_Math'); font-style: italic}
@font-face {font-family: MJXc-TeX-math-Iw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_Math-Italic.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_Math-Italic.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_Math-Italic.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size1-R; src: local('MathJax_Size1'), local('MathJax_Size1-Regular')}
@font-face {font-family: MJXc-TeX-size1-Rw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_Size1-Regular.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_Size1-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_Size1-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size2-R; src: local('MathJax_Size2'), local('MathJax_Size2-Regular')}
@font-face {font-family: MJXc-TeX-size2-Rw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_Size2-Regular.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_Size2-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_Size2-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size3-R; src: local('MathJax_Size3'), local('MathJax_Size3-Regular')}
@font-face {font-family: MJXc-TeX-size3-Rw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_Size3-Regular.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_Size3-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_Size3-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-size4-R; src: local('MathJax_Size4'), local('MathJax_Size4-Regular')}
@font-face {font-family: MJXc-TeX-size4-Rw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_Size4-Regular.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_Size4-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_Size4-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-vec-R; src: local('MathJax_Vector'), local('MathJax_Vector-Regular')}
@font-face {font-family: MJXc-TeX-vec-Rw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_Vector-Regular.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_Vector-Regular.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_Vector-Regular.otf') format('opentype')}
@font-face {font-family: MJXc-TeX-vec-B; src: local('MathJax_Vector Bold'), local('MathJax_Vector-Bold')}
@font-face {font-family: MJXc-TeX-vec-Bx; src: local('MathJax_Vector'); font-weight: bold}
@font-face {font-family: MJXc-TeX-vec-Bw; src /*1*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/eot/MathJax_Vector-Bold.eot'); src /*2*/: url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/woff/MathJax_Vector-Bold.woff') format('woff'), url('https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.2/fonts/HTML-CSS/TeX/otf/MathJax_Vector-Bold.otf') format('opentype')}
</style><p><em>This work was supported by the Monastic Academy for the Preservation of Life on Earth and the Long Term Future Fund.</em></p>
<p class="imgonly"><a href="https://storage.googleapis.com/doc-publisher-images/a62c1f5e1de9ab69.jpg"><div class="imgonly"><img src="https://res.cloudinary.com/lesswrong-2-0/image/upload/v1674653773/mirroredImages/jtMXj24Masrnq3SpS/pw7rnlp1lxdlzkk0w5tz.jpg" alt="" loading="lazy"></div></a></p>
<h2>Outline</h2>
<ul><li><p>This post is an explanation of the theory of logical induction developed by Garrabrant <em>et al</em></p></li><li><p>I formulate the theory in a way that should make sense to software engineers and those with a software engineering mindset.</p></li><li><p>I will go through a full implementation of the logical induction algorithm in Python, and I will use it to explain the basic theory of logical induction, including the core logical induction algorithm.</p></li><li><p>I will give type signatures for all concepts and will work through all algorithms in terms of a sequence of processing steps.</p></li><li><p>The Python code for this guide is <a href="http://github.com/monasticacademy/logical-induction">here</a>.</p></li><li><p>The Colab notebook for this guide is <a href="https://colab.research.google.com/github/monasticacademy/logical-induction/blob/master/notebooks/three_updates.ipynb">here</a>.</p></li><li><p>The index of type signatures for this guide is <a href="#Summary_of_terminology_and_type_signatures">here</a>.</p></li></ul>
<h2>Motivation</h2>
<p>Logical induction is a theory, <a href="https://arxiv.org/abs/1609.03543">published</a> in 2016 by Scott Garrabrant, Tsvi Benson-Tilsen, Andrew Critch, Nate Soares, and Jessica Taylor, about how to build machines that maintain uncertainty about the world and update those beliefs in light of evidence. It does this by assigning numbers between 0 and 1 to claims about the world, just as probability theory does, but it makes different guarantees about the internal relationship between those numbers. Whereas probability theory guarantees that its numbers will obey the sum and product rules of probability, logical induction guarantees that the evolution of its numbers over time will obey the logical induction criterion.</p>
<p>Many people have heard that logical induction is about having uncertainty in purely logical facts. It is true that logical induction shows how to construct algorithms that maintain uncertainty in purely logical facts, but in my view this is not really the <em>point</em> of logical induction. The point of logical induction, in my view, is that it is always <em>computable</em>, even when reasoning about contradictory, uncomputable, or self-referential questions. Its capacity to maintain uncertainty about purely logical facts is actually a by-product of the <em>computability</em> of logical induction.</p>
<p>Logical induction addresses the same basic problem that probability theory addresses. Logical induction and probability theory, therefore, are two different answers to the question: what is a reasonable formal method for quantifying uncertainty and updating it in light of evidence? Probability theory and logical induction both provide concrete operationalizations of “quantified uncertainty” (henceforth “credence”), and what it means for a set of credences to be “reasonable”.</p>
<p>Probability theory says that credences are “reasonable” if it is impossible for someone to bet against you in a way that is expected to make money, independent of the true state of the world (a Dutch book). Logical induction says that credences are “reasonable” if it is impossible for someone to bet against you in a way that makes more and more money <em>over time</em> with no corresponding down-side risk. The probability theory formulation is the stronger guarantee; its drawback is that it is not in general computable. The logical induction formulation <em>is</em> computable, and in this guide we will walk through a general purpose algorithm for computing credences given complicated, even self-referential, world models.</p>
<p>At its core, the theory of logical induction consists of two things:</p>
<ol><li>
<p>A set of proofs showing that <em>if</em> you assign credences in a way that is consistent with the logical induction operationalization of uncertainty <em>then</em> your credences are guaranteed to exhibit certain common-sense desirable properties such as consistency over time, unbiasedness over time, converging to well-calibrated limits in a timely manner.</p>
</li><li>
<p>An algorithm that assigns credences in a way that is consistent with the logical induction operationalization of uncertainty. The existence of this algorithm establishes that the logical induction operationalization of uncertainty is computable. This is the algorithm that we will work through in this guide. It is extremely inefficient.</p>
</li></ol>
<p>A by-product of the computability of logical induction is that logical induction propagates logical uncertainty gradually, rather than all at once as in probability theory. What this means is that the logical induction algorithm, upon receiving an observation, may <em>not</em> propagate the logical consequences of those observations to all of its credences immediately. For example, if you tell a logical inductor that two variables X and Y are highly correlated, and then you further update your logical inductor with the actual value of X, then the logical inductor may not immediately come to the logical conclusion concerning the possible values of Y:</p>
<p class="imgonly"><img src="https://res.cloudinary.com/lesswrong-2-0/image/upload/v1674653773/mirroredImages/jtMXj24Masrnq3SpS/zezh2mwxewr2oa47oryz.png" alt="https://storage.googleapis.com/doc-publisher-images/37d2ad51b0351217.png" loading="lazy"></p>
<p>Any computable algorithm for updating uncertainties over time <em>must</em> propagate logical consequences step-by-step rather than all-at-once, because propagating all the logical consequences of an observation is uncomputable in general, since we might have a world model where knowing the logical consequences of an observation is equivalent to knowing something uncomputable (e.g. whether some Turing machines halts or not). Therefore the ability of logical induction to maintain uncertaint about purely logical facts is really just a <em>by-product</em> of the more general feature of being a <em>computable</em> method of updating well-calibrated credences in light of evidence.</p>
<p>When we say that “logical induction is computable” we mean that there exists an algorithm that implements the logical induction operationalization of uncertainty for full-general models. There is no such fully-general algorithm for probability theory.</p>
<p>The remainder of this document is organized as follows. First we will look at how we can reduce everything to credences on binary-valued variables with logical relationships between them. Next we look at the inputs and outputs to the logical induction algorithm and their type signatures. Then we discuss the logical induction criterion, which you could view as the “spec” for the logical induction algorithm. Then we go through the logical induction algorithm itself in detail. Finally, we will review a worked example in the form of a Jupyter notebook.</p>
<h2>Credences on binary-valued variables</h2>
<p>In <a href="https://www.google.com/books/edition/Probability_Theory/tTN4HuUNXjgC?hl=en&gbpv=1&printsec=frontcover">classical treatments of probability theory</a>, everything starts with probabilities on binary-valued variables, and probabilities on continuous variables are built up out of that.</p>
<p class="imgonly"><img src="https://res.cloudinary.com/lesswrong-2-0/image/upload/v1674653773/mirroredImages/jtMXj24Masrnq3SpS/y9ugqipyy7mpqvasd1up.png" alt="https://storage.googleapis.com/doc-publisher-images/b9b01ec779c5229b.png" loading="lazy"></p>
<p>For many of us, though, it is more common to think directly in terms of continuous variables with probability distributions over them:</p>
<p class="imgonly"><img src="https://res.cloudinary.com/lesswrong-2-0/image/upload/v1674653773/mirroredImages/jtMXj24Masrnq3SpS/ehu9kzkr2mivy3d2ggwt.png" alt="https://storage.googleapis.com/doc-publisher-images/61d9381a7be9a586.png" loading="lazy"></p>
<p>In logical induction, everything is worked out in terms of binary-valued variables, and all relationships between variables are written in the language of first-order logic, which means combinations of AND, OR, NOT, FOR-ALL, and THERE-EXISTS relationships. The first task in applying logical induction to any problem is to formulate that problem in terms of binary-valued variables with purely logical relationships between them. This could be done in any number of ways, such as:</p>
<ul><li>
<p>To talk about a continuous-valued variable <em>x</em> with a fixed distribution (say a Gaussian distribution with some particular mean and variance) you could have a set of binary-valued variables <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="X_a"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-msubsup"><span class="mjx-base" style="margin-right: -0.024em;"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.446em; padding-bottom: 0.298em; padding-right: 0.024em;">X</span></span></span><span class="mjx-sub" style="font-size: 70.7%; vertical-align: -0.212em; padding-right: 0.071em;"><span class="mjx-mi" style=""><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.225em; padding-bottom: 0.298em;">a</span></span></span></span></span></span></span></span>, each of which is true whenever the the continuous-valued variable is less than <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="a"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.225em; padding-bottom: 0.298em;">a</span></span></span></span></span></span>. Logical induction does not “see” the value of <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="a"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.225em; padding-bottom: 0.298em;">a</span></span></span></span></span></span> in <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="X_a"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-msubsup"><span class="mjx-base" style="margin-right: -0.024em;"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.446em; padding-bottom: 0.298em; padding-right: 0.024em;">X</span></span></span><span class="mjx-sub" style="font-size: 70.7%; vertical-align: -0.212em; padding-right: 0.071em;"><span class="mjx-mi" style=""><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.225em; padding-bottom: 0.298em;">a</span></span></span></span></span></span></span></span> --- it just “sees” an undifferentiated binary-valued variable whose truth depends logically on some other variables.</p>
</li><li>
<p>To talk about two continuous-valued variables <em>x</em> and <em>y</em> that are correlated, you could construct a third continuous-valued variable <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="z"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.225em; padding-bottom: 0.298em; padding-right: 0.003em;">z</span></span></span></span></span></span> representing the deviation of <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="x"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.225em; padding-bottom: 0.298em;">x</span></span></span></span></span></span> and <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="y"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.225em; padding-bottom: 0.519em; padding-right: 0.006em;">y</span></span></span></span></span></span> from perfect correlation, and then construct three sets of binary-valued variables <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="X_a"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-msubsup"><span class="mjx-base" style="margin-right: -0.024em;"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.446em; padding-bottom: 0.298em; padding-right: 0.024em;">X</span></span></span><span class="mjx-sub" style="font-size: 70.7%; vertical-align: -0.212em; padding-right: 0.071em;"><span class="mjx-mi" style=""><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.225em; padding-bottom: 0.298em;">a</span></span></span></span></span></span></span></span>, <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="Y_b"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-msubsup"><span class="mjx-base" style="margin-right: -0.182em;"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.446em; padding-bottom: 0.298em; padding-right: 0.182em;">Y</span></span></span><span class="mjx-sub" style="font-size: 70.7%; vertical-align: -0.219em; padding-right: 0.071em;"><span class="mjx-mi" style=""><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.446em; padding-bottom: 0.298em;">b</span></span></span></span></span></span></span></span>, and <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="Z_c"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-msubsup"><span class="mjx-base" style="margin-right: -0.04em;"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.446em; padding-bottom: 0.298em; padding-right: 0.04em;">Z</span></span></span><span class="mjx-sub" style="font-size: 70.7%; vertical-align: -0.212em; padding-right: 0.071em;"><span class="mjx-mi" style=""><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.225em; padding-bottom: 0.298em;">c</span></span></span></span></span></span></span></span> as per the previous bullet point. You would add logical relationships of the form “IF <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="X_a"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-msubsup"><span class="mjx-base" style="margin-right: -0.024em;"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.446em; padding-bottom: 0.298em; padding-right: 0.024em;">X</span></span></span><span class="mjx-sub" style="font-size: 70.7%; vertical-align: -0.212em; padding-right: 0.071em;"><span class="mjx-mi" style=""><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.225em; padding-bottom: 0.298em;">a</span></span></span></span></span></span></span></span> AND <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="Y_b"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-msubsup"><span class="mjx-base" style="margin-right: -0.182em;"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.446em; padding-bottom: 0.298em; padding-right: 0.182em;">Y</span></span></span><span class="mjx-sub" style="font-size: 70.7%; vertical-align: -0.219em; padding-right: 0.071em;"><span class="mjx-mi" style=""><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.446em; padding-bottom: 0.298em;">b</span></span></span></span></span></span></span></span> THEN <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="Z_c"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-msubsup"><span class="mjx-base" style="margin-right: -0.04em;"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.446em; padding-bottom: 0.298em; padding-right: 0.04em;">Z</span></span></span><span class="mjx-sub" style="font-size: 70.7%; vertical-align: -0.212em; padding-right: 0.071em;"><span class="mjx-mi" style=""><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.225em; padding-bottom: 0.298em;">c</span></span></span></span></span></span></span></span>” for the particular values of <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="a"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.225em; padding-bottom: 0.298em;">a</span></span></span></span></span></span>, <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="b"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.446em; padding-bottom: 0.298em;">b</span></span></span></span></span></span>, and <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="c"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.225em; padding-bottom: 0.298em;">c</span></span></span></span></span></span> corresponding to the correlation coefficients between <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="x"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.225em; padding-bottom: 0.298em;">x</span></span></span></span></span></span> and <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="y"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.225em; padding-bottom: 0.519em; padding-right: 0.006em;">y</span></span></span></span></span></span>. That is, if it was the case that <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="z = y - x"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.225em; padding-bottom: 0.298em; padding-right: 0.003em;">z</span></span><span class="mjx-mo MJXc-space3"><span class="mjx-char MJXc-TeX-main-R" style="padding-top: 0.077em; padding-bottom: 0.298em;">=</span></span><span class="mjx-mi MJXc-space3"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.225em; padding-bottom: 0.519em; padding-right: 0.006em;">y</span></span><span class="mjx-mo MJXc-space2"><span class="mjx-char MJXc-TeX-main-R" style="padding-top: 0.298em; padding-bottom: 0.446em;">−</span></span><span class="mjx-mi MJXc-space2"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.225em; padding-bottom: 0.298em;">x</span></span></span></span></span></span> then we would feed logical induction the sentence “IF <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="X_2"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-msubsup"><span class="mjx-base" style="margin-right: -0.024em;"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.446em; padding-bottom: 0.298em; padding-right: 0.024em;">X</span></span></span><span class="mjx-sub" style="font-size: 70.7%; vertical-align: -0.212em; padding-right: 0.071em;"><span class="mjx-mn" style=""><span class="mjx-char MJXc-TeX-main-R" style="padding-top: 0.372em; padding-bottom: 0.372em;">2</span></span></span></span></span></span></span></span> AND <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="Y_9"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-msubsup"><span class="mjx-base" style="margin-right: -0.182em;"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.446em; padding-bottom: 0.298em; padding-right: 0.182em;">Y</span></span></span><span class="mjx-sub" style="font-size: 70.7%; vertical-align: -0.212em; padding-right: 0.071em;"><span class="mjx-mn" style=""><span class="mjx-char MJXc-TeX-main-R" style="padding-top: 0.372em; padding-bottom: 0.372em;">9</span></span></span></span></span></span></span></span> THEN <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="Z_7"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-msubsup"><span class="mjx-base" style="margin-right: -0.04em;"><span class="mjx-mi"><span class="mjx-char MJXc-TeX-math-I" style="padding-top: 0.446em; padding-bottom: 0.298em; padding-right: 0.04em;">Z</span></span></span><span class="mjx-sub" style="font-size: 70.7%; vertical-align: -0.212em; padding-right: 0.071em;"><span class="mjx-mn" style=""><span class="mjx-char MJXc-TeX-main-R" style="padding-top: 0.372em; padding-bottom: 0.372em;">7</span></span></span></span></span></span></span></span>” (because <span class="mathjax-inline-container mjpage"><span class="mjx-chtml"><span class="mjx-math" aria-label="7 = 9 - 2"><span class="mjx-mrow" aria-hidden="true"><span class="mjx-mn"><span class="mjx-char MJXc-TeX-main-R" style="padding-top: 0.372em; padding-bottom: 0.372em;">7</span></span><span class="mjx-mo MJXc-space3"><span class="mjx-char MJXc-TeX-main-R" style="padding-top: 0.077em; padding-bottom: 0.298em;">=</span></span><span class="mjx-mn MJXc-space3"><span class="mjx-char MJXc-TeX-main-R" style="padding-top: 0.372em; padding-bottom: 0.372em;">9</span></span><span class="mjx-mo MJXc-space2"><span class="mjx-char MJXc-TeX-main-R" style="padding-top: 0.298em; padding-bottom: 0.446em;">−</span></span><span class="mjx-mn MJXc-space2"><span class="mjx-char MJXc-TeX-main-R" style="padding-top: 0.372em; padding-bottom: 0.372em;">2</span></span></span></span></span></span>) along with other multiples of these coefficients</p>
</li><li>
<p>To talk about a computer program, we might have a binary-valued variable for each possible value of each variable after executing each line of code. The lines of code would then become logical relationships between those variables.</p>
</li></ul>
<p>You may be concerned at this point that there are an infinite number of binary-valued variables that we need to track, and an infinite number of constraints between them. The way we deal with this in logical induction is by feeding the constraints into the logical inductor as “observations”, one-by-one, such that at every point in time the logical inductor has only a finite number of sentences to deal with. Each one of those finite sentences contains only a finite number of binary-valued variables, so the logical inductor is always working with a finite number of binary-valued variables. The logical induction algorithm does not require any up-front list of all the variables in the world, or anything like that; rather, when it receives a new sentences containing a variable previously unknown to it, it can begin tracking and updating credences in that variable seamlessly.</p>
<p>In the remainder of this document we will refer to a binary-valued variable as an “atom” and to a logical statement about some variables as a “logical sentence”. A logical sentence that we pass to our logical inductor as “observed true” will be referred to as an “observation”.</p>
<h3>Terminology and type signatures</h3>
<p>Here is a summary of the concepts introduced up to this point. In the table below (and in similar tables given at the end of each major section of this write-up), the “concept” column contains a term was introduced in the text above, the “type” column contains a type signature, the “in the paper” column contains the corresponding term used by Garrabrant et al in the paper that introduced logical induction, and “In Python code” contains, where possible, a link to the corresponding code in the logical induction repository on Github. Since this is the first such table, the three concepts below all have elementary types. In future tables, many concepts will have types composed of previous types.</p>
<table>
<thead>
<tr>
<th>Concept</th>
<th>Type</th>
<th>In the paper</th>
<th>In Python code</th>
</tr>
</thead>
<tbody>
<tr>
<td>Credence</td>
<td>Real number</td>
<td>Price</td>
<td>float</td>
</tr>
<tr>
<td>Atom</td>
<td>Atom</td>
<td>Atom</td>
<td><a href="http://monasticacademy.github.io/logical-induction/link/Atom">class Atom</a></td>
</tr>
<tr>
<td>Observation</td>
<td>Sentence</td>
<td>Sentence</td>
<td><a href="http://monasticacademy.github.io/logical-induction/link/Sentence">class Sentence</a></td>
</tr>
</tbody>
</table>
<h2>Type signature of a logical inductor</h2>
<p>A logical inductor takes in a sequence of observations (sentences) one-by-one, and after processing each one produces a belief state, which is a list of (sentence, credence) pairs, where a credence is a real number between 0 and 1.</p>
<p class="imgonly"><img src="https://res.cloudinary.com/lesswrong-2-0/image/upload/v1674653773/mirroredImages/jtMXj24Masrnq3SpS/wpmlhs1bsoymwfn61akp.png" alt="https://storage.googleapis.com/doc-publisher-images/ce7717e695e36753.png" loading="lazy"></p>
<p>At each step, we only put credences on a finite set of sentences, so the list of (sentence, credence) pairs is finite in length. Each time an observation is provided as input, a new belief state is generated as output.</p>
<p>The credences fulfill the same basic <em>purpose</em> as probabilities in probability theory, but they need not obey the laws of probability theory, so we do not call them probabilities. Instead, they obey the logical induction criterion, which is a different notion of what it means to quantify one’s uncertainty about a claim about the world, to be discussed in the next section.</p>
<p>When we feed a sentence into the logical inductor as an observation, we are telling the logical inductor to take that sentence to be true. The logical inductor’s job is then to update its credences in other related sentences. The theory of logical induction is not concerned with how we generate these observations, just as probability theory is not concerned with how we generate the observations that we condition on.</p>
<p>The most important aspect of logical induction to be clear about is that this is a new formalization of what it means to associate numerical credences with claims about the world. Probability theory is one possible formalization of the general phenomena of reasoning about the world by updating credences in response to evidence. The formalization proposed by probability theory is compelling because (in Jaynes’ formulation of probability theory) it arises as the only possible solution to a set of mild desiderata. But it also has a serious drawback in requiring us to compute all the logical consequences of each new observation before we can produce a new belief state consistent with its laws, and the physics of our world does not permit machines that decide the logical consequences of general facts in finite time. Logical induction introduces a different notion of what it means to associate a numerical credence with a claim about the world. It makes a weaker set of guarantees about those credences, but in exchange we get a computable algorithm for updating beliefs in light of new observations<sup class="footnote-ref"><a href="#fn-RhNkDJ5gvj6QHaxFs-1" id="fnref-RhNkDJ5gvj6QHaxFs-1">[1]</a></sup>.</p>
<h3>Terminology and type signatures</h3>
<table>
<thead>
<tr>
<th>Concept</th>
<th>Type</th>
<th>In the paper</th>
<th>In Python code</th>
</tr>
</thead>
<tbody>
<tr>
<td>BeliefState</td>
<td>List<Pair< Sentence, Number >></td>
<td>Belief state</td>
<td>N/A</td>
</tr>
</tbody>
</table>
<h2>The logical induction criterion</h2>
<p>The logical induction criterion is the specification that a computer program must meet in order to be deemed a “logical inductor”. By analogy, consider a “sorting algorithm criterion” requiring each number in the program’s output to be less than or equal to the next number. There are many different sorting algorithms that meet this criterion; likewise, there are many algorithms that meet the requirements of the logical induction criterion. In the case of the logical induction criterion, we have (in the logical induction paper) a set of proofs showing that <em>if</em> an algorithm meets this specification, <em>then</em> the credences output by the algorithm will be convergent in a certain sense, coherent in a certain sense, unbiased in a certain sense, and so on. It is critical to understand the logical induction criterion because otherwise the logical induction algorithm will make little sense.</p>
<p>The logical induction criterion says that our credences should be set such that if we were to bet on them, there would be no continuous polynomial-time trading algorithm that would take more and more money from us, update after update, without limit, and without downside risk. What this means is that if you give me a computer program and that inputs observations and outputs credences, and I find an algorithm (within a certain restricted class that we will discuss below) that trades against it in a way that makes unboundedly much money, then I have proven that your algorithm does not obey the logical induction criterion. If there is no such trading algorithm then your computer program obeys the logical induction criterion.</p>
<p><strong>What does it mean to “trade against” a computer program that outputs credences?</strong> We interpret each credence as a price for a token that pays $1 if the respective sentence is eventually confirmed as true. So a credence of 0.6 assigned to X means that I am willing to sell you a token for 60c that pays out $1 if X is eventually confirmed as true. What it means to “be confirmed as true” is that X appears in the observation stream. Here is an example with three successive updates and a single trading algorithm that trades against the logical inductor:</p>
<p class="imgonly"><img src="https://res.cloudinary.com/lesswrong-2-0/image/upload/v1674653773/mirroredImages/jtMXj24Masrnq3SpS/xmdzfvxb8qxaugqb1ewc.png" alt="https://storage.googleapis.com/doc-publisher-images/4a66650f2e3d9bc2.png" loading="lazy"></p>
<p>Note:</p>
<ol><li>
<p>The logical inductor’s credences may not immediately reflect its observations. Even though it knows that the sky must either be blue or green on the first day, it still doesn’t assign 100% credence to the sentence “the sky is blue or the sky is green”. It is guaranteed to converge to 100% eventually on that sentence, but it may take a while.</p>
</li><li>
<p>The logical inductor credences may not immediately be probabilistically consistent. Even though it knows that the sky must either be blue or green, on the second day it assigns 0.8 credence to “the sky is blue” and 0.25 credence to the “the sky is green”, which don’t sum to 1. It will converge on credences that sum to 1 eventually, but it may take a while.</p>
</li><li>
<p>This example shows trades made by just one possible trading algorithm. I chose the numbers in the “purchase quantities” row arbitrarily.</p>
</li><li>
<p>This trading policy only makes trades in one sentence. That is just for simplicity. In general trading policies can make trades in any number of sentences after each update.</p>
</li><li>
<p>The last two rows in the figure are calculated as follows.</p>
</li><li>
<p>On the first update we spent $4.20 to purchase 6 tokens of “sky is blue”. If it turns out that the sky really is blue, then our tokens will be worth $6 ($1 for each of 6 tokens), in which case we will have made a <strong>profit of $1.80</strong>. If it turns out that the sky is not blue then our tokens are worth $0 and we will have <strong>lost</strong> <strong>$4.20</strong>. At this point we have only purchased tokens in this one sentence so the minimum and maximum possible value of our holdings are <strong>$4.20</strong> and <strong>-$1.80</strong> respectively.</p>
</li><li>
<p>On the second update we purchased a further 3.5 tokens of “the sky is blue” for $3.00 ( the price per token for this sentence changed between the first and second update). We now own 9.5 tokens, which could be worth $9.50 if the sky really is blue, in which case we would have made a profit of <strong>$2.30</strong>. If the sky turns out not to be blue then we will now have lost <strong>$7.20</strong>. In this example we only purchase tokens in one sentence in order to keep the calculations simple, but in general any number of tokens in any number of sentences can be purchased.</p>
</li><li>
<p>On the third update we observe that the sky is blue. When calculating the “min” and “max” rows we only consider possibilities that are logically consistent with what we have observed. Since we own 9.5 tokens of “the sky is blue” and we know now that the sky really is blue, the min and max values become identical at <strong>$2.30</strong>.</p>
</li></ol>
<p><strong>What does it mean to make unboundedly much money?</strong> If the maximum possible value of a trading algorithm’s holdings grows larger and larger over time without limit, while the minimum possible value does <em>not</em> become more and more negative without limit, then we say that the logical inductor has been “exploited”. Suppose we continued the figure above for many steps and made a graph of the “max possible value of holdings” and “min possible value of holdings”. Here are three possibilities for how the numbers could evolve:</p>
<p class="imgonly"><img src="https://res.cloudinary.com/lesswrong-2-0/image/upload/v1674653773/mirroredImages/jtMXj24Masrnq3SpS/qfg3reomkjipuhdb6rjw.png" alt="https://storage.googleapis.com/doc-publisher-images/1fb7ba40fdc56e3c.png" loading="lazy"></p>
<p>In the first figure, the max and min both keep growing unboundedly over time, and this does not meet the definition of exploitation used in the logical induction criterion. In the second figure, the max and min both reach a bound, and this again does not meet the definition of exploitation used in the logical induction criterion. In the third example the max grows unboundedly over time while the min reaches a bound, and this <em>does</em> meet the definition of exploitation used in the logical induction criterion. If there exists any polynomial time trading algorithm with a max line that grows unboundedly and a min line that reaches a bound, then the credences under consideration are exploitable. If there is no such algorithm then our credences are unexploitable and we have satisfied the logical induction criterion.</p>
<p><strong>What is the restricted class of trading algorithms?</strong> Logical inductors do not have to be unexploitable versus <em>all possible algorithms</em>, only to a certain restricted class that we will call “trading algorithms”. A trading algorithm is a polynomial time computer program that outputs “trading policies”. A trading policy is a list of pairs of (sentence, trading formula). A trading formula is a continuous function, built up from six primitives, that inputs a list of lists of (sentence, credence) pairs and outputs a real number representing a quantity of tokens to purchase.</p>
<p>The six trading primitives are:</p>
<ol><li>
<p>Purchase a constant number of tokens</p>
</li><li>
<p>Take the sum of two trading formulas and purchase that many tokens</p>
</li><li>
<p>Take the product of two trading formulas and purchase that many tokens</p>
</li><li>
<p>Take the max of two trading formulas and purchase that many tokens</p>
</li><li>
<p>Take the reciprocal of a trading formulas and purchase that many tokens</p>
</li><li>
<p>Look up the credence associated with a sentence and purchase that many tokens</p>
</li></ol>
<p>In the code, trading formulas are implemented by <a href="https://monasticacademy.github.io/logical-induction/link/Formula">Formula</a>.</p>
<p>So the trading algorithms that we must not be exploited by are actually programs that output <em>policies</em> for how much to trade as a function of the price of various sentences:</p>
<p class="imgonly"><img src="https://res.cloudinary.com/lesswrong-2-0/image/upload/v1674653773/mirroredImages/jtMXj24Masrnq3SpS/mfjhxihsttdpuz7xokbe.png" alt="https://storage.googleapis.com/doc-publisher-images/a2bb84c922b42208.png" loading="lazy"></p>
<p>The restriction in which trading algorithms must output policies, rather than directly performing trades, is crucial to making the whole logical induction system work. If we allowed trading algorithms to directly output trades then the problem of finding unexploitable credences would be so difficult that there would be no real-world algorithm that accomplishes it, because we would be asking for a computer program that systematically outsmarts every possible computer program. In this way the logical induction criterion threads the needle between capturing much of what it means to update beliefs in light of evidence, while permitting a real-world algorithm that satisfies it. This is really the crucial discovery in the whole theory of logical induction:</p>
<p class="imgonly"><img src="https://res.cloudinary.com/lesswrong-2-0/image/upload/v1674653773/mirroredImages/jtMXj24Masrnq3SpS/vg9n5oxsc9lxspspf69a.png" alt="https://storage.googleapis.com/doc-publisher-images/a3ded1b4df39aab0.png" loading="lazy"></p>
<h3>Terminology and type signatures</h3>
<p>Here is a summary of the type signatures of the concepts we have introduced in this section</p>
<table>
<thead>
<tr>
<th>Concept</th>
<th>Type</th>
<th>In the paper</th>
<th>In Python code</th>
</tr>
</thead>
<tbody>
<tr>
<td>BeliefHistory</td>
<td>List<BeliefState></td>
<td>Belief history</td>
<td><a href="https://monasticacademy.github.io/logical-induction/link/History">class History</a></td>
</tr>
<tr>
<td>Price, Constant, Sum, Product, Max, Reciprocal</td>
<td>Function: PriceHistory → List<Pair< Sentence, Number</td>
<td>Expressible feature</td>
<td><a href="https://monasticacademy.github.io/logical-induction/link/Price">class Price</a> <a href="https://monasticacademy.github.io/logical-induction/link/Constant">class Constant</a> <a href="https://monasticacademy.github.io/logical-induction/link/Sum">class Sum</a> <a href="https://monasticacademy.github.io/logical-induction/link/Product">class Product</a> <a href="https://monasticacademy.github.io/logical-induction/link/Max">class Max</a> <a href="https://monasticacademy.github.io/logical-induction/link/Reciprocal">class Reciprocal</a></td>
</tr>
<tr>
<td>TradingPrimitive</td>
<td>Price</td>
<td>Constant</td>
<td>Sum</td>
</tr>
<tr>
<td>TradingFormula</td>
<td>TreeOver<TradingPrimitive></td>
<td>Expressible feature</td>
<td><a href="https://monasticacademy.github.io/logical-induction/link/Formula">class Formula</a></td>
</tr>
<tr>
<td>TradingPolicy</td>
<td>List<Pair< Sentence, TradingFormula >></td>
<td>Trading strategy</td>
<td>N/A</td>
</tr>
<tr>
<td>TradingAlgorithm</td>
<td>Generator<TradingPolicy></td>
<td>Trader</td>
<td>N/A</td>
</tr>
</tbody>
</table>
<h3>Comparison to probability theory</h3>
<p>The formulation of probability theory given by E. T. Jayes also took the shape of a criterion and a solution to that criterion. Jaynes’ criterion was that one’s credences ought to be numerical, consistent with certain common-sense inequalities, and independent of the order in which one updates on different pieces of information. Jaynes showed that the only way of satisfying this criterion was via the sum and product rule of probability theory. This is such a strong result that it seems, from a certain perspective, to completely settle the question of how one ought to quantify and update one’s beliefs in light of evidence. However, the sum and product rules of probability theory are <em>not computable in general!</em> The reason is that one can set up arbitrarily complicated logical relationships between variables in such a way that evaluating the sum and product rule is equivalent to determining whether certain computer programs halt or not, which is uncomputable.</p>
<p>In statistical learning theory it is actually rather <em>rare</em> to formulate a statistical problem in which the sum and product rule can be evaluated exactly. Instead, an approximation algorithm is used, and as a result there is a separation between the theory concerning what one ought to compute (probability theory), and the theory concerning how to approximate that (some particular approximation algorithm and its guarantees). We rarely get strong guarantees about how the two will behave <em>over time</em> as a sequence of observations are processed, given finite computing resources. From this perspective, logical induction provides a unified theory about both parts of this equation (what to compute and how to compute it; the”gold standard” <em>and</em> the approximation technique). Logical induction says: follow this computable method for generating credences and the sequence of your belief states over time will have such-and-such nice properties. Of course, logical induction is at present highly <em>impractical</em> due to its very high time complexity. However, it may point the way towards something that is actually <em>more</em> practical than probability theory, even in cases where logical uncertainty itself isn’t the main goal.</p>
<p>Another way of looking at the connection between probability theory and logical induction is that in probability theory, we require that each individual belief state be unexploitable on its own (the “no dutch book” notion), whereas the logical induction criterion requires that the <em>sequence</em> of belief states not be exploitable unboundedly <em>over time</em>. That is, the logical induction criterion makes no guarantees about any one belief state, but instead about the evolution of belief states over time.</p>
<h3>Consequences of satisfying the logical induction criterion</h3>
<p>One of the main contributions of the logical induction paper is a set of proofs showing that <em>if</em> a computer program produces credences obeying the logical induction criterion <em>then</em> those credences are guaranteed to be “reasonable” in the following ways:</p>
<ol><li>
<p><strong>Convergent</strong>. Over time, one’s credences always converge to a single value (Theorem 4.1.1 in the paper)</p>
</li><li>
<p><strong>Coherent</strong>. Over time, one’s credences eventually become consistent with the sum and product rules of probability theory (Theorem 4.1.2 in the paper)</p>
</li><li>
<p><strong>Efficient</strong>. If there is an efficient deduction algorithm that eventually proves (or disproves) a sequence of sentences, then one’s credences will converge to 1 (or 0) for all sentences in that sequence within finite time (Theorem 4.2.1 in the paper)</p>
</li><li>
<p><strong>Persistent</strong>. If one’s credences are going to reflect a certain insight in the limit, then that insight will reflected in one’s credences after a finite amount of time (Theorems 4.2.3 and 4.2.4 in the paper)</p>
</li><li>
<p><strong>Calibrated</strong>. If one’s credences converge to <em>p</em> for all sentences in some set of sentences, then roughly p% of those sentences will turn out to be true (Theorem 4.3.3 in the paper)</p>
</li><li>
<p><strong>Unbiased</strong>. For certain well-behaved sequences of sentences, there is no efficient method for detecting a predictable bias in one’s credences (Theorem 4.3.6 and 4.3.8 in the paper)</p>
</li><li>
<p><strong>Statistically competent</strong>. When faced with a sequence of unpredictable sentences of which p% are true, one’s credences in the entire sequence convert to <em>p</em> (Therems 4.4.2 and 4.4.5 in the paper)</p>
</li><li>
<p><strong>Logically competent</strong>. The sum of credences over sets of sentences among which exactly one sentence must be true converges to 1 (Theorem 4.5.1 in the paper)</p>
</li><li>
<p><strong>Non-dogmatic</strong>. One’s credences will only converge to 1 for things that are provably true, and to 0 for things that are provably false (Theorems 4.6.2 and 4.6.3 in the paper). In other words, if something is not provably true then its credence will not converge to 1, and if something is not provably false then its credence will not converge to 0.</p>
</li></ol>
<p>These properties are actually extremely subtle in their precise definition. For a full description, see the <a href="https://arxiv.org/pdf/1609.03543">logical induction paper</a>, section 4.</p>
<p>Each of these definitions talks about the behavior of one’s credences over time. Two important mathematical facts about logical inductors are that (1) if you take a logical inductor and overwrite its credences for the first finitely many updates with any credences whatsoever then it will remain a logical inductor (i.e. will still satisfy the logical induction criterion), and (2) if you overwrite a logical inductor’s credences with the limits to which its own credences would have converged, then it is <em>not</em> a logical inductor (i.e. will not satisfy the logical induction criterion). These two points show that logical induction is neither about the “early” (first finitely many) credences, <em>nor</em> about the “final” (limiting value of) credences, but about the behavior of credences over time.</p>
<h2>The logical induction algorithm</h2>
<p>Suppose now that you are a logical inductor. Some observations have been fed to you, and you have generated in return some belief states. You have just received a new observation, and you are contemplating how to update your credences.</p>
<p class="imgonly"><img src="https://res.cloudinary.com/lesswrong-2-0/image/upload/v1674653773/mirroredImages/jtMXj24Masrnq3SpS/thzsdqfhhdzokjpdiwia.png" alt="https://storage.googleapis.com/doc-publisher-images/81cc118b2564ca99.png" loading="lazy"></p>
<p>You must answer two questions:</p>
<ul><li>
<p>Which sentences should I include in the list?</p>
</li><li>
<p>Which credences should I report for each sentence?</p>
</li></ul>
<p>We will answer these question in four steps:</p>
<ul><li>
<p>First we will go through an algorithm that answers the second question in the case that there is just one trading algorithm that we are trying not to be exploited by.</p>
</li><li>
<p>Next we will show how to combine multiple trading algorithms into one, in such a way that we can apply the previous algorithm to get credences that are not exploited by any of the constituent trading algorithms.</p>
</li><li>
<p>Next we will discuss how to not be exploited by any possible trading algorithm by enumerating all possible trading algorithms one-by-one.</p>
</li><li>
<p>Finally we will discuss the first question.</p>
</li></ul>
<h3>Defeating one trading algorithm</h3>
<p>Suppose now that your task is not to defeat all possible trading algorithms as required by the logical induction criterion, but just to defeat one particular trading algorithm for which you are given the source code. Defeating a trading algorithm means that we set our credences such that the trading algorithm, through buying and selling tokens from us, does not make an unlimited amount of money. More precisely, it means that either the “min possible value” line gets more and more negative without a lower bound, or the “max possible value” reaches an upper bound, or both. Or in yet other words, it’s fine for the trading algorithm to make money from us for a little while, but we must eventually limit its exploitation such that the value of its holdings are held below some upper bound.</p>
<p>One way to make sure that this trading algorithm does not make unlimited money from us is to set our credences such that, each time it trades with us, it either:</p>
<ul><li>
<p>purchases tokens from us and the price for those tokens is $1, or</p>
</li><li>
<p>sells tokens to us and the price for those tokens is $0, or</p>
</li><li>
<p>chooses not to buy or sell any tokens from us at all</p>
</li></ul>
<p>(What it means for a trading algorithm to “sell” tokens to us is that it purchases a negative number of tokens of some sentence, which means that we pay it at the time of purchase, and it pays us the $1 per token if the sentence is confirmed as true.)</p>
<p>If a trading algorithm only purchases tokens from us at $1 or sells to us at $0 or makes no trades at all then it will certainly not make any money from us. This is not the only way to limit the amount of money this trading algorithm makes, but it is one way, and if it’s possible to do it this way then it will certainly satisfy the logical induction criterion. One central result in the logical induction paper is a demonstration that this is indeed always possible. The proof of this uses Brouwer’s fixed point theorem, and there is a further proof showing that we can efficiently find a good approximation to this fixed point using a brute force search. These proofs make use of the fact that trading algorithms must output restricted trading policies in order to trade, and that the constituent trading formulas are continuous as a function of credences, and can be further broken down into the six trading primitives. This is why the trading policies are restricted in the way that they are: in order to make this proof possible.</p>
<p>The algorithm for finding credences is actually incredibly simple: we just enumerate all possible rational-valued belief states! For each one, we evaluate the trading policy that we are trying not to be exploited by, to find out what quantity of tokens it would buy or sell at the prices implied by the belief state. Then we calculate the “max possible value of holdings” number discussed above for this one trade, and if it is less than a certain tolerance then we output the belief state. The tolerance starts at $1 for the first update, then $0.50 for the second update, then $0.25, and so on, so that the sum of all the “max possible value of holdings” numbers stays under $2 over all time. This sum represents the “best case” from the perspective of the trading algorithm, or the “worst case” value from the perspective of the logical inductor, because the logical inductor is trying to set credences so that the trading algorithm never makes very much money. By keeping this number under $2 we ensure that this particular trading algorithm does not meet the requirements of “exploitation” discussed above. The fixed-point proof guarantees that there is <em>some</em> belief state that holds the “max possible value of holdings” number to zero, and the approximation proof guarantees that we can find a rational approximation that is close enough to meet the schedule of decreasing tolerances.</p>
<p>The following diagram depicts the search space over which we search in the case that our belief state contains credences for just two sentences. If there are more sentences in our belief state then the search space has a larger number of dimensions.</p>
<p class="imgonly"><img src="https://res.cloudinary.com/lesswrong-2-0/image/upload/v1674653773/mirroredImages/jtMXj24Masrnq3SpS/wudej3vfkawtvhs9gmnb.png" alt="https://storage.googleapis.com/doc-publisher-images/31f0dfbed4c0fcb9.png" loading="lazy"></p>
<p>In the code, the function that implements this algorithm is <a href="http://monasticacademy.github.io/logical-induction/link/find_credences">here</a>. The main loop that runs the search is <a href="https://monasticacademy.github.io/logical-induction/link/search_over_credences">here</a>, the loop that calculates the “max possible value of holdings” is <a href="https://monasticacademy.github.io/logical-induction/link/max_over_worlds">here</a>, and the tolerance check is <a href="https://monasticacademy.github.io/logical-induction/link/tolerance_check">here</a>. In the first update we set a tolerance of ½, then in the second update a tolerance of ¼, then ⅛, and so on, such that the all-time sum is never larger than 1. The code that sets this tolerance schedule is <a href="https://monasticacademy.github.io/logical-induction/link/tolerance_schedule">here</a>.</p>
<p>You will notice at this point how vastly inefficient the logical induction algorithm is. The number of belief states we may need to try grows exponentially with the number of sentences, and, separately, exponentially with the number of updates that we’ve previously performed, since the tolerance gets tighter with each iteration. For each belief state we then consider a number of possible worlds that also grows exponentially with the number of sentences in order to calculate the “max possible value of holdings”. There is then a further exponentially growing inner loop caused by the way that we combine multiple trading policies into one, described below. The logical induction algorithm described here is therefore at least thrice-exponential in the number of sentences, and this doesn’t even consider the slow enumeration of possible trading algorithms discussed two sections below.</p>
<h3>Defeating multiple trading algorithms</h3>
<p>Consider now the problem of selecting a set of credences that are not exploited by any one of some fixed set of trading algorithms. As in the previous section, we may assume that we are given the source code for the trading algorithms.</p>
<p>The basic idea here will be to combine a finite number of trading policies into an “ensemble trading policy” in such a way that if we are not exploited by the ensemble trading policy, then we are not exploited by any of its constituents. To construct this ensemble trading policy, we apply a transformation to each of the trading policies that holds it to a certain budget, which is a lower bound on “min possible value of holdings”. This transformation ensures that the trading policy does not lose more than a certain amount of money in any possible world. In the diagram below, trading formulas are represented as trees of trading primitives.</p>
<p class="imgonly"><img src="https://res.cloudinary.com/lesswrong-2-0/image/upload/v1674653773/mirroredImages/jtMXj24Masrnq3SpS/jc93wvfgrxyxjm2whlgv.png" alt="https://storage.googleapis.com/doc-publisher-images/7da5b13b4ad0c240.png" loading="lazy"></p>
<p>A side note: the budget transform involves pasting the original trading formula multiple times into the output trading formula, and the number of times that the input trading formula is pasted grows exponentially with the number of sentences under consideration by the logical inductor.</p>
<p>The code that applies this budget transform is <a href="https://monasticacademy.github.io/logical-induction/link/apply_budget_transform">here</a>. The most intricate part of the whole logical induction algorithm is the code to compute the denominator in the budget transform, which is <a href="https://monasticacademy.github.io/logical-induction/link/compute_budget_factor">here</a>. Interestingly, this is the only place that the logical induction algorithm is informed by the rules of propositional logic, which happens <a href="https://monasticacademy.github.io/logical-induction/link/loop_over_consistent_worlds">here</a>.</p>
<p>Having transformed our trading policies in this way, we combine the trading policies from our different trading algorithms together in a big weighted sum. This weighted sum consists of the trading policies from our N different trading algorithms, each budgeted with multiple different budgets. We can visualize the N trading algorithms as rows in a matrix and budgets of $1, $2, $3 as the columns:</p>
<p class="imgonly"><img src="https://res.cloudinary.com/lesswrong-2-0/image/upload/v1674653773/mirroredImages/jtMXj24Masrnq3SpS/scl4zvvpgzrzjehxizdo.png" alt="https://storage.googleapis.com/doc-publisher-images/b655c8a699d5ba19.png" loading="lazy"></p>
<p>The weight for each cell in this matrix is a product of the row weight and the column weight. Note that while the budgets increase linearly, the weights decrease exponentially. Note also that the entries in each cell in the matrix are trading formulas, and when we “add” them together we are actually combining them into a larger trading formula which contains a symbolic “+” node that evaluates each of the constituent trading formulas and adds their output together.</p>
<p>The reason the budgeting transformation is necessary is that if we had one trading policy that was very smart and one that was very stupid and we simply added them together, then the losses of the stupid policy might eclipse the gains of the smart policy to such an extent that a belief state that avoids exploitation by the combination of the two algorithms may not necessarily avoid exploitation by the smart policy alone. Instead of this, the “budget transform” ensures that the stupid policy will eventually be curtailed, leaving only the smart policy active within the ensemble, which in turn means that the belief state will have to contend directly with the smartest policies in the ensemble.</p>
<p>The code that combines multiple trading policies into one is <a href="https://monasticacademy.github.io/logical-induction/link/combine_trading_algorithms">here</a>. The loop over the rows in the table depicted above is <a href="https://monasticacademy.github.io/logical-induction/link/loop_over_rows">here</a>, and the loop over columns is <a href="https://monasticacademy.github.io/logical-induction/link/loop_over_columns">here</a>. In the end we get the ensemble trading policy <a href="https://monasticacademy.github.io/logical-induction/link/the_ensemble_policy">here</a>, which we pass to the algorithm described in the previous section <a href="https://monasticacademy.github.io/logical-induction/link/find_the_credences">here</a>.</p>
<h3>Defeating all possible trading algorithms</h3>
<p>In order to not be exploited by <em>any</em> polynomial time trading algorithm, we actually just enumerate all possible trading algorithms by directly enumerating turing machines, adding one more element from this enumeration to the ensemble before each update. On the very first update, therefore, we produce a belief state that is only guaranteed not to be exploited by one particular trading algorithm (whichever happens to be the first in this enumeration). Then, on the second update, we add one further trading algorithm to the ensemble, and produce a belief state that is guaranteed not to be exploited by either of these two trading algorithms. Eventually any particular trading algorithm will appear in this enumeration, and after that the logical inductor will output belief states that are not exploited by that trading algorithm. Therefore any trading algorithm whatsoever can only exploit the logical inductor for finitely many steps.</p>
<p>In the code, the next trading algorithm is actually an <a href="https://github.com/monasticacademy/logical-induction/blob/6ed8c8f11de82274e67add942323c17fbc6ab045/inductor.py#L355">input</a> to the function that computes updates, because any real implementation of an enumeration of all turing machines would make any testing whatsoever completely impractical. In my testing I set up enumerations of trading algorithms that put the most interesting trading algorithms first, such as <a href="https://github.com/monasticacademy/logical-induction/blob/6ed8c8f11de82274e67add942323c17fbc6ab045/example/two_updates.py#L35-L45">here</a>.</p>
<h3>Deciding which sentences to put credences on</h3>
<p>At each update we have a finite number of trading algorithms, each of which generates a trading policy, each of which contains a table of (sentence, trading formula) pairs, and each trading formula is a tree that looks up credences for some finite number of sentences. We take the union of all the sentences referenced in the trading policy tables (the sentences that the trading policies will attempt to trade on) together with all the sentences referenced within any of the trading formula trees (the sentences whose prices affect the behavior of the trading policies) as the set of sentences to place credences on.</p>
<p>What this means is that we are leaving it to the user to decide in what order to enumerate all the possible trading algorithms, and using that ordering to determine which sentences to place credences on at which time.</p>
<p>There is no need to place credences on sentences that aren’t used as inputs to a trading formula and aren’t traded on by any trading policy, because credences in these sentences wouldn’t affect anything. Our goal at each step is to find a set of credences that cause the current ensemble trader to trade very little, and in order to do this it makes sense to only consider the sentences that affect the current ensemble trader’s behavior or holdings.</p>
<h3>Summary of the algorithm</h3>
<p>In block diagram form, the process for generating a set of credences for a single update looks like this:</p>
<p class="imgonly"><img src="https://res.cloudinary.com/lesswrong-2-0/image/upload/v1674653773/mirroredImages/jtMXj24Masrnq3SpS/r8zhojcoem2enu0ggngw.png" alt="https://storage.googleapis.com/doc-publisher-images/be785261c0658d70.png" loading="lazy"></p>
<p>Here are links to the code for the functions referenced in monospace font in the figure above:</p>
<ul><li>
<p><a href="https://monasticacademy.github.io/logical-induction/link/LogicalInductor">LogicalInductor.update</a></p>
</li><li>
<p><a href="https://monasticacademy.github.io/logical-induction/link/compute_budget_factor">compute_budget_factor</a></p>
</li><li>
<p><a href="https://monasticacademy.github.io/logical-induction/link/combine_trading_algorithms">combine_trading_algorithms</a></p>
</li><li>
<p><a href="https://monasticacademy.github.io/logical-induction/link/find_credences">find_credences</a></p>
</li></ul>
<h2>Summary of terminology and type signatures</h2>
<table>
<thead>
<tr>
<th>Concept</th>
<th>Type</th>
<th>In the paper</th>
<th>In Python code</th>
</tr>
</thead>
<tbody>
<tr>
<td>Credence</td>
<td>Real Number</td>
<td>Price</td>
<td>float</td>
</tr>
<tr>
<td>Atom</td>
<td>Atom</td>
<td>Atom</td>
<td><a href="http://monasticacademy.github.io/logical-induction/link/Atom">class Atom</a></td>
</tr>
<tr>
<td>Sentence</td>
<td>Sentence</td>
<td>Sentence</td>
<td><a href="http://monasticacademy.github.io/logical-induction/link/Sentence">class Sentence</a></td>
</tr>
<tr>
<td>BeliefState</td>
<td>List<Pair< Sentence, Number >></td>
<td>Belief state</td>
<td>N/A</td>
</tr>
<tr>
<td>BeliefHistory</td>
<td>List<BeliefState></td>
<td>Belief history</td>
<td><a href="https://monasticacademy.github.io/logical-induction/link/History">class History</a></td>
</tr>
<tr>
<td>Price Constant Sum Product Max Reciprocal</td>
<td>Function: PriceHistory → List<Pair< Sentence, Number</td>
<td>Expressible feature</td>
<td><a href="https://monasticacademy.github.io/logical-induction/link/Price">class Price</a> <a href="https://monasticacademy.github.io/logical-induction/link/Constant">class Constant</a> <a href="https://monasticacademy.github.io/logical-induction/link/Sum">class Sum</a> <a href="https://monasticacademy.github.io/logical-induction/link/Product">class Product</a> <a href="https://monasticacademy.github.io/logical-induction/link/Max">class Max</a> <a href="https://monasticacademy.github.io/logical-induction/link/Reciprocal">class Reciprocal</a></td>
</tr>
<tr>
<td>TradingPrimitive</td>
<td>Price</td>
<td>Constant</td>
<td>Sum</td>
</tr>
<tr>
<td>TradingFormula</td>
<td>TreeOver<TradingPrimitive></td>
<td>Expressible feature</td>
<td><a href="https://monasticacademy.github.io/logical-induction/link/Formula">class Formula</a></td>
</tr>
<tr>
<td>TradingPolicy</td>
<td>List<Pair< Sentence, TradingFormula >></td>
<td>Trading strategy</td>
<td>N/A</td>
</tr>
<tr>
<td>TradingAlgorithm</td>
<td>Generator<TradingPolicy></td>
<td>Trader</td>
<td>N/A</td>
</tr>
</tbody>
</table>
<h2>Conclusion</h2>
<p>In this write-up I have explained the core logical induction criterion and algorithm in a way that I hope will be accessible to folks with a software engineering background. I have described logical induction as a computable method for assigning credences to arbitrary claims about the world, and for updating those credences in light of new evidence. I have said that the computability of logical induction necessarily implies that it can assign credences to purely logical facts.</p>
<p>I see the theory of logical induction as a stunning achievement of the 2010-era AI alignment community. It represents a successful crossing of a deep conceptual chasm, yielding a very different approach to a very fundamental aspect of intelligent systems – how they quantify and update their beliefs. Studying that different approach sheds light on a very familiar approach to the same problem – probability theory. I hope that this write-up provides a jumping-off point for deep investigations of the logical induction theory.</p>
<h2>Appendix: Worked example</h2>
<p>This following is a lightly edited export of the <a href="https://github.com/monasticacademy/logical-induction/blob/master/notebooks/three_updates.ipynb">jupyter notebook</a> from the logical induction Github repository. The <a href="https://github.com/monasticacademy/logical-induction/blob/master/notebooks/three_updates.ipynb">Github rendering of the notebook</a> may be more readable than the markdown rendering below. You can also view the <a href="https://colab.research.google.com/github/monasticacademy/logical-induction/blob/master/notebooks/three_updates.ipynb">same notebook in runnable form on Google Colab</a>.</p>
<h3>Install the logicalinduction package</h3>
<pre><code class="language-python">!pip install logicalinduction
</code></pre>
<p>Import packages</p>
<pre><code class="language-python">import itertools
import numpy as np
import matplotlib.pyplot as plt
import logicalinduction as li
</code></pre>
<h3>In the code below we will work with these 3 sentences:</h3>
<pre><code class="language-python">sentence1 = li.Atom("socrates is a man")
sentence2 = li.Atom("socrates is mortal")
sentence3 = li.Implication(sentence1, sentence2)
</code></pre>
<h3>First we create a helper function that builds trading formulas</h3>
<p>This helper returns trading formulas that “buy” whenever the price (credence) for a sentence is below a certain threashold p.</p>
<pre><code class="language-python">def trade_on_probability(sentence, index, p, slope=10):
return li.Min(
li.Constant(1),
li.Max(
li.Constant(-1),
li.Sum(
li.Constant(slope * p),
li.Product(
li.Constant(-slope),
li.Price(sentence1, index)
)
)
)
)
</code></pre>
<h3>Let’s plot the quantity traded by this formula as a function of price</h3>
<pre><code class="language-python">f = trade_on_probability(sentence1, 1, .8)
credences = np.linspace(0, 1, 30)
purchase_quantities = [f.evaluate(li.History([{sentence1: cr}])) for cr in credences]
plt.xlabel('price (credence)')
plt.ylabel('quantity')
plt.plot(credences, purchase_quantities)
</code></pre>
<p class="imgonly"><img src="https://res.cloudinary.com/lesswrong-2-0/image/upload/v1674653773/mirroredImages/jtMXj24Masrnq3SpS/txbgyypvpyrtk417taad.png" alt="https://storage.googleapis.com/doc-publisher-images/688c03e8f5b92e0e.png" loading="lazy"></p>
<p>As you can see, this trading formula says to purchase 1 token of sentence1 whenever that sentence’s price, or credence, is below 0.8, or zero tokens if the price is above 0.8. Actually there is a region just around 0.8 where the quantity move linearly from 1 down to 0 -- this is actually very important.</p>
<h3>Now we define a trading algorithm</h3>
<p>A trading algorithm is a generator of trading policies, which are maps from sentences to trading formulas</p>
<pre><code class="language-python">def trading_alg(sentence, probability):
count = 1
while True:
yield {sentence: trade_on_probability(sentence, count, probability)}
count += 1
</code></pre>
<h3>Create a logical inductor and perform two updates</h3>
<pre><code class="language-python">inductor = li.LogicalInductor()
first_credences = inductor.update(sentence3, trading_alg(sentence3, .5))
print("after first update:")
for sentence, credence in first_credences.items():
print(f' credence for "{sentence}"" is {credence}')
second_credences = inductor.update(sentence2, trading_alg(sentence3, .5))
print("after second update:")
for sentence, credence in second_credences.items():
print(f' credence for "{sentence}"" is {credence}')
third_credences = inductor.update(sentence1, trading_alg(sentence3, .5))
print("after third update:")
for sentence, credence in third_credences.items():
print(f' credence for "{sentence}"" is {credence}')
</code></pre>
<pre><code> after first update:
credence for "socrates is a man"" is 0
credence for "socrates is a man → socrates is mortal"" is 0
after second update:
credence for "socrates is a man"" is 0
credence for "socrates is a man → socrates is mortal"" is 1
after third update:
credence for "socrates is a man"" is 0
credence for "socrates is a man → socrates is mortal"" is 1
</code></pre>
<p>That’s it! The rest of this notebook will explore the inner workings of the update function used above.</p>
<h3>Let’s look at the inner workings of the logical induction algorithm</h3>
<p>First we will get a concrete trading algorithm and pull out the trading policy it uses on the first update.</p>
<pre><code class="language-python">the_trading_alg = trading_alg(sentence1, .8)
</code></pre>
<pre><code class="language-python">first_trading_policy = next(the_trading_alg)
</code></pre>
<h3>Now we solve for our a belief state where this trading policty makes very few trades</h3>
<p>We are going to find a set of credences that are not exploited by <code>first_trading_policy</code>. The logic for solving for credences is implemented in the library function <code>li.find_credences</code>. For this example will use an empty belief history, just as if this was our very first update ever.</p>
<pre><code class="language-python">history = li.History() # empty history
credences = li.find_credences(first_trading_policy, history, tolerance=.01)
credences
</code></pre>
<pre><code> {socrates is a man: Fraction(4, 5)}
</code></pre>
<p>We just solved for our first belief state. This belief state contains only one sentence because our trading policy <code>first_trading_policy</code> only trades on one sentence. We can check the quantity traded by our trading policy on the belief state we found:</p>
<pre><code class="language-python">updated_history = history.with_next_update(credences)
quantity = first_trading_policy[sentence1].evaluate(updated_history)
print('quantity traded is', quantity)
</code></pre>
<pre><code> quantity traded is 0.0
</code></pre>
<p>In this case our trading policy traded exactly zero, but any quantity less than the tolerance passed to <code>find_credences</code> would have been acceptable.</p>
<h3>Plot the space over which <code>find_credences</code> searches</h3>
<p>To get some insight into how <code>li.find_credences</code> works, let us plot the landscape over which it searches. It is looking for a belief state such that the maximum value-of-holdings for the given trading policy is close to zero.</p>
<pre><code class="language-python">def value_of_holdings_landscape(trading_policy, credence_history, x_sentence, y_sentence):
min_possible = np.zeros((20, 20))
max_possible = np.zeros((20, 20))
for i, x in enumerate(np.linspace(0, 1, 20)):
for j, y in enumerate(np.linspace(0, 1, 20)):
credences = {x_sentence: x, y_sentence: y}
history = credence_history.with_next_update(credences)
# check all possible worlds (all possible truth values for the support sentences)
possible_values = []
for truth_values in itertools.product([0, 1], repeat=2):
world = {sentence1: truth_values[0], sentence2: truth_values[1]}
value_of_holdings = li.evaluate(trading_policy, history, world)
possible_values.append(value_of_holdings)
min_possible[j,i] = min(possible_values)
max_possible[j,i] = max(possible_values)
return min_possible, max_possible
_, max_landscape = value_of_holdings_landscape(first_trading_policy, history, sentence1, sentence2)
</code></pre>
<pre><code class="language-python">plt.imshow(max_landscape, extent=(0, 1, 0, 1), vmin=0, vmax=1)
plt.xlabel(sentence1)
plt.ylabel(sentence2)
plt.colorbar()
plt.show()
</code></pre>
<p class="imgonly"><img src="https://res.cloudinary.com/lesswrong-2-0/image/upload/v1674653773/mirroredImages/jtMXj24Masrnq3SpS/zpmv7e8gxhgwawaop5p8.png" alt="https://storage.googleapis.com/doc-publisher-images/cee2abd3a6c19417.png" loading="lazy"></p>
<p>So we can see that this function has a local minimum when the credences for “socrates is a man” is 0.8, and as expected this function does not depend at all on the credence for “socrates is mortal”</p>
<h3>Compute a budget factor</h3>
<p>To demonstrate the inner workings of the logical induction algorithm, let’s look at the structure of a budget factor. Here is the formula from our one-sentence trading policy as a syntax tree:</p>
<pre><code class="language-python">print(first_trading_policy[sentence1].tree())
</code></pre>
<pre><code> Min
. Constant(1)
. Max
. . Constant(-1)
. . Sum
. . . Constant(8.0)
. . . Product
. . . . Constant(-10)
. . . . Price(socrates is a man, 1)
</code></pre>
<p>Now let’s compute a budget factor and print it as a syntax tree.</p>
<pre><code class="language-python">budget_factor = <a href="http://li.com" class="bare-url">li.com</a>pute_budget_factor(
budget=2,
observation_history=[],
next_observation=sentence1,
trading_history=[],
next_trading_formulas=first_trading_policy,
credence_history=history)
print(budget_factor.tree())
</code></pre>
<pre><code> SafeReciprocal
. Max
. . Product
. . . Constant(0.5)
. . . Product
. . . . Constant(-1)
. . . . Sum
. . . . . Product
. . . . . . Min
. . . . . . . Constant(1)
. . . . . . . Max
. . . . . . . . Constant(-1)
. . . . . . . . Sum
. . . . . . . . . Constant(8.0)
. . . . . . . . . Product
. . . . . . . . . . Constant(-10)
. . . . . . . . . . Price(socrates is a man, 1)
. . . . . . Sum
. . . . . . . Constant(1.0)
. . . . . . . Product
. . . . . . . . Constant(-1)
. . . . . . . . Price(socrates is a man, 1)
</code></pre>
<hr class="footnotes-sep">
<section class="footnotes">
<ol class="footnotes-list"><li id="fn-RhNkDJ5gvj6QHaxFs-1" class="footnote-item"><span class="footnote-back-link"><a href="#fnref-RhNkDJ5gvj6QHaxFs-1" class="footnote-backref">↩︎</a></span><div class="footnote-content"><p>Really what we get is the guarantee that updates are computable and that therefore at least one algorithm exists. In fact there are many possible concrete algorithms for performing updates in logical induction. </p>
</div></li></ol>
</section></hr>Alex FlintjtMXj24Masrnq3SpSSat, 03 Dec 2022 19:55:35 +0000Final Version Perfected: An Underused Execution Algorithm by willbradshaw
https://www.greaterwrong.com/posts/xfcKYznQ6B9yuxB28/final-version-perfected-an-underused-execution-algorithm
<h1><strong>TLDR</strong></h1><ul><li><p><a href="http://markforster.squarespace.com/blog/2015/5/21/the-final-version-perfected-fvp.html">Final Version Perfected</a> (FVP) is a highly effective algorithm for deciding which tasks from your To-Do lists to do in what order.</p></li><li><p>The design of the <a href="/posts/xfcKYznQ6B9yuxB28/final-version-perfected-an-underused-execution-algorithm#comment-The_FVP_Algorithm">algorithm</a> makes it far more efficient than exhaustive ranking, while (in my experience) far more effective than just reading through the tasks and picking one out.</p></li><li><p>FVP is most useful when you have a large number of tasks to choose from, don’t have time to do all of them, and are initially unsure about which is best.</p></li><li><p>I find FVP very effective at overcoming psychological issues like indecision, procrastination, or <a href="https://medium.com/@robertwiblin/ugh-fields-or-why-you-can-t-even-bear-to-think-about-that-task-5941837dac62">psychological aversion to particular tasks</a>.</p></li><li><p>Currently there are limited online tools available, and I mostly use FVP with paper lists. Ideas (or tools) for better online execution of FVP would be very valuable to me.</p></li></ul><h1><strong>Introduction</strong></h1><p>Execution is the <a href="https://en.wikipedia.org/wiki/Last_mile_(transportation)">Last Mile Problem</a> of productivity infrastructure. You can put as much effort as you like into organising your goals, organising your To-Do lists, organising your calendar, but sooner or later you will be presented with more than one thing you could reasonably be doing with your time. When that happens, you will need some sort of method for choosing what that thing will be, and actually getting started.</p><p>Most people, I think, face this problem by either just doing the thing that is top-of-mind or looking through their To-Do list and picking something out. This works fine when the next thing to do is obvious, and you have no problems getting started on it. But when you have many potential things to do and aren’t sure which is best, or when you kind of know what the best next thing is but are avoiding it for one reason or another, you need a better system.</p><p>That system needs to be quick to execute, easy to remember, and effective at actually having you do the best next task. It needs to be robust to your psychological weaknesses, minimising procrastination, indecision, and ugh fields. It needs to be efficient, requiring as little work as possible to identify the most valuable task.</p><p>Enter <a href="http://markforster.squarespace.com/blog/2015/5/21/the-final-version-perfected-fvp.html">Final Version Perfected</a>.</p><h1><strong>The FVP Algorithm</strong></h1><p>The algorithm for executing tasks under FVP is pretty simple. You can find a description of it by the designer <a href="http://markforster.squarespace.com/blog/2015/5/21/the-final-version-perfected-fvp.html">here</a>, but here’s my version:</p><ol><li><p>Put all the tasks you have to choose from into one big unsorted list.</p></li><li><p><strong>Mark</strong> the first item on the list. <strong>Don’t do it yet.</strong></p></li><li><p>For each <i>subsequent</i> item on the list, ask yourself, “Do I want to do this task more than the <i>last task I marked</i>?” If yes, <strong>mark it</strong>. If no, <strong>don’t mark it</strong>. Move on to the next item.</p></li><li><p>When you reach the end of the list, trace back up to find the bottom-most marked task. <strong>Do it</strong>, then <strong>cross it off</strong> the list.</p></li><li><p>Beginning with the next unmarked task <i>after the task you just crossed off</i>, repeat step 3, comparing each task to the bottom-most uncrossed marked task (i.e. the one prior to the one you just crossed out).</p></li><li><p>Go to step 4. Repeat until you run out of time or list items.</p></li></ol><p>In FVP, then, you perform a series of pairwise comparisons between tasks, in each case asking whether the new task is something you <i>want to do more than</i> the old task. The “want to do more than” comparison is deliberately vague: Depending on context, it might be the thing that would best move your project forward, the thing that would have the worst consequences if you didn’t do it, or the thing you would most enjoy doing. The key thing is that at each stage, you’re only comparing each task to the <i>most recent task you marked</i>, ignoring all previous tasks.</p><p>I’ll talk more in a moment about why I think this algorithm is a good one, but first, let’s work through an example. (If you’re sure you already understand the algorithm, click <a href="/posts/xfcKYznQ6B9yuxB28/final-version-perfected-an-underused-execution-algorithm#FVP__Why_and_why_not">here</a> to go straight to the pros and cons.)</p><h1><strong>A long-ish example</strong></h1><p>Let’s say this is my to-do list for today:</p><ul><li><p>Buy milk</p></li><li><p>Finish term paper</p></li><li><p>Play video games</p></li><li><p>Work out</p></li><li><p>Save the world</p></li><li><p>Walk the dog</p></li></ul><p>I start by marking the first item:</p><ul><li><p><strong>× Buy milk</strong></p></li><li><p>Finish term paper</p></li><li><p>Play video games</p></li><li><p>Work out</p></li><li><p>Save the world</p></li><li><p>Walk the dog</p></li></ul><p>Then I compare it to the next item on the list. Which do I want to do more, finish the term paper or buy milk? Well, the term paper is due today, and I don’t need milk until tomorrow, so I decide to do the term paper first.</p><ul><li><p><strong>× Buy milk</strong></p></li><li><p><strong>× Finish term paper</strong></p></li><li><p>Play video games</p></li><li><p>Work out</p></li><li><p>Save the world</p></li><li><p>Walk the dog</p></li></ul><p>Moving on to item 3. I already decided I want to finish the term paper before buying milk, so I can ignore the milk for now. Do I want to play video games or finish my term paper? Well, in some sense I <i>want</i> to play video games more, but my all-things-considered <i>endorsement</i> is to finish the term paper first, so I leave item 3 unmarked.</p><p>Next, item 4: do I want to finish the term paper or work out? Well, in some sense I’d rather not do either, and in another sense the term paper is more urgent, but working out is important, I’ve heard it has <a href="https://en.wikipedia.org/wiki/Neurobiological_effects_of_physical_exercise">cognitive benefits</a>, and I know from experience that if I don’t do it first thing I won’t do it, so it takes precedence:</p><ul><li><p><strong>× Buy milk</strong></p></li><li><p><strong>× Finish term paper</strong></p></li><li><p>Play video games</p></li><li><p><strong>× Work out</strong></p></li><li><p>Save the world</p></li><li><p>Walk the dog</p></li></ul><p>Item 5: oh yeah, I forgot, I need to save the world today. Damn. Well, I can’t work out if there’s no world to work out in, so I guess I’ll do that first.</p><ul><li><p><strong>× Buy milk</strong></p></li><li><p><strong>× Finish term paper</strong></p></li><li><p>Play video games</p></li><li><p><strong>× Work out</strong></p></li><li><p><strong>× Save the world</strong></p></li><li><p>Walk the dog</p></li></ul><p>Ditto for walking the dog: much though I love him, I won’t have anywhere to walk him if I don’t save the world first, so that takes precedence again.</p><p>I’ve finished the list now, so it’s time to do the last item on the list. Looks like that’s saving the world. Luckily, it doesn’t take long:</p><ul><li><p><strong>× Buy milk</strong></p></li><li><p><strong>× Finish term paper</strong></p></li><li><p>Play video games</p></li><li><p><strong>× Work out</strong></p></li><li><p><s>× Save the world</s> ✓</p></li><li><p>Walk the dog</p></li></ul><p>Now that I’ve done the highest priority task on the list, I go back to FVP to determine the next one. There’s actually only one comparison I need to make: work out or walk the dog? Walking the dog can wait until the evening, so it’s time to head to the gym.</p><ul><li><p><strong>× Buy milk</strong></p></li><li><p><strong>× Finish term paper</strong></p></li><li><p>Play video games</p></li><li><p><s>× Work out</s> ✓</p></li><li><p><s>× Save the world</s> ✓</p></li><li><p>Walk the dog</p></li></ul><p>Again, there’s only one more comparison I need to do to determine my next top task: do I want to finish my term paper, or walk the dog? And again, walking the dog isn’t that urgent, so I spend a few hours on the term paper.</p><ul><li><p><strong>× Buy milk</strong></p></li><li><p><s>× Finish term paper</s> ✓</p></li><li><p>Play video games</p></li><li><p><s>× Work out</s> ✓</p></li><li><p><s>× Save the world</s> ✓</p></li><li><p>Walk the dog</p></li></ul><p>Now I’m all the way back to the top of the list! But now there are <i>two</i> more comparisons to make to decide on the next task. First, do I want to buy milk, or play video games? I’ve worked pretty hard so far today, and buying milk isn’t that important, so let’s play games first:</p><ul><li><p><strong>× Buy milk</strong></p></li><li><p><s>× Finish term paper</s> ✓</p></li><li><p><strong>× Play video games</strong></p></li><li><p><s>× Work out</s> ✓</p></li><li><p><s>× Save the world</s> ✓</p></li><li><p>Walk the dog</p></li></ul><p>Finally, do I want to walk the dog or play video games? The dog has been waiting for hours for a walk now, and I could do with some fresh air, and I’d feel guilty just gaming without taking him out, so let’s do that first:</p><ul><li><p><strong>× Buy milk</strong></p></li><li><p><s>× Finish term paper</s> ✓</p></li><li><p><strong>× Play video games</strong></p></li><li><p><s>× Work out</s> ✓</p></li><li><p><s>× Save the world</s> ✓</p></li><li><p><strong>× Walk the dog</strong></p></li></ul><p>There’s no unmarked tasks in the list now, so to finish I just work up the list in order: first walking the dog, then playing games, then, finally, buying milk.</p><h1><strong>FVP: Why and why not</strong></h1><p>The usefulness of FVP depends on a few key assumptions.</p><ul><li><p>Firstly, the algorithm assumes your preferences are <a href="https://en.wikipedia.org/wiki/Transitive_relation#Examples">transitive</a>, and that you can accurately assess the value of each task according to your preferences. These are pretty fundamental assumptions that will be integral to almost any list-based execution system. In reality, your preferences probably aren’t quite transitive, but hopefully they are close enough that pretending they are is reasonable. As for accurately assessing each task, well, no execution algorithm can prevent you from making any mistakes, but FVP is more effective than most at eliciting your best guesses.</p></li><li><p>Secondly, FVP assumes that your preferences are <strong>stable</strong> over the timeframe you’re using it. If your preferences shift substantially over that period, such that you need to re-prioritise among the existing tasks on your list, you’ll need to throw out your previous FVP and start again. This places some constraints on the timescale you can organise using a single FVP iteration: I seldom stick with the same iteration for longer than a day. (Note, though, that FVP can handle the addition of <i>new</i> tasks quite easily, as long as they don’t alter the existing order.)</p></li><li><p>Thirdly, the value of FVP is greatest when you are <strong>unsure</strong> about which task you should do next, and especially when you don’t have time to do every task you might want to do that day. I find FVP most useful when I have a lot of different tasks competing for my time; it is much less useful when my time is pre-allocated to a single, well-planned-out task.</p></li></ul><p>When these conditions are met, FVP is a <i>very</i> effective method for guiding action. It is both efficient and exhaustive: guaranteed to identify the top-priority task while avoiding most of the work involved in producing a complete ranking. It is a simple algorithm, easy to remember and quick to perform. After doing it for a while, I find it scarcely requires conscious thought – but still reliably identifies the most valuable task for me to work on.</p><p>The biggest benefit I get from FVP, though, is how much easier it makes it to <a href="https://medium.com/@robertwiblin/ugh-fields-or-why-you-can-t-even-bear-to-think-about-that-task-5941837dac62">do important things I’d rather avoid</a>. There is something about a bald, pairwise comparison between two tasks that is highly effective at overcoming my aversion to difficult things. If an important but unpleasant task is nestled within a long to-do list of minor-but-rewarding busywork, it is easy for my eye to skip over the difficult task, defer it till tomorrow, and work on something more pleasant instead. It’s much harder to do that when comparing the important task to each minor task in isolation.</p><p>FVP is also good at minimising <a href="https://en.wikipedia.org/wiki/Buridan%27s_ass">time lost due to indecision</a>. When presented with a menu of tasks to choose from, it can be quite hard to select a single task to work on first. When that choice process is reduced to a series of simple pairwise comparisons, the choosing process as a whole becomes much easier. And, once I’ve finished with FVP and selected a single winning task, there’s an impetus towards starting that makes me much less prone to procrastination.</p><p>One last brief note on infrastructure: due to its relative obscurity, I haven’t found great online tools for FVP. <a href="http://complice.co/">Complice</a>’s starred-task system can be passably adapted to the algorithm, but in general I’ve found physical paper lists to work best. When I was at work I would print off my Todoist task lists and use those; now I’m working from home I mostly write them out by hand. This is kind of time-consuming and redundant, so if you dislike paper notes and don’t have access to a printer it might be a significant mark against FVP.</p><p>I’d really love it if someone created a great online tool for FVP or integrated it more formally into an existing productivity application, but I don’t expect that to happen any time soon. In the meantime, if you have ideas for existing ways to execute FVP online, I’d love to hear about them!</p>willbradshawxfcKYznQ6B9yuxB28Fri, 27 Nov 2020 10:43:02 +0000Algorithms to Live By: Ch3 Sorting by pepe_prime
https://www.greaterwrong.com/events/vJeJY6M8J4ChKoBrB/algorithms-to-live-by-ch3-sorting
<p>This is a reading group for the book Algorithms to Live By. We will read one chapter per meeting (every 2 weeks). When we meet, we’ll discuss how we can apply the concepts from the chapter to our personal lives.</p><p>If you want to join but these times or locations don’t work for you, please comment! The location is the lobby of Scandic Continental. We will have an A4 sized SlateStarCodex logo and sit in the lounge next to the reception.</p><p>Ch4 will be Feb 29.</p>pepe_primevJeJY6M8J4ChKoBrBTue, 11 Feb 2020 14:36:35 +0000Urgent & important: How (not) to do your to-do list by bfinn
https://www.greaterwrong.com/posts/dJQ7BFz9ZPqstP3an/urgent-and-important-how-not-to-do-your-to-do-list
<p>The Eisenhower Box is a well-known, simple decision matrix for dealing with tasks such as a to-do list, based on whether they’re urgent or important.</p><p>I reckon it has multiple flaws. But by fixing each flaw in turn, we end up with a better matrix, which I’ll call <strong>Hopscotch</strong>. It’s much more useful for planning your day, and can also be simplified further.</p><figure><img src="https://i.postimg.cc/5tvdZ6b9/urgent-box.jpg" loading="lazy"></figure><h2>What to do?</h2><p>The great problem of life is what to do. Your life consists of millions of decisions large and small, from making coffee to running for President. Which should you do, and when, and how?</p><p>There’s all the things to be done at work and home, constant demands and distractions, unfulfilled ambitions at the back of your mind – and barely time to think, let alone get through all this stuff.</p><p>Happily, a box has been invented to help you out. A bit like an Amazon Echo – but made only of paper & ink – it not only tells you how to deal with everything on your plate, but magically makes some of it disappear.</p><p>Or so it is claimed.</p><h2>The box</h2><p>The Eisenhower Box (or Matrix) was invented by Stephen Covey in his bestseller <a href="http://en.wikipedia.org/wiki/The_7_Habits_of_Highly_Effective_People"><i>The 7 Habits of Highly Effective People</i></a>. It was later named after US President Dwight Eisenhower, who once said:</p><blockquote><p>“I have two kinds of problems, the urgent and the important. The urgent are not important, and the important are never urgent.”</p></blockquote><p>The point being, people spend too much time on urgent-seeming but unimportant distractions, instead of on important, non-urgent matters – such as planning, people, and future opportunities. Short-term trivia divert you from what really counts.</p><p>To solve this, the Eisenhower Box tells you what to do with each task that happens along, based on whether it’s important or urgent:<span class="footnote-reference" role="doc-noteref" id="fnrefh2t2c2xa19d"><sup><a href="#fnh2t2c2xa19d">[1]</a></sup></span></p><figure><img src="https://i.postimg.cc/4NLgcDWG/Original.png" loading="lazy"></figure><p>The kind of tasks that end up in each cell, starting top-left, are:</p><ul><li><p><strong>Important & Urgent</strong> (green): things that need action ASAP, such as important meetings/calls/emails, tight deadlines, and crises. They’ve got to be done, so – like the box says – you’d better <strong>Do</strong> them.</p></li><li><p><strong>Important & Non-Urgent</strong> (blue): big-picture, longer-term, proactive things you don’t do enough of – planning, identifying opportunities, talking to people, recruiting, training, self-improvement, etc. Such things are rarely pressing, but can prevent the scrambles and crises of the stressful green cell. So <strong>Schedule</strong> these tasks in your calendar, to avoid procrastinating them for ever.</p></li><li><p><strong>Unimportant & Urgent</strong> (orange): e.g. unnecessary meetings, phone calls, interruptions, and similar needless demands from others. These grab your attention, so are easily mistaken as important – but you have better things to do, so <strong>Delegate</strong> these tasks to others.</p></li><li><p><strong>Unimportant & Non-Urgent</strong> (red): total time-wasters, such as pointless emails & business trips, aimless web browsing & social media, and other displacement activities that avoid real work. You know you shouldn’t be doing these, but go ahead anyway – because they’re easy or enjoyable, and feel a bit like work. Wise up and <strong>Delete</strong> these things entirely.</p></li></ul><p>So, for anything on your to-do list – whether work or personal – just toss it into the box, and out falls how best to deal with it. You’ll end up spending quality time on what matters, while delegating and deleting less important stuff. And everything will go swimmingly.</p><p>So far, so plausible – yes?</p><p>Well, close examination shows that this is half-right, but also half-wrong. And being half-wrong, it only half-works. But I won’t rip up the Eisenhower Box into little shreds, as we can patch it up and relabel it to make a better one.</p><hr><p>Let’s think outside the Box by questioning each of its labels in turn. (And if you’re not interested in the reasoning, skip to Hopscotch near the end for the final result.)</p><h2>Urgent / Non-urgent</h2><p>There’s certainly something special about urgent tasks. The dictionary defines ‘urgent’ as ‘<i>requiring immediate action</i>’. How could this not be crucial for deciding what to do?</p><p>Alas, Covey (the box’s inventor) uses the word both for things which really <i>are</i> urgent – like an angry phone-call from a major customer, or a crisis meeting – and those that merely <i>seem</i> urgent, like a phone-call from an insurance salesman, or a toddler shrieking for ice cream.</p><p>The former do require immediate action, but the latter merely grab your attention; they may involve urg<i>ing</i>, but they are not urg<i>ent</i>. Calling both ‘urgent’ blurs the crucial distinction; it fails to tell us which is which, and how to treat them. In fact, the real difference is that the former things are important, and the latter unimportant.<span class="footnote-reference" role="doc-noteref" id="fnreflc5zn809iq"><sup><a href="#fnlc5zn809iq">[2]</a></sup></span> But the box already makes this distinction via its rows; classifying all these tasks as Urgent doesn’t help one jot.</p><p>However, there is another aspect of urgency, and the clue is in the dictionary definition: the word ‘<i>immediate</i>’. It’s useful to know whether something needs doing ASAP, or can be dealt with another time.</p><p>More specifically, if you make a to-do list each day, it’s useful to distinguish what needs doing <strong>today</strong> from what can be put off until <strong>later</strong>, e.g. tomorrow. For example, collecting the kids from school must be done today – it can’t be postponed; whereas collecting a jacket from the dry cleaners can be done tomorrow or next week, if you don’t need it yet.</p><p>So, we can improve the Eisenhower Box by replacing Urgent/Non-Urgent with this better distinction – Today versus Later:</p><figure><img src="https://i.postimg.cc/XJVHQJvz/Today-Later.png" loading="lazy"></figure><h2>Important / Unimportant</h2><p>The box is absolutely right to identify importance as important. But we can do better.</p><p>Suppose you have a crucial project to finish today, and also a meeting you ought to attend but which isn’t essential. You’d better skip the meeting and get on with the project. Both are important, but the project is a ‘must’, and takes precedence.</p><p>Some things are more important than others; importance comes in shades of grey. But the Eisenhower Box only distinguishes black and white: Important and Unimportant. As far as it’s concerned, the project and the meeting are equally important; it can’t tell you which to do.</p><p>Far more useful is to distinguish three degrees of importance: things you <strong>must</strong> do, come what may (like the project); those you <strong>should</strong> do, which are preferable but inessential (like the meeting); and those you <strong>could</strong> do, but don’t matter much (like a lot of email). The <i>must/should/could</i> distinction is also easy to understand – we use these words all the time.<span class="footnote-reference" role="doc-noteref" id="fnrefk2enkwaiqk"><sup><a href="#fnk2enkwaiqk">[3]</a></sup></span></p><p>We can adapt the box to use them by splitting Important into two rows – Must and Should – and renaming Unimportant as Could:</p><figure><img src="https://i.postimg.cc/cCdS70qx/Must-Should-Could.png" loading="lazy"></figure><p>So now the top left half-cell is for things you Must do Today – like finish the project, or collect the kids from school – and top right, things you Must do Later, such as your tax return (not due for three months). Must means that if a task <i>isn’t</i> done, you risk disaster; and Must Today means you risk disaster if the task isn’t done <i>today</i>.<span class="footnote-reference" role="doc-noteref" id="fnrefoliixrnkalt"><sup><a href="#fnoliixrnkalt">[4]</a></sup></span> Hence, you will definitely do 100% of Must tasks if at all possible.</p><p>In the new row below the Musts are things you Should do Today – like attend the useful but inessential meeting, or eat lunch (though you might skip that too if necessary) – and things you Should do Later, e.g. buy a faster laptop, even though your current one is OK for now.</p><p>Finally, the Could row contains everything else on your to-do list.</p><h2>Do / Delegate</h2><p>The Eisenhower Box is quite right to recommend delegating. It’s inefficient, indeed impossible, to do everything yourself. So it tells you to do the Important Urgent tasks, and delegate Unimportant Urgent things to others. As the saying goes, “if you want a job done properly, do it yourself”.</p><p>But should you?</p><p>For many important tasks, you <i>shouldn’t</i> do them yourself – you should delegate them. If you’re on trial for bank robbery, don’t try to conduct your own defence – delegate that to a lawyer. Nor should you do your business’s accounts yourself; mistakes could lead to fines or a tax investigation. Delegate it to an accountant instead.</p><p>Conversely, many unimportant things aren’t worth delegating. To hang a picture on the wall, you could get a handyman in, but it’s probably not worth the hassle and cost; if you have a hammer and nail, just do it yourself. Prince Charles has a valet who <a href="http://www.theguardian.com/uk/2002/nov/16/monarchy.jamiewilson">squeezes toothpaste</a> onto the royal toothbrush for him; but it’s not worth hiring your own valet for this – squeeze your own toothpaste.</p><p>And for many tasks, whether you delegate or not depends on how busy you are. If you’re a CEO, you usually meet major customers yourself; but if some major crisis hits, you send your sales manager in your place. When you have friends round, you usually cook your best pizza recipe; but if you have to leave work late, you order a pizza delivery instead.</p><p>So the reality is, you should Do some important tasks, and Delegate others; Do some unimportant tasks and Delegate others. The box can’t tell us which. Hence we should replace these words with a single phrase that covers both – ‘<strong>deal with</strong>’:</p><figure><img src="https://i.postimg.cc/pVBxWh8p/Do-Delegate.png" loading="lazy"></figure><p>Dealing with a task means getting it done – either yourself, or by someone else. Which could be anyone who’s suitable and available: a junior, your boss, a contractor, partner, friend, etc.</p><p>The decision whether to delegate actually depends not on importance, but on what is <strong>best use of your time</strong>. For an important task for which you’re best suited – e.g. a meeting with a big customer – your time is best spent doing it yourself. Unless, that is, there’s an even better use of your time, such as handling a major crisis.</p><p>Similarly, you like making pizza, but if working late is a better use of your time, do that instead, and delegate the cooking to your local pizzeria.</p><p>You may handle the meeting better than anyone else, or make better pizza than the pizzeria, but that doesn’t necessarily mean you should do it – if you have better things to do.</p><h2>Schedule</h2><p>(Sometimes labelled ‘Do later’, ‘Decide’, or ‘Plan’.)</p><p>What about tasks in the blue cell, that we Must or Should do Later? The Eisenhower Box suggests we schedule them for some future date, which is certainly better than ignoring them. But there are other ways to handle these tasks – like, actually do them today, or at least make a start.</p><p>For if the task is a long one, i.e. a project, it’s best to start on it sooner than you might optimistically schedule. And the longer and more important the project, and the firmer the deadline, the earlier you should start. Unknown unknowns and emergencies often cause delays – and even without them, you can’t be sure you’ll finish on time. I have even heard of occasions on which things were left to the very last minute, but then turned out to take longer than expected.</p><p>Making even a small start today, such as a few minutes thinking, researching or planning, may reveal important information – e.g. that the project is much harder than you thought, or needs someone or something you hadn’t anticipated.</p><p>Alternatively, it may make sense to delegate the task, or some part of it. In which case, the sooner you do so the better, so whoever you’re delegating to can fit it into their schedule. They may be busy too.</p><p>So for blue-cell tasks, as an alternative to scheduling them, also consider doing, delegating, or at least starting on them today. That is, ‘deal with’ them:</p><figure><img src="https://i.postimg.cc/kGwdfz9x/Deal-with-or-Schedule.png" loading="lazy"></figure><h2>Delete</h2><p>(Sometimes called ‘Eliminate’ or ‘Drop’.)</p><p>Some things really are a waste of time, and the Eisenhower Box is right to try to stop us doing them. But does it identify them correctly?</p><p>Just as the Important row combines two degrees of importance – essential (Must) and merely preferable (Should) – the Unimportant row hides two degrees of unimportance: things worth getting done if possible, and things <i>never</i> worth doing. Like aimless web surfing, social media (in work time), pointless emails, and other wastes of time.</p><p>However, the latter aren’t so much tasks you Could do, as things you <i>shouldn’t</i> do; they really belong on a separate ‘Shouldn’t’ row below, for stuff you actually should Delete:</p><figure><img src="https://i.postimg.cc/NjKwkdnH/Shouldnt.png" loading="lazy"></figure><p>That said, in practice we don’t need this extra row, because you already know you shouldn’t do these things. It’s not as if ‘watch cat videos’ is on your to-do list, and you need the box to decide between that or some crucial project; you already know the answer. So we can forget about total time-wasters – just don’t do them.</p><p>Apart from those, everything else you Could do <i>might</i> be worth doing someday – so there is no point deleting them.</p><p>For example, suppose your bathroom is looking a bit jaded, and you’re wondering whether to repaint it. This is something you Could do Later, e.g. next weekend; but on the other hand, it hardly matters. Faced with this dilemma, you may be tempted to be decisive: either actually do it next weekend, or forget the whole idea – Delete it.</p><p>But if you don’t repaint the bathroom next weekend, nothing is gained by deciding <i>never</i> to do it. The task can just loiter around the bottom of your list until you have nothing better to do, if ever. For the opportunity may arise, e.g. if you get painters in for some other job; or the situation may change, if in a year or two the bathroom looks much worse, or you want to sell your house, so decide to paint it after all. Why Delete tasks if you might end up doing them anyway?</p><p>This does mean your complete to-do list will include lots of minor things that may never get done.<span class="footnote-reference" role="doc-noteref" id="fnrefdzewn1ie7ae"><sup><a href="#fndzewn1ie7ae">[5]</a></sup></span> Accept this. You won’t ever finish your list – and that’s OK. For if there were nothing left to do, what would there be to live for?</p><p>So, we shouldn’t have a Shouldn’t row; let’s delete Delete; and instead make anything you could do later just another task to Deal With, if you ever get around to it:</p><figure><img src="https://i.postimg.cc/J448GrcK/Delete.png" loading="lazy"></figure><p>Note the phrase ‘get around to it’. Unimportant tasks loiter at the bottom of your to-do list, seldom getting done, because you almost always have other things to do <i>first</i>.</p><p>So what should you do first? And what then, and after that?</p><h2>Prioritizing</h2><p>The Eisenhower Box kind of assumes you’ll have enough time to do what it tells you. But what if you don’t? Scheduling should be quick enough, but there may not be enough hours in the day to Do all the green tasks, let alone Delegate the orange ones (as delegating can take time). Something must give; but what?</p><p>If we can work out an order of priority for tasks, then if you don’t complete them today, at least you’ll have done what matters most. We can figure out the order like this (bear with me):</p><p>Must Todays must by definition be dealt with today, come what may – so do them first of all. Doing anything else increases the risk of not completing them.</p><p>Should Todays are more important than Coulds, so should be done before them. Doing Coulds instead of what you Should be doing is a symptom of ‘busyness’ – merrily filling your day with minor tasks that aren’t a waste of time, but aren’t much use either.</p><p>A harder conundrum is: which is higher priority, Should Today or Must Later? The pressing meeting, or the crucial long-term strategy that can wait? Well, if you do Should Todays first, you may not get through the Must Laters on your list. And if this happens day after day, some Must Laters will be procrastinated indefinitely, and you’ll miss crucial deadlines and opportunities. Whereas Should Todays are merely desirable. Hence it’s best to deal with Must Laters <i>before</i> Should Todays; and if you’re too busy to work on a Must Later, at least you can schedule it in seconds.</p><p>For example, suppose your business relies on selling just one product. At some point you must come up with a new one – a task you Must do Later. But you’re so focussed on your current product that your to-do list is full of Should Todays – reply to enquiries, order stock, issue invoices, etc. If you keep dealing with these every day rather than even thinking about a new product, a sudden competitor to your current product could make you go bust before you can say ‘<i>mañana’</i>. But by prioritizing Must Laters before Should Todays, you’ll either start planning your new product today, or at least put a date in the diary to do so.</p><p>And by the same reasoning, Should Laters are higher priority than Could Todays.</p><p>Putting this all together, the best order for tasks turns out as:</p><p>1. Must Today</p><p>2. Must Later</p><p>3. Should Today</p><p>4. Should Later</p><p>5. Could Today/Later</p><p>(though there are exceptions, discussed below).</p><p>With Coulds, it’s hardly worth distinguishing Could Todays from Could Laters. The timing of Coulds usually doesn’t matter much, because the task itself doesn’t matter much, and you probably won’t get round to it today anyway. Hence we can combine them into a single Could category.</p><hr><p>Now let’s redraw our reworked box more neatly. Every cell is now just something to ‘deal with’ (or ‘schedule’) – so we can lose the colours, and replace ‘deal with’ with the above numbers for the order to do those tasks in:</p><h2>Hopscotch</h2><figure><img src="https://i.postimg.cc/LXtSZhbQ/Hopscotch.png" loading="lazy"></figure><p>For <a href="http://www.google.com/search?q=hopscotch&+source=lnms&tbm=isch&sa=X">whimsical reasons</a> I’ll call this new box and method <strong>Hopscotch</strong>. Use it like this:</p><h3>Plan the day</h3><p>At the start of each day, go through your full to-do list and appointments, and ask yourself which things you <i>must</i> deal with <i>today</i>, <i>must</i> deal with <i>later</i>, <i>should</i> deal with <i>today</i>, etc. Perhaps label them MT, ML, ST etc. as you go. If you have lots to do, selecting just these top three categories should suffice; but if you include Coulds, pick just the most important ones, as chances are you won’t get round to them today anyway.</p><p>Copy these tasks to make a separate plan for the day. Then put them in the Hopscotch number order: Must Todays first, then Must Laters, then Should Todays, etc.</p><p>Within each of these categories, put tasks into roughly descending order of importance; if unsure, also consider which need doing sooner. It’s often unclear whether something counts as a Must or a Should, or a Should versus Could, but that hardly matters if tasks are ordered within each category too.</p><p>You can then move tasks around for a few reasons:</p><ul><li><p>If it’s at a <strong>fixed time</strong> (e.g. a scheduled meeting/call), or must be done <strong>after something</strong> <strong>else</strong> (e.g. awaiting approval), move it to about where in the order you expect to do it.</p></li><li><p>Put <strong>related tasks</strong> <strong>together</strong> to increase efficiency, e.g. ones from the same project or in the same location. If you Must go to the dentist, you may as well buy some milk nearby to save a separate trip, even if that’s just a Should. (But think twice about moving Coulds earlier.)</p></li><li><p>Move a <strong>quick Should Today</strong> task earlier <i>if</i> it’s best done ASAP. E.g. by sending a one-line email first thing, so the recipient can work on it today.</p></li><li><p>All that said, if your <strong>Must Todays might take all day</strong>, don’t do anything else until they’re finished.</p></li></ul><p>It’s easiest if your full to-do list is in software – even good ol’ Microsoft Word will do – and you keep it in rough order of importance.</p><h3>Using the day plan</h3><p>Now, down to work. Deal with tasks in the planned order; don’t cherry-pick ones you feel like doing. Remember that ‘dealing with’ a task can involve getting someone else to (delegating), depending on what’s the best use of your time, and who else could do it.</p><p>Whenever a new task arrives during the day, again ask yourself whether you really <i>must</i> deal with it <i>today</i>. If so, do it next, or add it among the Must Todays; if not, you can probably just leave it for consideration tomorrow.</p><p>You may well not get through everything by the end of the day. That’s fine – leftover tasks can go on tomorrow’s plan. But when you compile it, reconsider whether leftovers are still Must/Should/Could or Today/Later, as their priorities may have changed; they may not even be worth including.</p><h3>Simpler version</h3><p>Hopscotch is pretty simple, with just one more cell than the Eisenhower Box. Try it for a few days, and see how it works for you.</p><p>But for something even simpler, we can combine cells 2 & 3, and 4 & 5, to produce a minimal system that doesn’t even need a box:</p><ul><li><p>Start with tasks you <strong>must</strong> deal with <strong>today</strong> (unless they have to be done later in the day)</p></li><li><p>Then, tasks you <strong>should</strong> deal with <strong>today</strong> – the most important first, including working on or scheduling things you <i>must</i> deal with sometime</p></li><li><p>Finally, deal with anything else, in order of importance.</p></li></ul><h2>Postscript</h2><p>Was I too hard on the poor old Eisenhower Box? It was only ever a rough-and-ready solution. But millions know about it, so if it can be improved on, it should be.</p><p>Hopscotch may be better, but is still quite approximate. For example, there are big issues with deciding how important things are, tasks without clear deadlines, different time horizons, and considerations beyond importance and timing. But I hope to, and perhaps Should, write about these Later.</p><ol class="footnotes" role="doc-endnotes"><li class="footnote-item" role="doc-endnote" id="fnh2t2c2xa19d"><span class="footnote-back-link"><a href="#fnrefh2t2c2xa19d">^</a></span><div class="footnote-content"><p>Stephen Covey did not propose the one-word actions for each cell, which seem to have been added by later writers, and are an oversimplification of what he says; for instance, he did not claim Unimportant Urgent tasks are the only ones you should Delegate.</p></div></li><li class="footnote-item" role="doc-endnote" id="fnlc5zn809iq"><span class="footnote-back-link"><a href="#fnreflc5zn809iq">^</a></span><div class="footnote-content"><p>Hence there are no Unimportant Urgent tasks, and nothing belongs in the orange cell. Anything truly urgent – that <i>requires</i> action – must be important, and so goes in the green cell.</p></div></li><li class="footnote-item" role="doc-endnote" id="fnk2enkwaiqk"><span class="footnote-back-link"><a href="#fnrefk2enkwaiqk">^</a></span><div class="footnote-content"><p>Some people label three degrees of importance A, B, C, or 1, 2, 3 instead; but these are arbitrary, meaningless symbols, hence liable to be used inconsistently.</p></div></li><li class="footnote-item" role="doc-endnote" id="fnoliixrnkalt"><span class="footnote-back-link"><a href="#fnrefoliixrnkalt">^</a></span><div class="footnote-content"><p>This doesn’t mean this is a Must task which you have merely <i>chosen</i> to do Today; it’s an objective deadline, e.g. for completing the project, or collecting the kids, after which things will probably go pear-shaped.</p></div></li><li class="footnote-item" role="doc-endnote" id="fndzewn1ie7ae"><span class="footnote-back-link"><a href="#fnrefdzewn1ie7ae">^</a></span><div class="footnote-content"><p>Could Laters are like ‘Someday/Maybe’ tasks in David Allen’s <a href="http://en.wikipedia.org/wiki/Getting_Things_Done"><i>Getting Things Done</i></a> system; Someday = (much) Later, Maybe = Could. He proposes keeping them in a separate list, though in reality they’re just the bottom of one big to-do list.</p></div></li></ol></hr></hr>bfinndJQ7BFz9ZPqstP3anFri, 01 Feb 2019 17:44:34 +0000My Algorithm for Beating Procrastination by lukeprog
https://www.greaterwrong.com/posts/Ty2tjPwv8uyPK9vrz/my-algorithm-for-beating-procrastination
<p>Part of the sequence: <a href="http://wiki.lesswrong.com/wiki/The_Science_of_Winning_at_Life">The Science of Winning at Life</a></p><p>After three months of practice, I now use a single algorithm to beat procrastination most of the times I face it.<sup>1</sup> It <a href="https://www.greaterwrong.com/posts/6NvbSwuSAooQxxf7f/beware-of-other-optimizing">probably won’t work for you</a> quite like it did for me, but it’s the best advice on motivation I’ve got, and it’s a major reason I’m known for having the “gets shit done” property. There are <a href="https://www.greaterwrong.com/posts/4hMQHGMnsR4GJALmc/breaking-the-chain-of-akrasia">reasons to hope</a> that we can eventually <a href="https://www.greaterwrong.com/posts/iETtCZcfmRyHp69w4/can-the-chain-still-hold-you">break the chain</a> of <a href="https://www.greaterwrong.com/posts/rRmisKb45dN7DK4BW/akrasia-tactics-review">akrasia</a>; maybe this post is one <a href="https://www.greaterwrong.com/posts/qwdupkFd6kmeZHYXy/build-small-skills-in-the-right-order">baby step</a> in the right direction.</p><p><a href="https://www.greaterwrong.com/posts/RWo4LwFzpHNQCTcYt/how-to-beat-procrastination">How to Beat Procrastination</a> explained our best current general <i>theory</i> of procrastination, called “<a href="http://webapps2.ucalgary.ca/~steel/images/Integrating.pdf">temporal motivation theory</a>” (TMT). As an exercise in <a href="https://www.greaterwrong.com/posts/LqjKP255fPRY7aMzw/practical-advice-backed-by-deep-theories">practical advice backed by deep theories</a>, <i>this</i> post explains the <i>process</i> I use to beat procrastination — a process implied by TMT.</p><p>As a reminder, here’s a rough sketch of how motivation works according to TMT:</p><figure><img src="https://web.archive.org/web/20180726091558im_/http://commonsenseatheism.com/wp-content/uploads/2011/01/procrastination-equation.png" loading="lazy"></figure><p>Or, as Piers Steel <a href="http://www.amazon.com/Procrastination-Equation-Putting-Things-Getting/dp/0061703613/">summarizes</a>:</p><blockquote><p>Decrease the certainty or the size of a task’s reward — its expectancy or its value — and you are unlikely to pursue its completion with any vigor. Increase the delay for the task’s reward and our susceptibility to delay — impulsiveness — and motivation also dips.</p></blockquote><p>Of course, my motivation system is <a href="https://www.greaterwrong.com/posts/fa5o2tg9EfJE77jEQ/the-human-s-hidden-utility-function-maybe">more complex</a> than that. P.J. Eby <a href="https://www.greaterwrong.com/posts/4hMQHGMnsR4GJALmc/breaking-the-chain-of-akrasia#comment-YKhky5H6YbeFERLe2">likens</a> TMT (as a guide for beating procrastination) to the “fuel, air, ignition, and compression” plan for starting your car: it might be true, but a more useful theory would include details and mechanism.</p><p>That’s a fair criticism. Just as an fMRI captures the “big picture” of brain function at low resolution, TMT captures the big picture of motivation. This big picture helps us see where we need to work at the gears-and-circuits level, so we can become the goal-directed <a href="https://www.greaterwrong.com/posts/wmjPGE8TZKNLSKzm4/urges-vs-goals-the-analogy-to-anticipation-and-belief">consequentialists</a> we’d <i>like</i> to be.</p><p>So, I’ll share my four-step algorithm below, and tackle the gears-and-circuits level in later posts.</p><p>Step 1: Notice I’m procrastinating.</p><p>This part’s easy. I know I <i>should</i> do the task, but I feel averse to doing it, or I just don’t feel motivated enough to care. So I put it off, even though my prefrontal cortex keeps telling me I’ll be better off if I do it <i>now</i>. When this happens, I proceed to step 2.</p><p>Step 2: Guess which unattacked part of the equation is causing me the most trouble.</p><p>Now I get to play detective. Which part of the equation is causing me trouble, here? Does the task have low value because it’s boring or painful or too difficult, or because the reward isn’t that great? Do I doubt that completing the task will pay off? Would I have to wait a long time for my reward if I succeeded? Am I particularly impatient or impulsive, either now or in general? Which part of this problem do I need to attack?</p><p>Actually, I lied. <i>I</i> like to play <i>army sniper</i>. I stare down my <a href="http://en.wikipedia.org/wiki/Telescopic_sight">telescopic sight</a> at the terms in the equation and interrogate them. “Is it <i>you</i>, Delay? Huh, motherfucker? Is it <i>you</i>? I’ve shot you before; don’t think I won’t do it again!”</p><p>But not everyone was raised on violent videogames. <i>You</i> may prefer a different role-play.</p><p>Anyway, I try to figure out where the main problem is. Here are some of the signs I look for:</p><p>When I imagine myself doing the task, do I see myself bored and distracted instead of engaged and interested? Is the task uncomfortable, onerous, or painful? Am I nervous about the task, or afraid of what might happen if I undertake it? Has the task’s payoff lost its value to me? Perhaps it never had much value to me in the first place? If my answer to any of these questions is “Yes,” I’m probably facing the motivation problem of <i>low value</i>.</p><p>Do I think I’m likely to succeed at the task? Do I think it’s within my capabilities? Do I think I’ll actually <i>get</i> the reward if I <i>do</i> succeed? If my answer to any of these questions is “No,” I’m probably facing the problem of <i>low expectancy</i>.</p><p>How much of the reward only comes after a significant delay, and how long is that delay? If most of the reward comes after a big delay, I’m probably the facing the problem of, you guessed it, <i>delay</i>.</p><p>Do I feel particularly impatient? Am I easily distracted by other tasks, even ones for which I also face problems of low value, low expectancy, or delay? If so, I’m probably facing the problem of <i>impulsiveness</i>.</p><p>If the task is low value and low expectancy, and the reward is delayed, I run my expected value calculation again. Am I sure I <i>should</i> do the task, after all? Maybe I should drop it or delegate it. If after re-evaluation I <i>still</i> think I should do the task, then I move to step 3.</p><p>Step 3: Try several methods for attacking that specific problem.</p><p>Once I’ve got a plausible suspect in my sights, I fire away with the most suitable ammo I’ve got for that problem. Here’s a quick review of some techniques described in <a href="https://www.greaterwrong.com/posts/RWo4LwFzpHNQCTcYt/how-to-beat-procrastination">How to Beat Procrastination</a>:</p><p>For <a href="https://www.greaterwrong.com/posts/RWo4LwFzpHNQCTcYt/how-to-beat-procrastination">attacking the problem of low value</a>: Get into a state of flow, perhaps by gamifying the task. Ensure the task has meaning by connecting it to what you value intrinsically. Get more energy. Use reward and punishment. Focus on what you love, wherever possible.</p><p>For <a href="https://www.greaterwrong.com/posts/RWo4LwFzpHNQCTcYt/how-to-beat-procrastination">attacking the problem of low expectancy</a>: Give yourself a series of small, challenging but achieveable goals so that you get yourself into a “success spiral” and expect to succeed. Consume inspirational material. Surround yourself with others who are succeeding. Mentally contrast where you are now and where you want to be.</p><p>For <a href="https://www.greaterwrong.com/posts/jTk9m75y2bpujwRfb/how-and-why-to-granularize">attacking the problem of delay</a>: Decrease the reward’s delay if possible. Break the task into smaller chunks so you can get rewards each step of the way.</p><p>For <a href="https://www.greaterwrong.com/posts/RWo4LwFzpHNQCTcYt/how-to-beat-procrastination">attacking the problem of impulsiveness</a>: Use precommitment. Set specific and meaningful goals and subgoal and sub-subgoals. Measure your behavior. Build useful habits.</p><p>Each of these skills must be learned and practiced first before you can use them. It took me only a few days to learn the mental habit of “mental contrasting,” but I spent <i>weeks</i> practicing the skill of getting myself into <i>success spirals</i>. I’ve spent <i>months</i> trying various methods for having more energy, but I can do a lot better than I’m doing now. I’m not very good at goal-setting yet.</p><p>Step 4: If I’m still procrastinating, return to step 2.</p><p>If I’ve found some successful techniques for attacking the term in the motivation equation I thought was causing me the most trouble, but I’m still procrastinating, I return to step 2 and begin my assault on <i>another</i> term in the equation.</p><p>When I first began using this algorithm, though, I usually didn’t get that far. By the time I had learned mental contrasting or success spirals or whatever tool made the difference, the task was either complete or abandoned. This algorithm only begins to shine, I suspect, once you’ve come to some level of mastery on most of the subroutines it employs. Then you can quickly employ them and, if you’re still procrastinating, immediately employ others, until your procrastination is beaten.</p><p>Personal examples</p><p>Let me give you some idea of what it looks like for me to use this algorithm:</p><p>Building the large 5×5-unit Ikea “<a href="http://www.ikea.com/us/en/catalog/products/00208646/#/60208648">Expedit</a>” bookshelf is boring and repetitive, so I made a game of it. I pounded each wooden peg 4 or 5 times, alternating between these two counts no matter how quickly each peg went into its hole, waiting to see if the girl I was with would notice the pattern. She didn’t, so after every 10th peg I gave her a kiss, waiting to see if she’d catch <i>that</i> pattern. She didn’t, so I started kissing her after every 5th peg.<sup>2</sup> Apparently she thought I was just especially amorous that night.</p><p>Sometimes, being an <a href="https://www.greaterwrong.com/posts/yGZHQYqWkLMbXy3z7/video-q-and-a-with-singularity-institute-executive-director">executive director</a> just ain’t fun. I need to make lots of decisions with large but uncertain consequences — decisions that some people will love and others will hate. This is not as cozy as the quiet researcher’s life to which I had been growing accustomed. In many cases, the task of coming to a decision on something is fraught with anxiety and fear, and I procrastinate. In these cases, I remind myself of how the decision is connected to what I care about. I also purposely stoke my passion for the organization’s mission by playing epic world-saving music like “<a href="http://www.youtube.com/watch?v=EzCKrwOme2U">Butterflies and Hurricanes</a>” by Muse: “Change everything you are… your number has been called… you’ve got to be the best, you’ve got to change the world… your time is now.” Then I re-do my <a href="https://www.greaterwrong.com/posts/vADtvr9iDeYsCDfxd/value-of-information-four-examples">VoI</a> and <a href="http://wiki.lesswrong.com/wiki/Expected_value">EV</a> calculations again and I god damned <a href="https://www.greaterwrong.com/posts/WLJwTJ7uGPA5Qphbp/trying-to-try"><i>try</i></a>.</p><p>While researching <a href="https://www.greaterwrong.com/posts/RWo4LwFzpHNQCTcYt/how-to-beat-procrastination">How to Beat Procrastination</a>, I hired a German tutor. I planned to apply to philosophy graduate schools, which meant I needed to speak Greek, Latin, French, or German, and German philosophy isn’t <i>quite</i> as universally bad as the others (e.g. see <a href="http://en.wikipedia.org/wiki/Thomas_Metzinger">Thomas Metzinger</a>). But I procrastinated when studying, for my reward was <i>very</i> uncertain: would I actually go the route of philosophy grad school, and would my knowledge of German help? My reward was also extremely delayed, likely by several years. In the end, I did the expected value calculation more carefully than before, and concluded that I <i>shouldn’t</i> keep trying to speak my Rs from my throat. It was the right call: I’m now pretty certain I’ll never go to philosophy grad school.</p><p>Three times, I’ve started writing books. But each time, the rewards (appreciation, notoriety, money) were so delayed and uncertain that I gave up. Instead, I broke the books into chunks that I could publish as individual articles.<sup>3</sup> Thus, I received <i>some</i> reward (appreciation, growing notoriety) after every article, and had relatively high expectancy for this reward (since my goal was no longer so lofty as to be picked up by a major publisher). Breaking it into chunks also allowed me to focus on writing the pieces for which I had the most passion. Along the way, I used many techniques to boost my energy.</p><p>Conclusion</p><p>The key is to be <i>prepared</i> to conquer procrastination by practicing the necessary sub-skills <i>first</i>. <a href="https://www.greaterwrong.com/posts/qwdupkFd6kmeZHYXy/build-small-skills-in-the-right-order">Build small skills in the right order</a>. You can’t play Philip Glass if you haven’t first learned how to play scales, how to work the pedals, how to play arpeggios and ostinatos (<a href="http://www.allmusic.com/album/r106587"><i>lots</i></a> of arpeggios and ostinatos), etc. And you can’t beat procrastination if you don’t have any ammo ready when you’ve caught the right causal factor in your sights.</p><p>The quest toward becoming a <a href="https://www.greaterwrong.com/posts/wmjPGE8TZKNLSKzm4/urges-vs-goals-the-analogy-to-anticipation-and-belief">goal-directed consequentialist</a> is long and challenging, much like that of becoming a <a href="https://www.greaterwrong.com/posts/3oYaLja5h8qL5adDn/what-curiosity-looks-like">truth-aiming rationalist</a>. But the rewards are great, and the journey has perks. Remember: <a href="https://www.greaterwrong.com/posts/vbcjYg6h3XzuqaaN8/the-power-of-agency">true agency</a> is rare but powerful. As Michael Vassar says, “Evidence that people are crazy is evidence that things are easier than you think.” Millions of projects fail not because they “can’t be done” but because the first 5 people who tried them failed due to boring, pedestrian reasons like procrastination or the planning fallacy. People with just a <i>bit</i> more agency than normal — people like <a href="http://en.wikipedia.org/wiki/Benjamin_franklin">Benjamin Franklin</a> and <a href="http://en.wikipedia.org/wiki/Timothy_Ferriss">Tim Ferriss</a> — have incredible power.</p><p>At the end of <a href="http://www.amazon.com/Reasons-Persons-Oxford-Paperbacks-Parfit/dp/019824908X/"><i>Reasons and Persons</i></a>, Derek Parfit notes that non-religious ethics is a young field, and thus we may entertain high hopes for what will be discovered and what is possible. But <a href="https://www.greaterwrong.com/posts/33KewgYhNSxFpbpXg/scientific-self-help-the-state-of-our-knowledge">scientific self-help</a> is even younger. We have only just begun our inquiry into procrastination’s causes and cures. We don’t yet know what is possible. All we can do is <a href="https://www.greaterwrong.com/posts/WLJwTJ7uGPA5Qphbp/trying-to-try">try</a>. If you have <a href="https://www.greaterwrong.com/posts/SGR4GxFK7KmW7ckCB/something-to-protect">something to protect</a>, <a href="https://www.greaterwrong.com/posts/nCvvhFBaayaXyuBiD/shut-up-and-do-the-impossible">shut up and do the impossible</a>. Things <a href="https://www.greaterwrong.com/posts/iETtCZcfmRyHp69w4/can-the-chain-still-hold-you">may not be so impossible as you once thought</a>.</p><p>Next post: <a href="https://www.greaterwrong.com/posts/ZbgCx2ntD5eu8Cno9/how-to-be-happy">How to Be Happy</a></p><p>Previous post: <a href="https://www.greaterwrong.com/posts/RWo4LwFzpHNQCTcYt/how-to-beat-procrastination">How to Beat Procrastination</a></p><p><sup>1</sup> The main areas where I still usually succumb to procrastination are diet and exercise. Luckily, my metabolism is holding out pretty well so far.</p><p><sup>2</sup> Or, it was <i>something</i> like this. I can’t remember the exact game I played, now.</p><p><sup>3</sup> My abandoned book <i>Scientific Self Help</i> turned into my ongoing blog post sequence <a href="http://wiki.lesswrong.com/wiki/The_Science_of_Winning_at_Life">The Science of Winning at Life</a>. My abandoned book <a href="http://commonsenseatheism.com/?p=14397"><i>Ethics and Superintelligence</i></a> was broken into chunks that morphed into <a href="http://intelligence.org/singularityfaq">Singularity FAQ</a>, <a href="http://commonsenseatheism.com/wp-content/uploads/2011/11/Muehlhauser-Helm-The-Singularity-and-Machine-Ethics-draft.pdf">The Singularity and Machine Ethics</a>, and many posts from <a href="http://wiki.lesswrong.com/wiki/No-Nonsense_Metaethics">No-Nonsense Metaethics</a> and <a href="http://facingthesingularity.com/"><i>Facing the Singularity</i></a>. My abandoned book <i>Friendly AI: The Most Important Problem in the World</i> was broken into pieces that resulted in <a href="https://www.greaterwrong.com/posts/FGTgeweYNxmMBx4fz/existential-risk">Existential Risk</a> and some posts of <a href="http://facingthesingularity.com/"><i>Facing the Singularity</i></a>.</p>lukeprogTy2tjPwv8uyPK9vrzFri, 10 Feb 2012 02:48:18 +0000