Still converting syntax highlighter spec.

[joypy/Thun.git] / docs / sphinx_docs / _build / html / notebooks / Derivatives_of_Regular_Expressions.html

diff --git a/docs/sphinx_docs/_build/html/notebooks/Derivatives_of_Regular_Expressions.html b/docs/sphinx_docs/_build/html/notebooks/Derivatives_of_Regular_Expressions.html
index 9123462..8c2e135 100644 (file)
--- a/docs/sphinx_docs/_build/html/notebooks/Derivatives_of_Regular_Expressions.html
+++ b/docs/sphinx_docs/_build/html/notebooks/Derivatives_of_Regular_Expressions.html
@@ -96,15 +96,15 @@ R∘λ = λ∘R = R
 </section>
 <section id="implementation">
 <h2>Implementation<a class="headerlink" href="#implementation" title="Permalink to this headline">¶</a></h2>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>from functools import partial as curry
-from itertools import product
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">functools</span> <span class="kn">import</span> <span class="n">partial</span> <span class="k">as</span> <span class="n">curry</span>
+<span class="kn">from</span> <span class="nn">itertools</span> <span class="kn">import</span> <span class="n">product</span>
 </pre></div>
 </div>
 <section id="and">
 <h3><code class="docutils literal notranslate"><span class="pre">ϕ</span></code> and <code class="docutils literal notranslate"><span class="pre">λ</span></code><a class="headerlink" href="#and" title="Permalink to this headline">¶</a></h3>
 <p>The empty set and the set of just the empty string.</p>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>phi = frozenset()   # ϕ
-y = frozenset({&#39;&#39;}) # λ
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">phi</span> <span class="o">=</span> <span class="nb">frozenset</span><span class="p">()</span>   <span class="c1"># ϕ</span>
+<span class="n">y</span> <span class="o">=</span> <span class="nb">frozenset</span><span class="p">({</span><span class="s1">&#39;&#39;</span><span class="p">})</span> <span class="c1"># λ</span>
 </pre></div>
 </div>
 </section>
@@ -115,7 +115,7 @@ illustrate the algorithm and because you can represent any other
 alphabet with two symbols (if you had to.)</p>
 <p>I chose the names <code class="docutils literal notranslate"><span class="pre">O</span></code> and <code class="docutils literal notranslate"><span class="pre">l</span></code> (uppercase “o” and lowercase “L”) to
 look like <code class="docutils literal notranslate"><span class="pre">0</span></code> and <code class="docutils literal notranslate"><span class="pre">1</span></code> (zero and one) respectively.</p>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>syms = O, l = frozenset({&#39;0&#39;}), frozenset({&#39;1&#39;})
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">syms</span> <span class="o">=</span> <span class="n">O</span><span class="p">,</span> <span class="n">l</span> <span class="o">=</span> <span class="nb">frozenset</span><span class="p">({</span><span class="s1">&#39;0&#39;</span><span class="p">}),</span> <span class="nb">frozenset</span><span class="p">({</span><span class="s1">&#39;1&#39;</span><span class="p">})</span>
 </pre></div>
 </div>
 </section>
@@ -133,7 +133,7 @@ expression</em> is one of:</p>
 </pre></div>
 </div>
 <p>Where <code class="docutils literal notranslate"><span class="pre">R</span></code> and <code class="docutils literal notranslate"><span class="pre">S</span></code> stand for <em>regular expressions</em>.</p>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>AND, CONS, KSTAR, NOT, OR = &#39;and cons * not or&#39;.split()  # Tags are just strings.
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">AND</span><span class="p">,</span> <span class="n">CONS</span><span class="p">,</span> <span class="n">KSTAR</span><span class="p">,</span> <span class="n">NOT</span><span class="p">,</span> <span class="n">OR</span> <span class="o">=</span> <span class="s1">&#39;and cons * not or&#39;</span><span class="o">.</span><span class="n">split</span><span class="p">()</span>  <span class="c1"># Tags are just strings.</span>
 </pre></div>
 </div>
 <p>Because they are formed of <code class="docutils literal notranslate"><span class="pre">frozenset</span></code>, <code class="docutils literal notranslate"><span class="pre">tuple</span></code> and <code class="docutils literal notranslate"><span class="pre">str</span></code> objects
@@ -141,36 +141,36 @@ only, these datastructures are immutable.</p>
 </section>
 <section id="string-representation-of-re-datastructures">
 <h3>String Representation of RE Datastructures<a class="headerlink" href="#string-representation-of-re-datastructures" title="Permalink to this headline">¶</a></h3>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>def stringy(re):
-    &#39;&#39;&#39;
-    Return a nice string repr for a regular expression datastructure.
-    &#39;&#39;&#39;
-    if re == I: return &#39;.&#39;
-    if re in syms: return next(iter(re))
-    if re == y: return &#39;^&#39;
-    if re == phi: return &#39;X&#39;
-
-    assert isinstance(re, tuple), repr(re)
-    tag = re[0]
-
-    if tag == KSTAR:
-        body = stringy(re[1])
-        if not body: return body
-        if len(body) &gt; 1: return &#39;(&#39; + body + &quot;)*&quot;
-        return body + &#39;*&#39;
-
-    if tag == NOT:
-        body = stringy(re[1])
-        if not body: return body
-        if len(body) &gt; 1: return &#39;(&#39; + body + &quot;)&#39;&quot;
-        return body + &quot;&#39;&quot;
-
-    r, s = stringy(re[1]), stringy(re[2])
-    if tag == CONS: return r + s
-    if tag == OR:   return &#39;%s | %s&#39; % (r, s)
-    if tag == AND:  return &#39;(%s) &amp; (%s)&#39; % (r, s)
-
-    raise ValueError
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">stringy</span><span class="p">(</span><span class="n">re</span><span class="p">):</span>
+    <span class="sd">&#39;&#39;&#39;</span>
+<span class="sd">    Return a nice string repr for a regular expression datastructure.</span>
+<span class="sd">    &#39;&#39;&#39;</span>
+    <span class="k">if</span> <span class="n">re</span> <span class="o">==</span> <span class="n">I</span><span class="p">:</span> <span class="k">return</span> <span class="s1">&#39;.&#39;</span>
+    <span class="k">if</span> <span class="n">re</span> <span class="ow">in</span> <span class="n">syms</span><span class="p">:</span> <span class="k">return</span> <span class="nb">next</span><span class="p">(</span><span class="nb">iter</span><span class="p">(</span><span class="n">re</span><span class="p">))</span>
+    <span class="k">if</span> <span class="n">re</span> <span class="o">==</span> <span class="n">y</span><span class="p">:</span> <span class="k">return</span> <span class="s1">&#39;^&#39;</span>
+    <span class="k">if</span> <span class="n">re</span> <span class="o">==</span> <span class="n">phi</span><span class="p">:</span> <span class="k">return</span> <span class="s1">&#39;X&#39;</span>
+
+    <span class="k">assert</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">re</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">),</span> <span class="nb">repr</span><span class="p">(</span><span class="n">re</span><span class="p">)</span>
+    <span class="n">tag</span> <span class="o">=</span> <span class="n">re</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
+
+    <span class="k">if</span> <span class="n">tag</span> <span class="o">==</span> <span class="n">KSTAR</span><span class="p">:</span>
+        <span class="n">body</span> <span class="o">=</span> <span class="n">stringy</span><span class="p">(</span><span class="n">re</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span>
+        <span class="k">if</span> <span class="ow">not</span> <span class="n">body</span><span class="p">:</span> <span class="k">return</span> <span class="n">body</span>
+        <span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">body</span><span class="p">)</span> <span class="o">&gt;</span> <span class="mi">1</span><span class="p">:</span> <span class="k">return</span> <span class="s1">&#39;(&#39;</span> <span class="o">+</span> <span class="n">body</span> <span class="o">+</span> <span class="s2">&quot;)*&quot;</span>
+        <span class="k">return</span> <span class="n">body</span> <span class="o">+</span> <span class="s1">&#39;*&#39;</span>
+
+    <span class="k">if</span> <span class="n">tag</span> <span class="o">==</span> <span class="n">NOT</span><span class="p">:</span>
+        <span class="n">body</span> <span class="o">=</span> <span class="n">stringy</span><span class="p">(</span><span class="n">re</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span>
+        <span class="k">if</span> <span class="ow">not</span> <span class="n">body</span><span class="p">:</span> <span class="k">return</span> <span class="n">body</span>
+        <span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">body</span><span class="p">)</span> <span class="o">&gt;</span> <span class="mi">1</span><span class="p">:</span> <span class="k">return</span> <span class="s1">&#39;(&#39;</span> <span class="o">+</span> <span class="n">body</span> <span class="o">+</span> <span class="s2">&quot;)&#39;&quot;</span>
+        <span class="k">return</span> <span class="n">body</span> <span class="o">+</span> <span class="s2">&quot;&#39;&quot;</span>
+
+    <span class="n">r</span><span class="p">,</span> <span class="n">s</span> <span class="o">=</span> <span class="n">stringy</span><span class="p">(</span><span class="n">re</span><span class="p">[</span><span class="mi">1</span><span class="p">]),</span> <span class="n">stringy</span><span class="p">(</span><span class="n">re</span><span class="p">[</span><span class="mi">2</span><span class="p">])</span>
+    <span class="k">if</span> <span class="n">tag</span> <span class="o">==</span> <span class="n">CONS</span><span class="p">:</span> <span class="k">return</span> <span class="n">r</span> <span class="o">+</span> <span class="n">s</span>
+    <span class="k">if</span> <span class="n">tag</span> <span class="o">==</span> <span class="n">OR</span><span class="p">:</span>   <span class="k">return</span> <span class="s1">&#39;</span><span class="si">%s</span><span class="s1"> | </span><span class="si">%s</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="n">r</span><span class="p">,</span> <span class="n">s</span><span class="p">)</span>
+    <span class="k">if</span> <span class="n">tag</span> <span class="o">==</span> <span class="n">AND</span><span class="p">:</span>  <span class="k">return</span> <span class="s1">&#39;(</span><span class="si">%s</span><span class="s1">) &amp; (</span><span class="si">%s</span><span class="s1">)&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="n">r</span><span class="p">,</span> <span class="n">s</span><span class="p">)</span>
+
+    <span class="k">raise</span> <span class="ne">ValueError</span>
 </pre></div>
 </div>
 </section>
@@ -180,10 +180,10 @@ only, these datastructures are immutable.</p>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">I</span> <span class="o">=</span> <span class="p">(</span><span class="mi">0</span><span class="o">|</span><span class="mi">1</span><span class="p">)</span><span class="o">*</span>
 </pre></div>
 </div>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>I = (KSTAR, (OR, O, l))
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">I</span> <span class="o">=</span> <span class="p">(</span><span class="n">KSTAR</span><span class="p">,</span> <span class="p">(</span><span class="n">OR</span><span class="p">,</span> <span class="n">O</span><span class="p">,</span> <span class="n">l</span><span class="p">))</span>
 </pre></div>
 </div>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>print stringy(I)
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span> <span class="n">stringy</span><span class="p">(</span><span class="n">I</span><span class="p">)</span>
 </pre></div>
 </div>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="o">.</span>
@@ -198,13 +198,13 @@ only, these datastructures are immutable.</p>
 </pre></div>
 </div>
 <p>Note that it contains one of everything.</p>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>a = (CONS, I, (CONS, l, (CONS, l, (CONS, l, I))))
-b = (CONS, I, (CONS, O, l))
-c = (CONS, l, (KSTAR, l))
-it = (AND, a, (NOT, (OR, b, c)))
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="o">=</span> <span class="p">(</span><span class="n">CONS</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="p">(</span><span class="n">CONS</span><span class="p">,</span> <span class="n">l</span><span class="p">,</span> <span class="p">(</span><span class="n">CONS</span><span class="p">,</span> <span class="n">l</span><span class="p">,</span> <span class="p">(</span><span class="n">CONS</span><span class="p">,</span> <span class="n">l</span><span class="p">,</span> <span class="n">I</span><span class="p">))))</span>
+<span class="n">b</span> <span class="o">=</span> <span class="p">(</span><span class="n">CONS</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="p">(</span><span class="n">CONS</span><span class="p">,</span> <span class="n">O</span><span class="p">,</span> <span class="n">l</span><span class="p">))</span>
+<span class="n">c</span> <span class="o">=</span> <span class="p">(</span><span class="n">CONS</span><span class="p">,</span> <span class="n">l</span><span class="p">,</span> <span class="p">(</span><span class="n">KSTAR</span><span class="p">,</span> <span class="n">l</span><span class="p">))</span>
+<span class="n">it</span> <span class="o">=</span> <span class="p">(</span><span class="n">AND</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="p">(</span><span class="n">NOT</span><span class="p">,</span> <span class="p">(</span><span class="n">OR</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="n">c</span><span class="p">)))</span>
 </pre></div>
 </div>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>print stringy(it)
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span> <span class="n">stringy</span><span class="p">(</span><span class="n">it</span><span class="p">)</span>
 </pre></div>
 </div>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="o">.</span><span class="mf">111.</span><span class="p">)</span> <span class="o">&amp;</span> <span class="p">((</span><span class="o">.</span><span class="mi">01</span> <span class="o">|</span> <span class="mi">11</span><span class="o">*</span><span class="p">)</span><span class="s1">&#39;)</span>
@@ -214,36 +214,36 @@ it = (AND, a, (NOT, (OR, b, c)))
 <section id="nully">
 <h3><code class="docutils literal notranslate"><span class="pre">nully()</span></code><a class="headerlink" href="#nully" title="Permalink to this headline">¶</a></h3>
 <p>Let’s get that auxiliary predicate function <code class="docutils literal notranslate"><span class="pre">δ</span></code> out of the way.</p>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>def nully(R):
-    &#39;&#39;&#39;
-    δ - Return λ if λ ⊆ R otherwise ϕ.
-    &#39;&#39;&#39;
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">nully</span><span class="p">(</span><span class="n">R</span><span class="p">):</span>
+    <span class="sd">&#39;&#39;&#39;</span>
+<span class="sd">    δ - Return λ if λ ⊆ R otherwise ϕ.</span>
+<span class="sd">    &#39;&#39;&#39;</span>
 
-    # δ(a) → ϕ
-    # δ(ϕ) → ϕ
-    if R in syms or R == phi:
-        return phi
+    <span class="c1"># δ(a) → ϕ</span>
+    <span class="c1"># δ(ϕ) → ϕ</span>
+    <span class="k">if</span> <span class="n">R</span> <span class="ow">in</span> <span class="n">syms</span> <span class="ow">or</span> <span class="n">R</span> <span class="o">==</span> <span class="n">phi</span><span class="p">:</span>
+        <span class="k">return</span> <span class="n">phi</span>
 
-    # δ(λ) → λ
-    if R == y:
-        return y
+    <span class="c1"># δ(λ) → λ</span>
+    <span class="k">if</span> <span class="n">R</span> <span class="o">==</span> <span class="n">y</span><span class="p">:</span>
+        <span class="k">return</span> <span class="n">y</span>
 
-    tag = R[0]
+    <span class="n">tag</span> <span class="o">=</span> <span class="n">R</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
 
-    # δ(R*) → λ
-    if tag == KSTAR:
-        return y
+    <span class="c1"># δ(R*) → λ</span>
+    <span class="k">if</span> <span class="n">tag</span> <span class="o">==</span> <span class="n">KSTAR</span><span class="p">:</span>
+        <span class="k">return</span> <span class="n">y</span>
 
-    # δ(¬R) δ(R)≟ϕ → λ
-    # δ(¬R) δ(R)≟λ → ϕ
-    if tag == NOT:
-        return phi if nully(R[1]) else y
+    <span class="c1"># δ(¬R) δ(R)≟ϕ → λ</span>
+    <span class="c1"># δ(¬R) δ(R)≟λ → ϕ</span>
+    <span class="k">if</span> <span class="n">tag</span> <span class="o">==</span> <span class="n">NOT</span><span class="p">:</span>
+        <span class="k">return</span> <span class="n">phi</span> <span class="k">if</span> <span class="n">nully</span><span class="p">(</span><span class="n">R</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span> <span class="k">else</span> <span class="n">y</span>
 
-    # δ(R∘S) → δ(R) ∧ δ(S)
-    # δ(R ∧ S) → δ(R) ∧ δ(S)
-    # δ(R ∨ S) → δ(R) ∨ δ(S)
-    r, s = nully(R[1]), nully(R[2])
-    return r &amp; s if tag in {AND, CONS} else r | s
+    <span class="c1"># δ(R∘S) → δ(R) ∧ δ(S)</span>
+    <span class="c1"># δ(R ∧ S) → δ(R) ∧ δ(S)</span>
+    <span class="c1"># δ(R ∨ S) → δ(R) ∨ δ(S)</span>
+    <span class="n">r</span><span class="p">,</span> <span class="n">s</span> <span class="o">=</span> <span class="n">nully</span><span class="p">(</span><span class="n">R</span><span class="p">[</span><span class="mi">1</span><span class="p">]),</span> <span class="n">nully</span><span class="p">(</span><span class="n">R</span><span class="p">[</span><span class="mi">2</span><span class="p">])</span>
+    <span class="k">return</span> <span class="n">r</span> <span class="o">&amp;</span> <span class="n">s</span> <span class="k">if</span> <span class="n">tag</span> <span class="ow">in</span> <span class="p">{</span><span class="n">AND</span><span class="p">,</span> <span class="n">CONS</span><span class="p">}</span> <span class="k">else</span> <span class="n">r</span> <span class="o">|</span> <span class="n">s</span>
 </pre></div>
 </div>
 </section>
@@ -252,71 +252,71 @@ it = (AND, a, (NOT, (OR, b, c)))
 <p>This is the straightforward version with no “compaction”. It works fine,
 but does waaaay too much work because the expressions grow each
 derivation.</p>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>def D(symbol):
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">D</span><span class="p">(</span><span class="n">symbol</span><span class="p">):</span>
 
-    def derv(R):
+    <span class="k">def</span> <span class="nf">derv</span><span class="p">(</span><span class="n">R</span><span class="p">):</span>
 
-        # ∂a(a) → λ
-        if R == {symbol}:
-            return y
+        <span class="c1"># ∂a(a) → λ</span>
+        <span class="k">if</span> <span class="n">R</span> <span class="o">==</span> <span class="p">{</span><span class="n">symbol</span><span class="p">}:</span>
+            <span class="k">return</span> <span class="n">y</span>
 
-        # ∂a(λ) → ϕ
-        # ∂a(ϕ) → ϕ
-        # ∂a(¬a) → ϕ
-        if R == y or R == phi or R in syms:
-            return phi
+        <span class="c1"># ∂a(λ) → ϕ</span>
+        <span class="c1"># ∂a(ϕ) → ϕ</span>
+        <span class="c1"># ∂a(¬a) → ϕ</span>
+        <span class="k">if</span> <span class="n">R</span> <span class="o">==</span> <span class="n">y</span> <span class="ow">or</span> <span class="n">R</span> <span class="o">==</span> <span class="n">phi</span> <span class="ow">or</span> <span class="n">R</span> <span class="ow">in</span> <span class="n">syms</span><span class="p">:</span>
+            <span class="k">return</span> <span class="n">phi</span>
 
-        tag = R[0]
+        <span class="n">tag</span> <span class="o">=</span> <span class="n">R</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
 
-        # ∂a(R*) → ∂a(R)∘R*
-        if tag == KSTAR:
-            return (CONS, derv(R[1]), R)
+        <span class="c1"># ∂a(R*) → ∂a(R)∘R*</span>
+        <span class="k">if</span> <span class="n">tag</span> <span class="o">==</span> <span class="n">KSTAR</span><span class="p">:</span>
+            <span class="k">return</span> <span class="p">(</span><span class="n">CONS</span><span class="p">,</span> <span class="n">derv</span><span class="p">(</span><span class="n">R</span><span class="p">[</span><span class="mi">1</span><span class="p">]),</span> <span class="n">R</span><span class="p">)</span>
 
-        # ∂a(¬R) → ¬∂a(R)
-        if tag == NOT:
-            return (NOT, derv(R[1]))
+        <span class="c1"># ∂a(¬R) → ¬∂a(R)</span>
+        <span class="k">if</span> <span class="n">tag</span> <span class="o">==</span> <span class="n">NOT</span><span class="p">:</span>
+            <span class="k">return</span> <span class="p">(</span><span class="n">NOT</span><span class="p">,</span> <span class="n">derv</span><span class="p">(</span><span class="n">R</span><span class="p">[</span><span class="mi">1</span><span class="p">]))</span>
 
-        r, s = R[1:]
+        <span class="n">r</span><span class="p">,</span> <span class="n">s</span> <span class="o">=</span> <span class="n">R</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span>
 
-        # ∂a(R∘S) → ∂a(R)∘S ∨ δ(R)∘∂a(S)
-        if tag == CONS:
-            A = (CONS, derv(r), s)  # A = ∂a(R)∘S
-            # A ∨ δ(R) ∘ ∂a(S)
-            # A ∨  λ   ∘ ∂a(S) → A ∨ ∂a(S)
-            # A ∨  ϕ   ∘ ∂a(S) → A ∨ ϕ → A
-            return (OR, A, derv(s)) if nully(r) else A
+        <span class="c1"># ∂a(R∘S) → ∂a(R)∘S ∨ δ(R)∘∂a(S)</span>
+        <span class="k">if</span> <span class="n">tag</span> <span class="o">==</span> <span class="n">CONS</span><span class="p">:</span>
+            <span class="n">A</span> <span class="o">=</span> <span class="p">(</span><span class="n">CONS</span><span class="p">,</span> <span class="n">derv</span><span class="p">(</span><span class="n">r</span><span class="p">),</span> <span class="n">s</span><span class="p">)</span>  <span class="c1"># A = ∂a(R)∘S</span>
+            <span class="c1"># A ∨ δ(R) ∘ ∂a(S)</span>
+            <span class="c1"># A ∨  λ   ∘ ∂a(S) → A ∨ ∂a(S)</span>
+            <span class="c1"># A ∨  ϕ   ∘ ∂a(S) → A ∨ ϕ → A</span>
+            <span class="k">return</span> <span class="p">(</span><span class="n">OR</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">derv</span><span class="p">(</span><span class="n">s</span><span class="p">))</span> <span class="k">if</span> <span class="n">nully</span><span class="p">(</span><span class="n">r</span><span class="p">)</span> <span class="k">else</span> <span class="n">A</span>
 
-        # ∂a(R ∧ S) → ∂a(R) ∧ ∂a(S)
-        # ∂a(R ∨ S) → ∂a(R) ∨ ∂a(S)
-        return (tag, derv(r), derv(s))
+        <span class="c1"># ∂a(R ∧ S) → ∂a(R) ∧ ∂a(S)</span>
+        <span class="c1"># ∂a(R ∨ S) → ∂a(R) ∨ ∂a(S)</span>
+        <span class="k">return</span> <span class="p">(</span><span class="n">tag</span><span class="p">,</span> <span class="n">derv</span><span class="p">(</span><span class="n">r</span><span class="p">),</span> <span class="n">derv</span><span class="p">(</span><span class="n">s</span><span class="p">))</span>
 
-    return derv
+    <span class="k">return</span> <span class="n">derv</span>
 </pre></div>
 </div>
 </section>
 <section id="compaction-rules">
 <h3>Compaction Rules<a class="headerlink" href="#compaction-rules" title="Permalink to this headline">¶</a></h3>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>def _compaction_rule(relation, one, zero, a, b):
-    return (
-        b if a == one else  # R*1 = 1*R = R
-        a if b == one else
-        zero if a == zero or b == zero else  # R*0 = 0*R = 0
-        (relation, a, b)
-        )
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">_compaction_rule</span><span class="p">(</span><span class="n">relation</span><span class="p">,</span> <span class="n">one</span><span class="p">,</span> <span class="n">zero</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">):</span>
+    <span class="k">return</span> <span class="p">(</span>
+        <span class="n">b</span> <span class="k">if</span> <span class="n">a</span> <span class="o">==</span> <span class="n">one</span> <span class="k">else</span>  <span class="c1"># R*1 = 1*R = R</span>
+        <span class="n">a</span> <span class="k">if</span> <span class="n">b</span> <span class="o">==</span> <span class="n">one</span> <span class="k">else</span>
+        <span class="n">zero</span> <span class="k">if</span> <span class="n">a</span> <span class="o">==</span> <span class="n">zero</span> <span class="ow">or</span> <span class="n">b</span> <span class="o">==</span> <span class="n">zero</span> <span class="k">else</span>  <span class="c1"># R*0 = 0*R = 0</span>
+        <span class="p">(</span><span class="n">relation</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span>
+        <span class="p">)</span>
 </pre></div>
 </div>
 <p>An elegant symmetry.</p>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span># R ∧ I = I ∧ R = R
-# R ∧ ϕ = ϕ ∧ R = ϕ
-_and = curry(_compaction_rule, AND, I, phi)
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># R ∧ I = I ∧ R = R</span>
+<span class="c1"># R ∧ ϕ = ϕ ∧ R = ϕ</span>
+<span class="n">_and</span> <span class="o">=</span> <span class="n">curry</span><span class="p">(</span><span class="n">_compaction_rule</span><span class="p">,</span> <span class="n">AND</span><span class="p">,</span> <span class="n">I</span><span class="p">,</span> <span class="n">phi</span><span class="p">)</span>
 
-# R ∨ ϕ = ϕ ∨ R = R
-# R ∨ I = I ∨ R = I
-_or = curry(_compaction_rule, OR, phi, I)
+<span class="c1"># R ∨ ϕ = ϕ ∨ R = R</span>
+<span class="c1"># R ∨ I = I ∨ R = I</span>
+<span class="n">_or</span> <span class="o">=</span> <span class="n">curry</span><span class="p">(</span><span class="n">_compaction_rule</span><span class="p">,</span> <span class="n">OR</span><span class="p">,</span> <span class="n">phi</span><span class="p">,</span> <span class="n">I</span><span class="p">)</span>
 
-# R∘λ = λ∘R = R
-# R∘ϕ = ϕ∘R = ϕ
-_cons = curry(_compaction_rule, CONS, y, phi)
+<span class="c1"># R∘λ = λ∘R = R</span>
+<span class="c1"># R∘ϕ = ϕ∘R = ϕ</span>
+<span class="n">_cons</span> <span class="o">=</span> <span class="n">curry</span><span class="p">(</span><span class="n">_compaction_rule</span><span class="p">,</span> <span class="n">CONS</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">phi</span><span class="p">)</span>
 </pre></div>
 </div>
 </section>
@@ -325,21 +325,21 @@ _cons = curry(_compaction_rule, CONS, y, phi)
 <p>We can save re-processing by remembering results we have already
 computed. RE datastructures are immutable and the <code class="docutils literal notranslate"><span class="pre">derv()</span></code> functions
 are <em>pure</em> so this is fine.</p>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>class Memo(object):
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Memo</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
 
-    def __init__(self, f):
-        self.f = f
-        self.calls = self.hits = 0
-        self.mem = {}
+    <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">f</span><span class="p">):</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">f</span> <span class="o">=</span> <span class="n">f</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">calls</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">hits</span> <span class="o">=</span> <span class="mi">0</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">mem</span> <span class="o">=</span> <span class="p">{}</span>
 
-    def __call__(self, key):
-        self.calls += 1
-        try:
-            result = self.mem[key]
-            self.hits += 1
-        except KeyError:
-            result = self.mem[key] = self.f(key)
-        return result
+    <span class="k">def</span> <span class="fm">__call__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">calls</span> <span class="o">+=</span> <span class="mi">1</span>
+        <span class="k">try</span><span class="p">:</span>
+            <span class="n">result</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">mem</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">hits</span> <span class="o">+=</span> <span class="mi">1</span>
+        <span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
+            <span class="n">result</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">mem</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">f</span><span class="p">(</span><span class="n">key</span><span class="p">)</span>
+        <span class="k">return</span> <span class="n">result</span>
 </pre></div>
 </div>
 </section>
@@ -347,47 +347,47 @@ are <em>pure</em> so this is fine.</p>
 <h3>With “Compaction”<a class="headerlink" href="#with-compaction" title="Permalink to this headline">¶</a></h3>
 <p>This version uses the rules above to perform compaction. It keeps the
 expressions from growing too large.</p>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>def D_compaction(symbol):
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">D_compaction</span><span class="p">(</span><span class="n">symbol</span><span class="p">):</span>
 
-    @Memo
-    def derv(R):
+    <span class="nd">@Memo</span>
+    <span class="k">def</span> <span class="nf">derv</span><span class="p">(</span><span class="n">R</span><span class="p">):</span>
 
-        # ∂a(a) → λ
-        if R == {symbol}:
-            return y
+        <span class="c1"># ∂a(a) → λ</span>
+        <span class="k">if</span> <span class="n">R</span> <span class="o">==</span> <span class="p">{</span><span class="n">symbol</span><span class="p">}:</span>
+            <span class="k">return</span> <span class="n">y</span>
 
-        # ∂a(λ) → ϕ
-        # ∂a(ϕ) → ϕ
-        # ∂a(¬a) → ϕ
-        if R == y or R == phi or R in syms:
-            return phi
+        <span class="c1"># ∂a(λ) → ϕ</span>
+        <span class="c1"># ∂a(ϕ) → ϕ</span>
+        <span class="c1"># ∂a(¬a) → ϕ</span>
+        <span class="k">if</span> <span class="n">R</span> <span class="o">==</span> <span class="n">y</span> <span class="ow">or</span> <span class="n">R</span> <span class="o">==</span> <span class="n">phi</span> <span class="ow">or</span> <span class="n">R</span> <span class="ow">in</span> <span class="n">syms</span><span class="p">:</span>
+            <span class="k">return</span> <span class="n">phi</span>
 
-        tag = R[0]
+        <span class="n">tag</span> <span class="o">=</span> <span class="n">R</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
 
-        # ∂a(R*) → ∂a(R)∘R*
-        if tag == KSTAR:
-            return _cons(derv(R[1]), R)
+        <span class="c1"># ∂a(R*) → ∂a(R)∘R*</span>
+        <span class="k">if</span> <span class="n">tag</span> <span class="o">==</span> <span class="n">KSTAR</span><span class="p">:</span>
+            <span class="k">return</span> <span class="n">_cons</span><span class="p">(</span><span class="n">derv</span><span class="p">(</span><span class="n">R</span><span class="p">[</span><span class="mi">1</span><span class="p">]),</span> <span class="n">R</span><span class="p">)</span>
 
-        # ∂a(¬R) → ¬∂a(R)
-        if tag == NOT:
-            return (NOT, derv(R[1]))
+        <span class="c1"># ∂a(¬R) → ¬∂a(R)</span>
+        <span class="k">if</span> <span class="n">tag</span> <span class="o">==</span> <span class="n">NOT</span><span class="p">:</span>
+            <span class="k">return</span> <span class="p">(</span><span class="n">NOT</span><span class="p">,</span> <span class="n">derv</span><span class="p">(</span><span class="n">R</span><span class="p">[</span><span class="mi">1</span><span class="p">]))</span>
 
-        r, s = R[1:]
+        <span class="n">r</span><span class="p">,</span> <span class="n">s</span> <span class="o">=</span> <span class="n">R</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span>
 
-        # ∂a(R∘S) → ∂a(R)∘S ∨ δ(R)∘∂a(S)
-        if tag == CONS:
-            A = _cons(derv(r), s)  # A = ∂a(r)∘s
-            # A ∨ δ(R) ∘ ∂a(S)
-            # A ∨  λ   ∘ ∂a(S) → A ∨ ∂a(S)
-            # A ∨  ϕ   ∘ ∂a(S) → A ∨ ϕ → A
-            return _or(A, derv(s)) if nully(r) else A
+        <span class="c1"># ∂a(R∘S) → ∂a(R)∘S ∨ δ(R)∘∂a(S)</span>
+        <span class="k">if</span> <span class="n">tag</span> <span class="o">==</span> <span class="n">CONS</span><span class="p">:</span>
+            <span class="n">A</span> <span class="o">=</span> <span class="n">_cons</span><span class="p">(</span><span class="n">derv</span><span class="p">(</span><span class="n">r</span><span class="p">),</span> <span class="n">s</span><span class="p">)</span>  <span class="c1"># A = ∂a(r)∘s</span>
+            <span class="c1"># A ∨ δ(R) ∘ ∂a(S)</span>
+            <span class="c1"># A ∨  λ   ∘ ∂a(S) → A ∨ ∂a(S)</span>
+            <span class="c1"># A ∨  ϕ   ∘ ∂a(S) → A ∨ ϕ → A</span>
+            <span class="k">return</span> <span class="n">_or</span><span class="p">(</span><span class="n">A</span><span class="p">,</span> <span class="n">derv</span><span class="p">(</span><span class="n">s</span><span class="p">))</span> <span class="k">if</span> <span class="n">nully</span><span class="p">(</span><span class="n">r</span><span class="p">)</span> <span class="k">else</span> <span class="n">A</span>
 
-        # ∂a(R ∧ S) → ∂a(R) ∧ ∂a(S)
-        # ∂a(R ∨ S) → ∂a(R) ∨ ∂a(S)
-        dr, ds = derv(r), derv(s)
-        return _and(dr, ds) if tag == AND else _or(dr, ds)
+        <span class="c1"># ∂a(R ∧ S) → ∂a(R) ∧ ∂a(S)</span>
+        <span class="c1"># ∂a(R ∨ S) → ∂a(R) ∨ ∂a(S)</span>
+        <span class="n">dr</span><span class="p">,</span> <span class="n">ds</span> <span class="o">=</span> <span class="n">derv</span><span class="p">(</span><span class="n">r</span><span class="p">),</span> <span class="n">derv</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
+        <span class="k">return</span> <span class="n">_and</span><span class="p">(</span><span class="n">dr</span><span class="p">,</span> <span class="n">ds</span><span class="p">)</span> <span class="k">if</span> <span class="n">tag</span> <span class="o">==</span> <span class="n">AND</span> <span class="k">else</span> <span class="n">_or</span><span class="p">(</span><span class="n">dr</span><span class="p">,</span> <span class="n">ds</span><span class="p">)</span>
 
-    return derv
+    <span class="k">return</span> <span class="n">derv</span>
 </pre></div>
 </div>
 </section>
@@ -395,26 +395,26 @@ expressions from growing too large.</p>
 <section id="lets-try-it-out">
 <h2>Let’s try it out…<a class="headerlink" href="#lets-try-it-out" title="Permalink to this headline">¶</a></h2>
 <p>(FIXME: redo.)</p>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>o, z = D_compaction(&#39;0&#39;), D_compaction(&#39;1&#39;)
-REs = set()
-N = 5
-names = list(product(*(N * [(0, 1)])))
-dervs = list(product(*(N * [(o, z)])))
-for name, ds in zip(names, dervs):
-    R = it
-    ds = list(ds)
-    while ds:
-        R = ds.pop()(R)
-        if R == phi or R == I:
-            break
-        REs.add(R)
-
-print stringy(it) ; print
-print o.hits, &#39;/&#39;, o.calls
-print z.hits, &#39;/&#39;, z.calls
-print
-for s in sorted(map(stringy, REs), key=lambda n: (len(n), n)):
-    print s
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">o</span><span class="p">,</span> <span class="n">z</span> <span class="o">=</span> <span class="n">D_compaction</span><span class="p">(</span><span class="s1">&#39;0&#39;</span><span class="p">),</span> <span class="n">D_compaction</span><span class="p">(</span><span class="s1">&#39;1&#39;</span><span class="p">)</span>
+<span class="n">REs</span> <span class="o">=</span> <span class="nb">set</span><span class="p">()</span>
+<span class="n">N</span> <span class="o">=</span> <span class="mi">5</span>
+<span class="n">names</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">product</span><span class="p">(</span><span class="o">*</span><span class="p">(</span><span class="n">N</span> <span class="o">*</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">)])))</span>
+<span class="n">dervs</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">product</span><span class="p">(</span><span class="o">*</span><span class="p">(</span><span class="n">N</span> <span class="o">*</span> <span class="p">[(</span><span class="n">o</span><span class="p">,</span> <span class="n">z</span><span class="p">)])))</span>
+<span class="k">for</span> <span class="n">name</span><span class="p">,</span> <span class="n">ds</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="n">names</span><span class="p">,</span> <span class="n">dervs</span><span class="p">):</span>
+    <span class="n">R</span> <span class="o">=</span> <span class="n">it</span>
+    <span class="n">ds</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="n">ds</span><span class="p">)</span>
+    <span class="k">while</span> <span class="n">ds</span><span class="p">:</span>
+        <span class="n">R</span> <span class="o">=</span> <span class="n">ds</span><span class="o">.</span><span class="n">pop</span><span class="p">()(</span><span class="n">R</span><span class="p">)</span>
+        <span class="k">if</span> <span class="n">R</span> <span class="o">==</span> <span class="n">phi</span> <span class="ow">or</span> <span class="n">R</span> <span class="o">==</span> <span class="n">I</span><span class="p">:</span>
+            <span class="k">break</span>
+        <span class="n">REs</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">R</span><span class="p">)</span>
+
+<span class="nb">print</span> <span class="n">stringy</span><span class="p">(</span><span class="n">it</span><span class="p">)</span> <span class="p">;</span> <span class="nb">print</span>
+<span class="nb">print</span> <span class="n">o</span><span class="o">.</span><span class="n">hits</span><span class="p">,</span> <span class="s1">&#39;/&#39;</span><span class="p">,</span> <span class="n">o</span><span class="o">.</span><span class="n">calls</span>
+<span class="nb">print</span> <span class="n">z</span><span class="o">.</span><span class="n">hits</span><span class="p">,</span> <span class="s1">&#39;/&#39;</span><span class="p">,</span> <span class="n">z</span><span class="o">.</span><span class="n">calls</span>
+<span class="nb">print</span>
+<span class="k">for</span> <span class="n">s</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="nb">map</span><span class="p">(</span><span class="n">stringy</span><span class="p">,</span> <span class="n">REs</span><span class="p">),</span> <span class="n">key</span><span class="o">=</span><span class="k">lambda</span> <span class="n">n</span><span class="p">:</span> <span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">n</span><span class="p">),</span> <span class="n">n</span><span class="p">)):</span>
+    <span class="nb">print</span> <span class="n">s</span>
 </pre></div>
 </div>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">(</span><span class="o">.</span><span class="mf">111.</span><span class="p">)</span> <span class="o">&amp;</span> <span class="p">((</span><span class="o">.</span><span class="mi">01</span> <span class="o">|</span> <span class="mi">11</span><span class="o">*</span><span class="p">)</span><span class="s1">&#39;)</span>
@@ -555,45 +555,45 @@ a --1--&gt; ∂1(a)
 <p>You can see the one-way nature of the <code class="docutils literal notranslate"><span class="pre">g</span></code> state and the <code class="docutils literal notranslate"><span class="pre">hij</span></code> “trap”
 in the way that the <code class="docutils literal notranslate"><span class="pre">.111.</span></code> on the left-hand side of the <code class="docutils literal notranslate"><span class="pre">&amp;</span></code>
 disappears once it has been matched.</p>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>from collections import defaultdict
-from pprint import pprint
-from string import ascii_lowercase
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">collections</span> <span class="kn">import</span> <span class="n">defaultdict</span>
+<span class="kn">from</span> <span class="nn">pprint</span> <span class="kn">import</span> <span class="n">pprint</span>
+<span class="kn">from</span> <span class="nn">string</span> <span class="kn">import</span> <span class="n">ascii_lowercase</span>
 </pre></div>
 </div>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>d0, d1 = D_compaction(&#39;0&#39;), D_compaction(&#39;1&#39;)
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">d0</span><span class="p">,</span> <span class="n">d1</span> <span class="o">=</span> <span class="n">D_compaction</span><span class="p">(</span><span class="s1">&#39;0&#39;</span><span class="p">),</span> <span class="n">D_compaction</span><span class="p">(</span><span class="s1">&#39;1&#39;</span><span class="p">)</span>
 </pre></div>
 </div>
 </section>
 <section id="explore">
 <h3><code class="docutils literal notranslate"><span class="pre">explore()</span></code><a class="headerlink" href="#explore" title="Permalink to this headline">¶</a></h3>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>def explore(re):
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">explore</span><span class="p">(</span><span class="n">re</span><span class="p">):</span>
 
-    # Don&#39;t have more than 26 states...
-    names = defaultdict(iter(ascii_lowercase).next)
+    <span class="c1"># Don&#39;t have more than 26 states...</span>
+    <span class="n">names</span> <span class="o">=</span> <span class="n">defaultdict</span><span class="p">(</span><span class="nb">iter</span><span class="p">(</span><span class="n">ascii_lowercase</span><span class="p">)</span><span class="o">.</span><span class="n">next</span><span class="p">)</span>
 
-    table, accepting = dict(), set()
+    <span class="n">table</span><span class="p">,</span> <span class="n">accepting</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">(),</span> <span class="nb">set</span><span class="p">()</span>
 
-    to_check = {re}
-    while to_check:
+    <span class="n">to_check</span> <span class="o">=</span> <span class="p">{</span><span class="n">re</span><span class="p">}</span>
+    <span class="k">while</span> <span class="n">to_check</span><span class="p">:</span>
 
-        re = to_check.pop()
-        state_name = names[re]
+        <span class="n">re</span> <span class="o">=</span> <span class="n">to_check</span><span class="o">.</span><span class="n">pop</span><span class="p">()</span>
+        <span class="n">state_name</span> <span class="o">=</span> <span class="n">names</span><span class="p">[</span><span class="n">re</span><span class="p">]</span>
 
-        if (state_name, 0) in table:
-            continue
+        <span class="k">if</span> <span class="p">(</span><span class="n">state_name</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span> <span class="ow">in</span> <span class="n">table</span><span class="p">:</span>
+            <span class="k">continue</span>
 
-        if nully(re):
-            accepting.add(state_name)
+        <span class="k">if</span> <span class="n">nully</span><span class="p">(</span><span class="n">re</span><span class="p">):</span>
+            <span class="n">accepting</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">state_name</span><span class="p">)</span>
 
-        o, i = d0(re), d1(re)
-        table[state_name, 0] = names[o] ; to_check.add(o)
-        table[state_name, 1] = names[i] ; to_check.add(i)
+        <span class="n">o</span><span class="p">,</span> <span class="n">i</span> <span class="o">=</span> <span class="n">d0</span><span class="p">(</span><span class="n">re</span><span class="p">),</span> <span class="n">d1</span><span class="p">(</span><span class="n">re</span><span class="p">)</span>
+        <span class="n">table</span><span class="p">[</span><span class="n">state_name</span><span class="p">,</span> <span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="n">names</span><span class="p">[</span><span class="n">o</span><span class="p">]</span> <span class="p">;</span> <span class="n">to_check</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">o</span><span class="p">)</span>
+        <span class="n">table</span><span class="p">[</span><span class="n">state_name</span><span class="p">,</span> <span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="n">names</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="p">;</span> <span class="n">to_check</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
 
-    return table, accepting
+    <span class="k">return</span> <span class="n">table</span><span class="p">,</span> <span class="n">accepting</span>
 </pre></div>
 </div>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>table, accepting = explore(it)
-table
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">table</span><span class="p">,</span> <span class="n">accepting</span> <span class="o">=</span> <span class="n">explore</span><span class="p">(</span><span class="n">it</span><span class="p">)</span>
+<span class="n">table</span>
 </pre></div>
 </div>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">{(</span><span class="s1">&#39;a&#39;</span><span class="p">,</span> <span class="mi">0</span><span class="p">):</span> <span class="s1">&#39;b&#39;</span><span class="p">,</span>
@@ -618,7 +618,7 @@ table
  <span class="p">(</span><span class="s1">&#39;j&#39;</span><span class="p">,</span> <span class="mi">1</span><span class="p">):</span> <span class="s1">&#39;h&#39;</span><span class="p">}</span>
 </pre></div>
 </div>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>accepting
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">accepting</span>
 </pre></div>
 </div>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="p">{</span><span class="s1">&#39;h&#39;</span><span class="p">,</span> <span class="s1">&#39;i&#39;</span><span class="p">}</span>
@@ -629,31 +629,31 @@ table
 <h3>Generate Diagram<a class="headerlink" href="#generate-diagram" title="Permalink to this headline">¶</a></h3>
 <p>Once we have the FSM table and the set of accepting states we can
 generate the diagram above.</p>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>_template = &#39;&#39;&#39;\
-digraph finite_state_machine {
-  rankdir=LR;
-  size=&quot;8,5&quot;
-  node [shape = doublecircle]; %s;
-  node [shape = circle];
-%s
-}
-&#39;&#39;&#39;
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">_template</span> <span class="o">=</span> <span class="s1">&#39;&#39;&#39;</span><span class="se">\</span>
+<span class="s1">digraph finite_state_machine {</span>
+<span class="s1">  rankdir=LR;</span>
+<span class="s1">  size=&quot;8,5&quot;</span>
+<span class="s1">  node [shape = doublecircle]; </span><span class="si">%s</span><span class="s1">;</span>
+<span class="s1">  node [shape = circle];</span>
+<span class="si">%s</span><span class="s1"></span>
+<span class="s1">}</span>
+<span class="s1">&#39;&#39;&#39;</span>
 
-def link(fr, nm, label):
-    return &#39;  %s -&gt; %s [ label = &quot;%s&quot; ];&#39; % (fr, nm, label)
+<span class="k">def</span> <span class="nf">link</span><span class="p">(</span><span class="n">fr</span><span class="p">,</span> <span class="n">nm</span><span class="p">,</span> <span class="n">label</span><span class="p">):</span>
+    <span class="k">return</span> <span class="s1">&#39;  </span><span class="si">%s</span><span class="s1"> -&gt; </span><span class="si">%s</span><span class="s1"> [ label = &quot;</span><span class="si">%s</span><span class="s1">&quot; ];&#39;</span> <span class="o">%</span> <span class="p">(</span><span class="n">fr</span><span class="p">,</span> <span class="n">nm</span><span class="p">,</span> <span class="n">label</span><span class="p">)</span>
 
 
-def make_graph(table, accepting):
-    return _template % (
-        &#39; &#39;.join(accepting),
-        &#39;\n&#39;.join(
-          link(from_, to, char)
-          for (from_, char), (to) in sorted(table.iteritems())
-          )
-        )
+<span class="k">def</span> <span class="nf">make_graph</span><span class="p">(</span><span class="n">table</span><span class="p">,</span> <span class="n">accepting</span><span class="p">):</span>
+    <span class="k">return</span> <span class="n">_template</span> <span class="o">%</span> <span class="p">(</span>
+        <span class="s1">&#39; &#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">accepting</span><span class="p">),</span>
+        <span class="s1">&#39;</span><span class="se">\n</span><span class="s1">&#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span>
+          <span class="n">link</span><span class="p">(</span><span class="n">from_</span><span class="p">,</span> <span class="n">to</span><span class="p">,</span> <span class="n">char</span><span class="p">)</span>
+          <span class="k">for</span> <span class="p">(</span><span class="n">from_</span><span class="p">,</span> <span class="n">char</span><span class="p">),</span> <span class="p">(</span><span class="n">to</span><span class="p">)</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">table</span><span class="o">.</span><span class="n">iteritems</span><span class="p">())</span>
+          <span class="p">)</span>
+        <span class="p">)</span>
 </pre></div>
 </div>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>print make_graph(table, accepting)
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span> <span class="n">make_graph</span><span class="p">(</span><span class="n">table</span><span class="p">,</span> <span class="n">accepting</span><span class="p">)</span>
 </pre></div>
 </div>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">digraph</span> <span class="n">finite_state_machine</span> <span class="p">{</span>
@@ -699,14 +699,14 @@ hard-code the information in the table into a little patch of branches.</p>
 <h4>Trampoline Function<a class="headerlink" href="#trampoline-function" title="Permalink to this headline">¶</a></h4>
 <p>Python has no GOTO statement but we can fake it with a “trampoline”
 function.</p>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>def trampoline(input_, jump_from, accepting):
-    I = iter(input_)
-    while True:
-        try:
-            bounce_to = jump_from(I)
-        except StopIteration:
-            return jump_from in accepting
-        jump_from = bounce_to
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">trampoline</span><span class="p">(</span><span class="n">input_</span><span class="p">,</span> <span class="n">jump_from</span><span class="p">,</span> <span class="n">accepting</span><span class="p">):</span>
+    <span class="n">I</span> <span class="o">=</span> <span class="nb">iter</span><span class="p">(</span><span class="n">input_</span><span class="p">)</span>
+    <span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
+        <span class="k">try</span><span class="p">:</span>
+            <span class="n">bounce_to</span> <span class="o">=</span> <span class="n">jump_from</span><span class="p">(</span><span class="n">I</span><span class="p">)</span>
+        <span class="k">except</span> <span class="ne">StopIteration</span><span class="p">:</span>
+            <span class="k">return</span> <span class="n">jump_from</span> <span class="ow">in</span> <span class="n">accepting</span>
+        <span class="n">jump_from</span> <span class="o">=</span> <span class="n">bounce_to</span>
 </pre></div>
 </div>
 </section>
@@ -714,17 +714,17 @@ function.</p>
 <h4>Stream Functions<a class="headerlink" href="#stream-functions" title="Permalink to this headline">¶</a></h4>
 <p>Little helpers to process the iterator of our data (a “stream” of “1”
 and “0” characters, not bits.)</p>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>getch = lambda I: int(next(I))
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">getch</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">I</span><span class="p">:</span> <span class="nb">int</span><span class="p">(</span><span class="nb">next</span><span class="p">(</span><span class="n">I</span><span class="p">))</span>
 
 
-def _1(I):
-    &#39;&#39;&#39;Loop on ones.&#39;&#39;&#39;
-    while getch(I): pass
+<span class="k">def</span> <span class="nf">_1</span><span class="p">(</span><span class="n">I</span><span class="p">):</span>
+    <span class="sd">&#39;&#39;&#39;Loop on ones.&#39;&#39;&#39;</span>
+    <span class="k">while</span> <span class="n">getch</span><span class="p">(</span><span class="n">I</span><span class="p">):</span> <span class="k">pass</span>
 
 
-def _0(I):
-    &#39;&#39;&#39;Loop on zeros.&#39;&#39;&#39;
-    while not getch(I): pass
+<span class="k">def</span> <span class="nf">_0</span><span class="p">(</span><span class="n">I</span><span class="p">):</span>
+    <span class="sd">&#39;&#39;&#39;Loop on zeros.&#39;&#39;&#39;</span>
+    <span class="k">while</span> <span class="ow">not</span> <span class="n">getch</span><span class="p">(</span><span class="n">I</span><span class="p">):</span> <span class="k">pass</span>
 </pre></div>
 </div>
 </section>
@@ -735,28 +735,28 @@ def _0(I):
 code. (You have to imagine that these are GOTO statements in C or
 branches in assembly and that the state names are branch destination
 labels.)</p>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>a = lambda I: c if getch(I) else b
-b = lambda I: _0(I) or d
-c = lambda I: e if getch(I) else b
-d = lambda I: f if getch(I) else b
-e = lambda I: g if getch(I) else b
-f = lambda I: h if getch(I) else b
-g = lambda I: _1(I) or i
-h = lambda I: _1(I) or i
-i = lambda I: _0(I) or j
-j = lambda I: h if getch(I) else i
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">I</span><span class="p">:</span> <span class="n">c</span> <span class="k">if</span> <span class="n">getch</span><span class="p">(</span><span class="n">I</span><span class="p">)</span> <span class="k">else</span> <span class="n">b</span>
+<span class="n">b</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">I</span><span class="p">:</span> <span class="n">_0</span><span class="p">(</span><span class="n">I</span><span class="p">)</span> <span class="ow">or</span> <span class="n">d</span>
+<span class="n">c</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">I</span><span class="p">:</span> <span class="n">e</span> <span class="k">if</span> <span class="n">getch</span><span class="p">(</span><span class="n">I</span><span class="p">)</span> <span class="k">else</span> <span class="n">b</span>
+<span class="n">d</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">I</span><span class="p">:</span> <span class="n">f</span> <span class="k">if</span> <span class="n">getch</span><span class="p">(</span><span class="n">I</span><span class="p">)</span> <span class="k">else</span> <span class="n">b</span>
+<span class="n">e</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">I</span><span class="p">:</span> <span class="n">g</span> <span class="k">if</span> <span class="n">getch</span><span class="p">(</span><span class="n">I</span><span class="p">)</span> <span class="k">else</span> <span class="n">b</span>
+<span class="n">f</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">I</span><span class="p">:</span> <span class="n">h</span> <span class="k">if</span> <span class="n">getch</span><span class="p">(</span><span class="n">I</span><span class="p">)</span> <span class="k">else</span> <span class="n">b</span>
+<span class="n">g</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">I</span><span class="p">:</span> <span class="n">_1</span><span class="p">(</span><span class="n">I</span><span class="p">)</span> <span class="ow">or</span> <span class="n">i</span>
+<span class="n">h</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">I</span><span class="p">:</span> <span class="n">_1</span><span class="p">(</span><span class="n">I</span><span class="p">)</span> <span class="ow">or</span> <span class="n">i</span>
+<span class="n">i</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">I</span><span class="p">:</span> <span class="n">_0</span><span class="p">(</span><span class="n">I</span><span class="p">)</span> <span class="ow">or</span> <span class="n">j</span>
+<span class="n">j</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">I</span><span class="p">:</span> <span class="n">h</span> <span class="k">if</span> <span class="n">getch</span><span class="p">(</span><span class="n">I</span><span class="p">)</span> <span class="k">else</span> <span class="n">i</span>
 </pre></div>
 </div>
 <p>Note that the implementations of <code class="docutils literal notranslate"><span class="pre">h</span></code> and <code class="docutils literal notranslate"><span class="pre">g</span></code> are identical ergo
 <code class="docutils literal notranslate"><span class="pre">h</span> <span class="pre">=</span> <span class="pre">g</span></code> and we could eliminate one in the code but <code class="docutils literal notranslate"><span class="pre">h</span></code> is an
 accepting state and <code class="docutils literal notranslate"><span class="pre">g</span></code> isn’t.</p>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>def acceptable(input_):
-    return trampoline(input_, a, {h, i})
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">acceptable</span><span class="p">(</span><span class="n">input_</span><span class="p">):</span>
+    <span class="k">return</span> <span class="n">trampoline</span><span class="p">(</span><span class="n">input_</span><span class="p">,</span> <span class="n">a</span><span class="p">,</span> <span class="p">{</span><span class="n">h</span><span class="p">,</span> <span class="n">i</span><span class="p">})</span>
 </pre></div>
 </div>
-<div class="highlight-ipython2 notranslate"><div class="highlight"><pre><span></span>for n in range(2**5):
-    s = bin(n)[2:]
-    print &#39;%05s&#39; % s, acceptable(s)
+<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">2</span><span class="o">**</span><span class="mi">5</span><span class="p">):</span>
+    <span class="n">s</span> <span class="o">=</span> <span class="nb">bin</span><span class="p">(</span><span class="n">n</span><span class="p">)[</span><span class="mi">2</span><span class="p">:]</span>
+    <span class="nb">print</span> <span class="s1">&#39;</span><span class="si">%05s</span><span class="s1">&#39;</span> <span class="o">%</span> <span class="n">s</span><span class="p">,</span> <span class="n">acceptable</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
 </pre></div>
 </div>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span>    <span class="mi">0</span> <span class="kc">False</span>