<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE article PUBLIC "-//NLM//DTD Journal Publishing DTD v3.0 20080202//EN" "http://dtd.nlm.nih.gov/publishing/3.0/journalpublishing3.dtd">
<article xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink" dtd-version="3.0" xml:lang="en" article-type="research article">
 <front>
  <journal-meta>
   <journal-id journal-id-type="publisher-id">
    jamp
   </journal-id>
   <journal-title-group>
    <journal-title>
     Journal of Applied Mathematics and Physics
    </journal-title>
   </journal-title-group>
   <issn pub-type="epub">
    2327-4352
   </issn>
   <issn publication-format="print">
    2327-4379
   </issn>
   <publisher>
    <publisher-name>
     Scientific Research Publishing
    </publisher-name>
   </publisher>
  </journal-meta>
  <article-meta>
   <article-id pub-id-type="doi">
    10.4236/jamp.2024.126129
   </article-id>
   <article-id pub-id-type="publisher-id">
    jamp-133950
   </article-id>
   <article-categories>
    <subj-group subj-group-type="heading">
     <subject>
      Articles
     </subject>
    </subj-group>
    <subj-group subj-group-type="Discipline-v2">
     <subject>
      Physics 
     </subject>
     <subject>
       Mathematics
     </subject>
    </subj-group>
   </article-categories>
   <title-group>
    Non-Recursive Base Conversion Using a Deterministic Markov Process
   </title-group>
   <contrib-group>
    <contrib contrib-type="author" xlink:type="simple">
     <name name-style="western">
      <surname>
       Louis M.
      </surname>
      <given-names>
       Houston
      </given-names>
     </name>
    </contrib>
   </contrib-group> 
   <aff id="affnull">
    <addr-line>
     aDepartment of Innovation and Research, The University of Louisiana at Lafayette, Lafayette, LA, USA
    </addr-line> 
   </aff> 
   <pub-date pub-type="epub">
    <day>
     07
    </day> 
    <month>
     06
    </month>
    <year>
     2024
    </year>
   </pub-date> 
   <volume>
    12
   </volume> 
   <issue>
    06
   </issue>
   <fpage>
    2112
   </fpage>
   <lpage>
    2118
   </lpage>
   <history>
    <date date-type="received">
     <day>
      27,
     </day>
     <month>
      February
     </month>
     <year>
      2024
     </year>
    </date>
    <date date-type="published">
     <day>
      18,
     </day>
     <month>
      February
     </month>
     <year>
      2024
     </year> 
    </date> 
    <date date-type="accepted">
     <day>
      18,
     </day>
     <month>
      June
     </month>
     <year>
      2024
     </year> 
    </date>
   </history>
   <permissions>
    <copyright-statement>
     © Copyright 2014 by authors and Scientific Research Publishing Inc. 
    </copyright-statement>
    <copyright-year>
     2014
    </copyright-year>
    <license>
     <license-p>
      This work is licensed under the Creative Commons Attribution International License (CC BY). http://creativecommons.org/licenses/by/4.0/
     </license-p>
    </license>
   </permissions>
   <abstract>
    We prove that non-recursive base conversion can always be implemented by using a deterministic Markov process. Our paper discusses the pros and cons of recursive and non-recursive methods, in general. And we include a comparison between non-recursion and a deterministic Markov process, proving that the Markov process is twice as efficient.
   </abstract>
   <kwd-group> 
    <kwd>
     Base Conversion
    </kwd> 
    <kwd>
      Recursion
    </kwd> 
    <kwd>
      Euclidean Division
    </kwd> 
    <kwd>
      Geometric Series
    </kwd> 
    <kwd>
      Markov Process
    </kwd>
   </kwd-group>
  </article-meta>
 </front>
 <body>
  <sec id="s1">
   <title>1. Introduction</title>
   <p>Mathematically, the base or radix, b is the building block of a number. A digit of a number is maximally b − 1. For example, the largest digit in base ten is nine. The subject matter of this paper is about converting a number from one base system to another base system and revealing the coupling between base conversion and a Markov process.</p>
   <p>To discuss the conditions that couple non-recursive base conversion to a deterministic Markov process, we need to break down the concepts involved:</p>
   <p>The theorem presented in this paper is not to be confused with the Base Conversion Theorem by Matula <xref ref-type="bibr" rid="scirp.133950-1">
     [1]
    </xref>. The Base Conversion Theorem stipulates the conditions under which base conversions are one-to-one and/or onto. The theorem presented in this paper provides a specific method to produce non-recursive base conversion for positive integers and decimal numbers that are consistent with deterministic Markov processes.</p>
   <sec id="s1_1">
    <title>1.1. The Markov Base Conversion Theorem</title>
    <p>The base conversion of a number has historically been a recursive process that depends on the dividends and remainders from Euclidean division or the multiplication of real numbers <xref ref-type="bibr" rid="scirp.133950-2">
      [2]
     </xref> <xref ref-type="bibr" rid="scirp.133950-3">
      [3]
     </xref> <xref ref-type="bibr" rid="scirp.133950-4">
      [4]
     </xref>. We derive a process that easily converts a number from base ten to another base without recursion. The theorem is fundamentally based on the intuitive process of isolating digits in a base ten or decimal number that are separated by powers of ten and therefore are distinctly represented in the number. The process that separates the base ten elements from the number simply isolates the digits of the decimal number. The derived process does not depend on the remainders from division. By generating the process to convert between decimal and an arbitrary base, we derive the theorem of deterministic Markov base conversion. The theorem specifies base conversion between an N-digit positive decimal number less than one and any other base. While base conversion readily extends to negative and floating-point numbers <xref ref-type="bibr" rid="scirp.133950-5">
      [5]
     </xref> <xref ref-type="bibr" rid="scirp.133950-6">
      [6]
     </xref> <xref ref-type="bibr" rid="scirp.133950-7">
      [7]
     </xref> <xref ref-type="bibr" rid="scirp.133950-8">
      [8]
     </xref>, we will not discuss that extension in this paper. An essential component of the theorem is the use of the floor function and the geometric series <xref ref-type="bibr" rid="scirp.133950-9">
      [9]
     </xref> <xref ref-type="bibr" rid="scirp.133950-10">
      [10]
     </xref>. We also show that a deterministic Markov base conversion is twice as efficient, mathematically, as typical base conversion methods, such as iterative or non-recursive methods.</p>
   </sec>
   <sec id="s1_2">
    <title>1.2. A Markov Chain or Markov Process</title>
    <p>A Markov chain or Markov process is a stochastic model describing a sequence of possible events in which the probability of each event depends only on the state attained in the previous event. Informally, this may be thought of as, “What happens next depends only on the state of affairs now.”</p>
    <p>A deterministic Markov process is generally non-recursive as it typically involves state transitions governed by deterministic rules or functions, which can be implemented iteratively without the need for recursive calls.</p>
    <p>Recursive base conversion is a clear and concise method for converting numbers between bases, though it may not always be the most efficient. For small to moderately sized numbers, it provides a readable and maintainable solution. For larger numbers, an iterative approach might be more suitable to avoid potential performance and memory issues.</p>
    <p>Coupling non-recursive base conversion to a deterministic Markov process involves defining states that represent each stage of the conversion, establishing deterministic transition rules that depend solely on the current state, and ensuring the process terminates in a final state representing the converted number. This approach leverages the deterministic nature of both the base conversion algorithm and the Markov process framework to achieve the desired coupling.</p>
    <sec id="s1">
     <title>2. Recursive Base Conversion</title>
     <p>We want to consider two cases: 1) base conversion for a positive integer and 2) base conversion for a positive number less than one. In case one, we want to show that a recursive process that retains the remainders from Euclidean division achieves a conversion between base ten and any other base.</p>
     <p>Consider a positive N-digit base-ten integer x. We can write it as</p>
     <p>
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <mi>
          x 
        </mi> 
        <mo>
          = 
        </mo> 
        <mstyle displaystyle="true"> 
         <msubsup> 
          <mo>
            ∑ 
          </mo> 
          <mrow> 
           <mi>
             i 
           </mi> 
           <mo>
             = 
           </mo> 
           <mn>
             1 
           </mn> 
          </mrow> 
          <mi>
            N 
          </mi> 
         </msubsup> 
         <mrow> 
          <msub> 
           <mi>
             a 
           </mi> 
           <mi>
             i 
           </mi> 
          </msub> 
          <msup> 
           <mi>
             b 
           </mi> 
           <mrow> 
            <mi>
              i 
            </mi> 
            <mo>
              − 
            </mo> 
            <mn>
              1 
            </mn> 
           </mrow> 
          </msup> 
         </mrow> 
        </mstyle> 
       </mrow> 
      </math>,(1)</p>
     <p>where 
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <mrow> 
         <mo>
           { 
         </mo> 
         <mrow> 
          <msub> 
           <mi>
             a 
           </mi> 
           <mi>
             i 
           </mi> 
          </msub> 
         </mrow> 
         <mo>
           } 
         </mo> 
        </mrow> 
       </mrow> 
      </math> are the digits of x in the base b &gt; 1. Observe that if you divide 
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <mi>
          x 
        </mi> 
        <mo>
          = 
        </mo> 
        <msup> 
         <mi>
           x 
         </mi> 
         <mrow> 
          <mrow> 
           <mo>
             ( 
           </mo> 
           <mn>
             1 
           </mn> 
           <mo>
             ) 
           </mo> 
          </mrow> 
         </mrow> 
        </msup> 
       </mrow> 
      </math> by b, by Euclidean division you get</p>
     <p>
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <msup> 
         <mi>
           x 
         </mi> 
         <mrow> 
          <mrow> 
           <mo>
             ( 
           </mo> 
           <mn>
             1 
           </mn> 
           <mo>
             ) 
           </mo> 
          </mrow> 
         </mrow> 
        </msup> 
        <mo>
          = 
        </mo> 
        <msub> 
         <mi>
           r 
         </mi> 
         <mn>
           1 
         </mn> 
        </msub> 
        <mo>
          + 
        </mo> 
        <mi>
          b 
        </mi> 
        <msup> 
         <mi>
           x 
         </mi> 
         <mrow> 
          <mrow> 
           <mo>
             ( 
           </mo> 
           <mn>
             2 
           </mn> 
           <mo>
             ) 
           </mo> 
          </mrow> 
         </mrow> 
        </msup> 
       </mrow> 
      </math>(2)</p>
     <p>For some positive integers 
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <msup> 
         <mi>
           x 
         </mi> 
         <mrow> 
          <mrow> 
           <mo>
             ( 
           </mo> 
           <mn>
             2 
           </mn> 
           <mo>
             ) 
           </mo> 
          </mrow> 
         </mrow> 
        </msup> 
        <mo>
          &lt; 
        </mo> 
        <msup> 
         <mi>
           x 
         </mi> 
         <mrow> 
          <mrow> 
           <mo>
             ( 
           </mo> 
           <mn>
             1 
           </mn> 
           <mo>
             ) 
           </mo> 
          </mrow> 
         </mrow> 
        </msup> 
       </mrow> 
      </math> and 
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <msub> 
         <mi>
           r 
         </mi> 
         <mn>
           1 
         </mn> 
        </msub> 
        <mo>
          &lt; 
        </mo> 
        <mi>
          b 
        </mi> 
       </mrow> 
      </math>. You can then recursively divide 
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <msup> 
         <mi>
           x 
         </mi> 
         <mrow> 
          <mrow> 
           <mo>
             ( 
           </mo> 
           <mn>
             2 
           </mn> 
           <mo>
             ) 
           </mo> 
          </mrow> 
         </mrow> 
        </msup> 
       </mrow> 
      </math> by b (note that this will require only a finite number of steps), obtaining</p>
     <p>
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <mi>
          x 
        </mi> 
        <mo>
          = 
        </mo> 
        <msub> 
         <mi>
           r 
         </mi> 
         <mn>
           1 
         </mn> 
        </msub> 
        <mo>
          + 
        </mo> 
        <mi>
          b 
        </mi> 
        <mrow> 
         <mo>
           ( 
         </mo> 
         <mrow> 
          <msub> 
           <mi>
             r 
           </mi> 
           <mn>
             2 
           </mn> 
          </msub> 
          <mo>
            + 
          </mo> 
          <mi>
            b 
          </mi> 
          <mrow> 
           <mo>
             ( 
           </mo> 
           <mrow> 
            <mo>
              ⋯ 
            </mo> 
            <mo>
              + 
            </mo> 
            <mi>
              b 
            </mi> 
            <mrow> 
             <mo>
               ( 
             </mo> 
             <mrow> 
              <msub> 
               <mi>
                 r 
               </mi> 
               <mi>
                 N 
               </mi> 
              </msub> 
             </mrow> 
             <mo>
               ) 
             </mo> 
            </mrow> 
           </mrow> 
           <mo>
             ) 
           </mo> 
          </mrow> 
         </mrow> 
         <mo>
           ) 
         </mo> 
        </mrow> 
       </mrow> 
      </math>(3)</p>
     <p>with 
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <mn>
          0 
        </mn> 
        <mo>
          ≤ 
        </mo> 
        <msub> 
         <mi>
           r 
         </mi> 
         <mn>
           1 
         </mn> 
        </msub> 
        <mo>
          &lt; 
        </mo> 
        <mi>
          b 
        </mi> 
       </mrow> 
      </math>. Therefore, 
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <msub> 
         <mi>
           a 
         </mi> 
         <mi>
           i 
         </mi> 
        </msub> 
        <mo>
          = 
        </mo> 
        <msub> 
         <mi>
           r 
         </mi> 
         <mi>
           i 
         </mi> 
        </msub> 
       </mrow> 
      </math> as required.</p>
     <p>Now let us examine case two. Consider a positive N-digit decimal number less than one. We can write it as</p>
     <p>
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <mi>
          x 
        </mi> 
        <mo>
          = 
        </mo> 
        <mstyle displaystyle="true"> 
         <msubsup> 
          <mo>
            ∑ 
          </mo> 
          <mrow> 
           <mi>
             i 
           </mi> 
           <mo>
             = 
           </mo> 
           <mn>
             1 
           </mn> 
          </mrow> 
          <mi>
            N 
          </mi> 
         </msubsup> 
         <mrow> 
          <msub> 
           <mi>
             a 
           </mi> 
           <mi>
             i 
           </mi> 
          </msub> 
          <msup> 
           <mi>
             b 
           </mi> 
           <mrow> 
            <mi>
              i 
            </mi> 
            <mo>
              − 
            </mo> 
            <mn>
              1 
            </mn> 
            <mo>
              − 
            </mo> 
            <mi>
              N 
            </mi> 
           </mrow> 
          </msup> 
         </mrow> 
        </mstyle> 
       </mrow> 
      </math>.(4)</p>
     <p>where 
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <mrow> 
         <mo>
           { 
         </mo> 
         <mrow> 
          <msub> 
           <mi>
             a 
           </mi> 
           <mi>
             i 
           </mi> 
          </msub> 
         </mrow> 
         <mo>
           } 
         </mo> 
        </mrow> 
       </mrow> 
      </math> are the digits of x in the base b &gt; 1. Observe that if you multiply 
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <mi>
          x 
        </mi> 
        <mo>
          = 
        </mo> 
        <msup> 
         <mi>
           x 
         </mi> 
         <mrow> 
          <mrow> 
           <mo>
             ( 
           </mo> 
           <mn>
             1 
           </mn> 
           <mo>
             ) 
           </mo> 
          </mrow> 
         </mrow> 
        </msup> 
       </mrow> 
      </math> by b, you get</p>
     <p>
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <mi>
          b 
        </mi> 
        <msup> 
         <mi>
           x 
         </mi> 
         <mrow> 
          <mrow> 
           <mo>
             ( 
           </mo> 
           <mn>
             1 
           </mn> 
           <mo>
             ) 
           </mo> 
          </mrow> 
         </mrow> 
        </msup> 
        <mo>
          = 
        </mo> 
        <msup> 
         <mi>
           x 
         </mi> 
         <mrow> 
          <mrow> 
           <mo>
             ( 
           </mo> 
           <mn>
             2 
           </mn> 
           <mo>
             ) 
           </mo> 
          </mrow> 
         </mrow> 
        </msup> 
        <mo>
          + 
        </mo> 
        <msub> 
         <mi>
           q 
         </mi> 
         <mi>
           N 
         </mi> 
        </msub> 
       </mrow> 
      </math>.(5)</p>
     <p>and if you multiply 
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <mi>
          x 
        </mi> 
        <mo>
          = 
        </mo> 
        <msup> 
         <mi>
           x 
         </mi> 
         <mrow> 
          <mrow> 
           <mo>
             ( 
           </mo> 
           <mn>
             2 
           </mn> 
           <mo>
             ) 
           </mo> 
          </mrow> 
         </mrow> 
        </msup> 
       </mrow> 
      </math> by b you get</p>
     <p>
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <mi>
          b 
        </mi> 
        <msup> 
         <mi>
           x 
         </mi> 
         <mrow> 
          <mrow> 
           <mo>
             ( 
           </mo> 
           <mn>
             2 
           </mn> 
           <mo>
             ) 
           </mo> 
          </mrow> 
         </mrow> 
        </msup> 
        <mo>
          = 
        </mo> 
        <msup> 
         <mi>
           x 
         </mi> 
         <mrow> 
          <mrow> 
           <mo>
             ( 
           </mo> 
           <mn>
             3 
           </mn> 
           <mo>
             ) 
           </mo> 
          </mrow> 
         </mrow> 
        </msup> 
        <mo>
          + 
        </mo> 
        <msub> 
         <mi>
           q 
         </mi> 
         <mrow> 
          <mi>
            N 
          </mi> 
          <mo>
            − 
          </mo> 
          <mn>
            1 
          </mn> 
         </mrow> 
        </msub> 
       </mrow> 
      </math>,(6)</p>
     <p>where 
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <msub> 
         <mi>
           q 
         </mi> 
         <mi>
           N 
         </mi> 
        </msub> 
       </mrow> 
      </math> and 
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <msub> 
         <mi>
           q 
         </mi> 
         <mrow> 
          <mi>
            N 
          </mi> 
          <mo>
            − 
          </mo> 
          <mn>
            1 
          </mn> 
         </mrow> 
        </msub> 
       </mrow> 
      </math> are positive integers. If we multiply by 
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <msup> 
         <mi>
           b 
         </mi> 
         <mrow> 
          <mo>
            − 
          </mo> 
          <mn>
            1 
          </mn> 
         </mrow> 
        </msup> 
       </mrow> 
      </math>, we get</p>
     <p>
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <msup> 
         <mi>
           x 
         </mi> 
         <mrow> 
          <mrow> 
           <mo>
             ( 
           </mo> 
           <mn>
             1 
           </mn> 
           <mo>
             ) 
           </mo> 
          </mrow> 
         </mrow> 
        </msup> 
        <mo>
          = 
        </mo> 
        <msup> 
         <mi>
           b 
         </mi> 
         <mrow> 
          <mo>
            − 
          </mo> 
          <mn>
            1 
          </mn> 
         </mrow> 
        </msup> 
        <msup> 
         <mi>
           x 
         </mi> 
         <mrow> 
          <mrow> 
           <mo>
             ( 
           </mo> 
           <mn>
             2 
           </mn> 
           <mo>
             ) 
           </mo> 
          </mrow> 
         </mrow> 
        </msup> 
        <mo>
          + 
        </mo> 
        <msup> 
         <mi>
           b 
         </mi> 
         <mrow> 
          <mo>
            − 
          </mo> 
          <mn>
            1 
          </mn> 
         </mrow> 
        </msup> 
        <msub> 
         <mi>
           q 
         </mi> 
         <mi>
           N 
         </mi> 
        </msub> 
       </mrow> 
      </math>(7)</p>
     <p>We can then recursively multiply by 
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <msup> 
         <mi>
           b 
         </mi> 
         <mrow> 
          <mo>
            − 
          </mo> 
          <mn>
            1 
          </mn> 
         </mrow> 
        </msup> 
       </mrow> 
      </math></p>
     <p>
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <msup> 
         <mi>
           x 
         </mi> 
         <mrow> 
          <mrow> 
           <mo>
             ( 
           </mo> 
           <mn>
             1 
           </mn> 
           <mo>
             ) 
           </mo> 
          </mrow> 
         </mrow> 
        </msup> 
        <mo>
          = 
        </mo> 
        <msup> 
         <mi>
           b 
         </mi> 
         <mrow> 
          <mo>
            − 
          </mo> 
          <mn>
            1 
          </mn> 
         </mrow> 
        </msup> 
        <mrow> 
         <mo>
           ( 
         </mo> 
         <mrow> 
          <msup> 
           <mi>
             b 
           </mi> 
           <mrow> 
            <mo>
              − 
            </mo> 
            <mn>
              1 
            </mn> 
           </mrow> 
          </msup> 
          <msup> 
           <mi>
             x 
           </mi> 
           <mrow> 
            <mrow> 
             <mo>
               ( 
             </mo> 
             <mn>
               3 
             </mn> 
             <mo>
               ) 
             </mo> 
            </mrow> 
           </mrow> 
          </msup> 
          <mo>
            + 
          </mo> 
          <mo>
            ⋯ 
          </mo> 
          <mo>
            + 
          </mo> 
          <msup> 
           <mi>
             b 
           </mi> 
           <mrow> 
            <mo>
              − 
            </mo> 
            <mn>
              1 
            </mn> 
           </mrow> 
          </msup> 
          <msub> 
           <mi>
             q 
           </mi> 
           <mrow> 
            <mi>
              N 
            </mi> 
            <mo>
              − 
            </mo> 
            <mn>
              1 
            </mn> 
           </mrow> 
          </msub> 
         </mrow> 
         <mo>
           ) 
         </mo> 
        </mrow> 
        <mo>
          + 
        </mo> 
        <msup> 
         <mi>
           b 
         </mi> 
         <mrow> 
          <mo>
            − 
          </mo> 
          <mn>
            1 
          </mn> 
         </mrow> 
        </msup> 
        <msub> 
         <mi>
           q 
         </mi> 
         <mi>
           N 
         </mi> 
        </msub> 
       </mrow> 
      </math></p>
     <p>
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <msup> 
         <mi>
           x 
         </mi> 
         <mrow> 
          <mrow> 
           <mo>
             ( 
           </mo> 
           <mn>
             1 
           </mn> 
           <mo>
             ) 
           </mo> 
          </mrow> 
         </mrow> 
        </msup> 
        <mo>
          = 
        </mo> 
        <msup> 
         <mi>
           b 
         </mi> 
         <mrow> 
          <mo>
            − 
          </mo> 
          <mn>
            1 
          </mn> 
         </mrow> 
        </msup> 
        <mrow> 
         <mo>
           ( 
         </mo> 
         <mrow> 
          <msup> 
           <mi>
             b 
           </mi> 
           <mrow> 
            <mo>
              − 
            </mo> 
            <mn>
              1 
            </mn> 
           </mrow> 
          </msup> 
          <mrow> 
           <mo>
             ( 
           </mo> 
           <mrow> 
            <msup> 
             <mi>
               b 
             </mi> 
             <mrow> 
              <mo>
                − 
              </mo> 
              <mn>
                1 
              </mn> 
             </mrow> 
            </msup> 
            <msup> 
             <mi>
               x 
             </mi> 
             <mrow> 
              <mrow> 
               <mo>
                 ( 
               </mo> 
               <mn>
                 4 
               </mn> 
               <mo>
                 ) 
               </mo> 
              </mrow> 
             </mrow> 
            </msup> 
            <mo>
              + 
            </mo> 
            <msup> 
             <mi>
               b 
             </mi> 
             <mrow> 
              <mo>
                − 
              </mo> 
              <mn>
                1 
              </mn> 
             </mrow> 
            </msup> 
            <msub> 
             <mi>
               q 
             </mi> 
             <mrow> 
              <mi>
                N 
              </mi> 
              <mo>
                − 
              </mo> 
              <mn>
                2 
              </mn> 
             </mrow> 
            </msub> 
           </mrow> 
           <mo>
             ) 
           </mo> 
          </mrow> 
          <mo>
            + 
          </mo> 
          <msup> 
           <mi>
             b 
           </mi> 
           <mrow> 
            <mo>
              − 
            </mo> 
            <mn>
              1 
            </mn> 
           </mrow> 
          </msup> 
          <msub> 
           <mi>
             q 
           </mi> 
           <mrow> 
            <mi>
              N 
            </mi> 
            <mo>
              − 
            </mo> 
            <mn>
              1 
            </mn> 
           </mrow> 
          </msub> 
         </mrow> 
         <mo>
           ) 
         </mo> 
        </mrow> 
        <mo>
          + 
        </mo> 
        <msup> 
         <mi>
           b 
         </mi> 
         <mrow> 
          <mo>
            − 
          </mo> 
          <mn>
            1 
          </mn> 
         </mrow> 
        </msup> 
        <msub> 
         <mi>
           q 
         </mi> 
         <mi>
           N 
         </mi> 
        </msub> 
       </mrow> 
      </math> {N operations}</p>
     <p>When the highest version of x is zero, we have 
      <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
        <msub> 
         <mi>
           a 
         </mi> 
         <mi>
           i 
         </mi> 
        </msub> 
        <mo>
          = 
        </mo> 
        <msub> 
         <mi>
           q 
         </mi> 
         <mi>
           i 
         </mi> 
        </msub> 
       </mrow> 
      </math> as required.</p>
    </sec>
   </sec>
   <sec id="s3">
    <title>3. Non-Recursive Base Conversion</title>
    <p>We now present a theorem that derives non-recursive base conversion for a positive integer and a positive number less than one, respectively, with the result equivalent to a deterministic Markov process. The theorem proves that the Markov process is twice as efficient as standard base conversion.</p>
    <p>Theorem I.</p>
    <p>If 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         x 
       </mi> 
       <mo>
         = 
       </mo> 
       <mstyle displaystyle="true"> 
        <msub> 
         <mo>
           ∑ 
         </mo> 
         <mrow> 
          <mi>
            k 
          </mi> 
          <mo>
            = 
          </mo> 
          <mn>
            1 
          </mn> 
         </mrow> 
        </msub> 
        <mrow> 
         <msup> 
          <mi>
            b 
          </mi> 
          <mrow> 
           <mi>
             k 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
          </mrow> 
         </msup> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
        </mrow> 
       </mstyle> 
      </mrow> 
     </math>, for 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mn>
         0 
       </mn> 
       <mo>
         ≤ 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mi>
          k 
        </mi> 
       </msub> 
       <mo>
         ≤ 
       </mo> 
       <mi>
         b 
       </mi> 
       <mo>
         − 
       </mo> 
       <mn>
         1 
       </mn> 
      </mrow> 
     </math>, 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mi>
          k 
        </mi> 
       </msub> 
       <mo>
         ∈ 
       </mo> 
       <mrow> 
        <mo>
          { 
        </mo> 
        <mn>
          0 
        </mn> 
        <mo>
          } 
        </mo> 
       </mrow> 
       <mo>
         ∪ 
       </mo> 
       <msup> 
        <mi>
          ℤ 
        </mi> 
        <mo>
          + 
        </mo> 
       </msup> 
      </mrow> 
     </math> and 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         b 
       </mi> 
       <mo>
         ∈ 
       </mo> 
       <msup> 
        <mi>
          ℤ 
        </mi> 
        <mo>
          + 
        </mo> 
       </msup> 
      </mrow> 
     </math>, then</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mi>
          j 
        </mi> 
       </msub> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mi>
            x 
          </mi> 
          <mrow> 
           <msup> 
            <mi>
              b 
            </mi> 
            <mrow> 
             <mi>
               j 
             </mi> 
             <mo>
               − 
             </mo> 
             <mn>
               1 
             </mn> 
            </mrow> 
           </msup> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         − 
       </mo> 
       <mi>
         b 
       </mi> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mi>
            x 
          </mi> 
          <mrow> 
           <msup> 
            <mi>
              b 
            </mi> 
            <mi>
              j 
            </mi> 
           </msup> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
      </mrow> 
     </math>,</p>
    <p>where 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mtext>
            
        </mtext> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
      </mrow> 
     </math> ≡ the greatest integer function (i.e. floor function) rand 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         j 
       </mi> 
       <mo>
         , 
       </mo> 
       <mi>
         k 
       </mi> 
       <mo>
         ∈ 
       </mo> 
       <msup> 
        <mi>
          ℤ 
        </mi> 
        <mo>
          + 
        </mo> 
       </msup> 
      </mrow> 
     </math>.</p>
    <p>Proof. First, evaluate 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mfrac> 
        <mi>
          x 
        </mi> 
        <mrow> 
         <msup> 
          <mi>
            b 
          </mi> 
          <mi>
            j 
          </mi> 
         </msup> 
        </mrow> 
       </mfrac> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         x 
       </mi> 
       <mo>
         = 
       </mo> 
       <mstyle displaystyle="true"> 
        <msub> 
         <mo>
           ∑ 
         </mo> 
         <mrow> 
          <mi>
            k 
          </mi> 
          <mo>
            = 
          </mo> 
          <mn>
            1 
          </mn> 
         </mrow> 
        </msub> 
        <mrow> 
         <msup> 
          <mi>
            b 
          </mi> 
          <mrow> 
           <mi>
             k 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
          </mrow> 
         </msup> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
        </mrow> 
       </mstyle> 
       <mtext>
           
       </mtext> 
       <mtext>
           
       </mtext> 
       <mrow> 
        <mo>
          ( 
        </mo> 
        <mrow> 
         <mi>
           N 
         </mi> 
         <mtext>
             
         </mtext> 
         <mtext>
           operations 
         </mtext> 
        </mrow> 
        <mo>
          ) 
        </mo> 
       </mrow> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mfrac> 
        <mi>
          x 
        </mi> 
        <mrow> 
         <msup> 
          <mi>
            b 
          </mi> 
          <mi>
            j 
          </mi> 
         </msup> 
        </mrow> 
       </mfrac> 
       <mo>
         = 
       </mo> 
       <mstyle displaystyle="true"> 
        <munder> 
         <mo>
           ∑ 
         </mo> 
         <mrow> 
          <mi>
            k 
          </mi> 
          <mo>
            ≤ 
          </mo> 
          <mi>
            j 
          </mi> 
         </mrow> 
        </munder> 
        <mrow> 
         <msup> 
          <mi>
            b 
          </mi> 
          <mrow> 
           <mi>
             k 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
           <mo>
             − 
           </mo> 
           <mi>
             j 
           </mi> 
          </mrow> 
         </msup> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
        </mrow> 
       </mstyle> 
       <mo>
         + 
       </mo> 
       <mstyle displaystyle="true"> 
        <munder> 
         <mo>
           ∑ 
         </mo> 
         <mrow> 
          <mi>
            k 
          </mi> 
          <mo>
            &gt; 
          </mo> 
          <mi>
            j 
          </mi> 
         </mrow> 
        </munder> 
        <mrow> 
         <msup> 
          <mi>
            b 
          </mi> 
          <mrow> 
           <mi>
             k 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
           <mo>
             − 
           </mo> 
           <mi>
             j 
           </mi> 
          </mrow> 
         </msup> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
        </mrow> 
       </mstyle> 
      </mrow> 
     </math></p>
    <p>Since the floor function is distributive,</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mi>
            x 
          </mi> 
          <mrow> 
           <msup> 
            <mi>
              b 
            </mi> 
            <mi>
              j 
            </mi> 
           </msup> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mstyle displaystyle="true"> 
          <msub> 
           <mo>
             ∑ 
           </mo> 
           <mrow> 
            <mi>
              k 
            </mi> 
            <mo>
              ≤ 
            </mo> 
            <mi>
              j 
            </mi> 
           </mrow> 
          </msub> 
          <mrow> 
           <msup> 
            <mi>
              b 
            </mi> 
            <mrow> 
             <mi>
               k 
             </mi> 
             <mo>
               − 
             </mo> 
             <mn>
               1 
             </mn> 
             <mo>
               − 
             </mo> 
             <mi>
               j 
             </mi> 
            </mrow> 
           </msup> 
           <msub> 
            <mi>
              a 
            </mi> 
            <mi>
              k 
            </mi> 
           </msub> 
          </mrow> 
         </mstyle> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         + 
       </mo> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mstyle displaystyle="true"> 
          <msub> 
           <mo>
             ∑ 
           </mo> 
           <mrow> 
            <mi>
              k 
            </mi> 
            <mo>
              &gt; 
            </mo> 
            <mi>
              j 
            </mi> 
           </mrow> 
          </msub> 
          <mrow> 
           <msup> 
            <mi>
              b 
            </mi> 
            <mrow> 
             <mi>
               k 
             </mi> 
             <mo>
               − 
             </mo> 
             <mn>
               1 
             </mn> 
             <mo>
               − 
             </mo> 
             <mi>
               j 
             </mi> 
            </mrow> 
           </msup> 
           <msub> 
            <mi>
              a 
            </mi> 
            <mi>
              k 
            </mi> 
           </msub> 
          </mrow> 
         </mstyle> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
      </mrow> 
     </math></p>
    <p>Because of the condition: 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mn>
         0 
       </mn> 
       <mo>
         ≤ 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mi>
          k 
        </mi> 
       </msub> 
       <mo>
         ≤ 
       </mo> 
       <mi>
         b 
       </mi> 
       <mo>
         − 
       </mo> 
       <mn>
         1 
       </mn> 
      </mrow> 
     </math>, only the second term within the first sum survives:</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mi>
            x 
          </mi> 
          <mrow> 
           <msup> 
            <mi>
              b 
            </mi> 
            <mi>
              j 
            </mi> 
           </msup> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mstyle displaystyle="true"> 
        <munder> 
         <mo>
           ∑ 
         </mo> 
         <mrow> 
          <mi>
            k 
          </mi> 
          <mo>
            &gt; 
          </mo> 
          <mi>
            j 
          </mi> 
         </mrow> 
        </munder> 
        <mrow> 
         <msup> 
          <mi>
            b 
          </mi> 
          <mrow> 
           <mi>
             k 
           </mi> 
           <mo>
             − 
           </mo> 
           <mn>
             1 
           </mn> 
           <mo>
             − 
           </mo> 
           <mi>
             j 
           </mi> 
          </mrow> 
         </msup> 
        </mrow> 
       </mstyle> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         b 
       </mi> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mi>
            x 
          </mi> 
          <mrow> 
           <msup> 
            <mi>
              b 
            </mi> 
            <mi>
              j 
            </mi> 
           </msup> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mstyle displaystyle="true"> 
        <munder> 
         <mo>
           ∑ 
         </mo> 
         <mrow> 
          <mi>
            k 
          </mi> 
          <mo>
            &gt; 
          </mo> 
          <mi>
            j 
          </mi> 
         </mrow> 
        </munder> 
        <mrow> 
         <msup> 
          <mi>
            b 
          </mi> 
          <mrow> 
           <mi>
             k 
           </mi> 
           <mo>
             − 
           </mo> 
           <mi>
             j 
           </mi> 
          </mrow> 
         </msup> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
        </mrow> 
       </mstyle> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mi>
            x 
          </mi> 
          <mrow> 
           <msup> 
            <mi>
              b 
            </mi> 
            <mrow> 
             <mi>
               j 
             </mi> 
             <mo>
               − 
             </mo> 
             <mn>
               1 
             </mn> 
            </mrow> 
           </msup> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mstyle displaystyle="true"> 
          <munder> 
           <mo>
             ∑ 
           </mo> 
           <mrow> 
            <mi>
              k 
            </mi> 
            <mo>
              ≤ 
            </mo> 
            <mi>
              j 
            </mi> 
           </mrow> 
          </munder> 
          <mrow> 
           <msup> 
            <mi>
              b 
            </mi> 
            <mrow> 
             <mi>
               k 
             </mi> 
             <mo>
               − 
             </mo> 
             <mi>
               j 
             </mi> 
            </mrow> 
           </msup> 
           <msub> 
            <mi>
              a 
            </mi> 
            <mi>
              k 
            </mi> 
           </msub> 
          </mrow> 
         </mstyle> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         + 
       </mo> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mstyle displaystyle="true"> 
          <munder> 
           <mo>
             ∑ 
           </mo> 
           <mrow> 
            <mi>
              k 
            </mi> 
            <mo>
              &gt; 
            </mo> 
            <mi>
              j 
            </mi> 
           </mrow> 
          </munder> 
          <mrow> 
           <msup> 
            <mi>
              b 
            </mi> 
            <mrow> 
             <mi>
               k 
             </mi> 
             <mo>
               − 
             </mo> 
             <mi>
               j 
             </mi> 
            </mrow> 
           </msup> 
           <msub> 
            <mi>
              a 
            </mi> 
            <mi>
              k 
            </mi> 
           </msub> 
          </mrow> 
         </mstyle> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
      </mrow> 
     </math></p>
    <p>Only the 
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mi>
          j 
        </mi> 
       </msub> 
      </mrow> 
     </math> term in the first sum survives {because of the geometric series} while the complete sum becomes:</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mi>
            x 
          </mi> 
          <mrow> 
           <msup> 
            <mi>
              b 
            </mi> 
            <mrow> 
             <mi>
               j 
             </mi> 
             <mo>
               − 
             </mo> 
             <mn>
               1 
             </mn> 
            </mrow> 
           </msup> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mi>
          j 
        </mi> 
       </msub> 
       <mo>
         + 
       </mo> 
       <mstyle displaystyle="true"> 
        <munder> 
         <mo>
           ∑ 
         </mo> 
         <mrow> 
          <mi>
            k 
          </mi> 
          <mo>
            &gt; 
          </mo> 
          <mi>
            j 
          </mi> 
         </mrow> 
        </munder> 
        <mrow> 
         <msup> 
          <mi>
            b 
          </mi> 
          <mrow> 
           <mi>
             k 
           </mi> 
           <mo>
             − 
           </mo> 
           <mi>
             j 
           </mi> 
          </mrow> 
         </msup> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
        </mrow> 
       </mstyle> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mi>
         b 
       </mi> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mi>
            x 
          </mi> 
          <mrow> 
           <msup> 
            <mi>
              b 
            </mi> 
            <mi>
              j 
            </mi> 
           </msup> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mstyle displaystyle="true"> 
        <munder> 
         <mo>
           ∑ 
         </mo> 
         <mrow> 
          <mi>
            k 
          </mi> 
          <mo>
            &gt; 
          </mo> 
          <mi>
            j 
          </mi> 
         </mrow> 
        </munder> 
        <mrow> 
         <msup> 
          <mi>
            b 
          </mi> 
          <mrow> 
           <mi>
             k 
           </mi> 
           <mo>
             − 
           </mo> 
           <mi>
             j 
           </mi> 
          </mrow> 
         </msup> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
        </mrow> 
       </mstyle> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mi>
            x 
          </mi> 
          <mrow> 
           <msup> 
            <mi>
              b 
            </mi> 
            <mrow> 
             <mi>
               j 
             </mi> 
             <mo>
               − 
             </mo> 
             <mn>
               1 
             </mn> 
            </mrow> 
           </msup> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         − 
       </mo> 
       <mi>
         b 
       </mi> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mi>
            x 
          </mi> 
          <mrow> 
           <msup> 
            <mi>
              b 
            </mi> 
            <mi>
              j 
            </mi> 
           </msup> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mi>
          j 
        </mi> 
       </msub> 
       <mo>
         + 
       </mo> 
       <mstyle displaystyle="true"> 
        <munder> 
         <mo>
           ∑ 
         </mo> 
         <mrow> 
          <mi>
            k 
          </mi> 
          <mo>
            &gt; 
          </mo> 
          <mi>
            j 
          </mi> 
         </mrow> 
        </munder> 
        <mrow> 
         <msup> 
          <mi>
            b 
          </mi> 
          <mrow> 
           <mi>
             k 
           </mi> 
           <mo>
             − 
           </mo> 
           <mi>
             j 
           </mi> 
          </mrow> 
         </msup> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
        </mrow> 
       </mstyle> 
       <mo>
         − 
       </mo> 
       <mstyle displaystyle="true"> 
        <munder> 
         <mo>
           ∑ 
         </mo> 
         <mrow> 
          <mi>
            k 
          </mi> 
          <mo>
            &gt; 
          </mo> 
          <mi>
            j 
          </mi> 
         </mrow> 
        </munder> 
        <mrow> 
         <msup> 
          <mi>
            b 
          </mi> 
          <mrow> 
           <mi>
             k 
           </mi> 
           <mo>
             − 
           </mo> 
           <mi>
             j 
           </mi> 
          </mrow> 
         </msup> 
         <msub> 
          <mi>
            a 
          </mi> 
          <mi>
            k 
          </mi> 
         </msub> 
        </mrow> 
       </mstyle> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mi>
            x 
          </mi> 
          <mrow> 
           <msup> 
            <mi>
              b 
            </mi> 
            <mrow> 
             <mi>
               j 
             </mi> 
             <mo>
               − 
             </mo> 
             <mn>
               1 
             </mn> 
            </mrow> 
           </msup> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         − 
       </mo> 
       <mi>
         b 
       </mi> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mi>
            x 
          </mi> 
          <mrow> 
           <msup> 
            <mi>
              b 
            </mi> 
            <mi>
              j 
            </mi> 
           </msup> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mi>
          j 
        </mi> 
       </msub> 
      </mrow> 
     </math> ⊡</p>
    <p>Corollary:</p>
    <p>Observe that this result is easily invertible:</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mi>
            x 
          </mi> 
          <mrow> 
           <msup> 
            <mi>
              a 
            </mi> 
            <mrow> 
             <mi>
               j 
             </mi> 
             <mo>
               − 
             </mo> 
             <mn>
               1 
             </mn> 
            </mrow> 
           </msup> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         − 
       </mo> 
       <mi>
         a 
       </mi> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mi>
            x 
          </mi> 
          <mrow> 
           <msup> 
            <mi>
              a 
            </mi> 
            <mi>
              j 
            </mi> 
           </msup> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <msub> 
        <mi>
          b 
        </mi> 
        <mi>
          j 
        </mi> 
       </msub> 
      </mrow> 
     </math></p>
    <p>Example (1): First, convert 407 to base 4 using the standard recursion approach:</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mrow> 
         <mn>
           407 
         </mn> 
        </mrow> 
        <mo>
          / 
        </mo> 
        <mn>
          4 
        </mn> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mtext>
         1 
       </mtext> 
       <mn>
         0 
       </mn> 
       <mtext>
         1 
       </mtext> 
       <mo>
         → 
       </mo> 
       <mtext>
         remainder 
       </mtext> 
       <mo>
         = 
       </mo> 
       <mtext>
         3 
       </mtext> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mrow> 
         <mn>
           101 
         </mn> 
        </mrow> 
        <mo>
          / 
        </mo> 
        <mn>
          4 
        </mn> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mtext>
         25 
       </mtext> 
       <mo>
         → 
       </mo> 
       <mtext>
         remainder 
       </mtext> 
       <mo>
         = 
       </mo> 
       <mtext>
         1 
       </mtext> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mrow> 
         <mn>
           25 
         </mn> 
        </mrow> 
        <mo>
          / 
        </mo> 
        <mn>
          4 
        </mn> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mtext>
         6 
       </mtext> 
       <mo>
         → 
       </mo> 
       <mtext>
         remainder 
       </mtext> 
       <mo>
         = 
       </mo> 
       <mtext>
         1 
       </mtext> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mn>
          6 
        </mn> 
        <mo>
          / 
        </mo> 
        <mn>
          4 
        </mn> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mtext>
         1 
       </mtext> 
       <mo>
         → 
       </mo> 
       <mtext>
         remainder 
       </mtext> 
       <mo>
         = 
       </mo> 
       <mtext>
         2 
       </mtext> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mn>
          1 
        </mn> 
        <mo>
          / 
        </mo> 
        <mn>
          4 
        </mn> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mn>
         0 
       </mn> 
       <mo>
         → 
       </mo> 
       <mtext>
         remainder 
       </mtext> 
       <mo>
         = 
       </mo> 
       <mtext>
         1 
       </mtext> 
      </mrow> 
     </math></p>
    <p>Therefore, 407 = 12,113<sub>four</sub> and this conversion required 10 (i.e. N) operations, which includes the remainder operations.</p>
    <p>Now, use the non-recursive Markov approach:</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mn>
           407 
         </mn> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         − 
       </mo> 
       <mn>
         4 
       </mn> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mrow> 
           <mn>
             407 
           </mn> 
          </mrow> 
          <mn>
            4 
          </mn> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mn>
         3 
       </mn> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mrow> 
           <mn>
             407 
           </mn> 
          </mrow> 
          <mn>
            4 
          </mn> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         − 
       </mo> 
       <mn>
         4 
       </mn> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mrow> 
           <mn>
             407 
           </mn> 
          </mrow> 
          <mrow> 
           <mn>
             16 
           </mn> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mn>
         1 
       </mn> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mrow> 
           <mn>
             407 
           </mn> 
          </mrow> 
          <mrow> 
           <mn>
             16 
           </mn> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         − 
       </mo> 
       <mn>
         4 
       </mn> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mrow> 
           <mn>
             407 
           </mn> 
          </mrow> 
          <mrow> 
           <mn>
             64 
           </mn> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mn>
         1 
       </mn> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mrow> 
           <mn>
             407 
           </mn> 
          </mrow> 
          <mrow> 
           <mn>
             64 
           </mn> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         − 
       </mo> 
       <mn>
         4 
       </mn> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mrow> 
           <mn>
             407 
           </mn> 
          </mrow> 
          <mrow> 
           <mn>
             256 
           </mn> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mn>
         2 
       </mn> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mrow> 
           <mn>
             407 
           </mn> 
          </mrow> 
          <mrow> 
           <mn>
             256 
           </mn> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         − 
       </mo> 
       <mn>
         4 
       </mn> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mrow> 
           <mn>
             407 
           </mn> 
          </mrow> 
          <mrow> 
           <mn>
             1024 
           </mn> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mn>
         1 
       </mn> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mrow> 
           <mn>
             407 
           </mn> 
          </mrow> 
          <mrow> 
           <mn>
             1024 
           </mn> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         − 
       </mo> 
       <mn>
         4 
       </mn> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <mfrac> 
          <mrow> 
           <mn>
             407 
           </mn> 
          </mrow> 
          <mrow> 
           <mn>
             2048 
           </mn> 
          </mrow> 
         </mfrac> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mn>
         0 
       </mn> 
      </mrow> 
     </math></p>
    <p>Therefore, 407 = 12,113<sub>four</sub> and this conversion required 6 [i.e. (N/2 + 1) operations.]</p>
    <p>Example (2):</p>
    <p>Convert 0.390625 to base 2 using the standard recursion approach:</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mn>
         0.390625 
       </mn> 
       <mo>
         × 
       </mo> 
       <mn>
         2 
       </mn> 
       <mo>
         = 
       </mo> 
       <mn>
         0.78125 
       </mn> 
       <mo>
         → 
       </mo> 
       <mtext>
         remainder 
       </mtext> 
       <mo>
         → 
       </mo> 
       <mn>
         0 
       </mn> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mn>
         0.78125 
       </mn> 
       <mo>
         × 
       </mo> 
       <mn>
         2 
       </mn> 
       <mo>
         = 
       </mo> 
       <mn>
         1.5625 
       </mn> 
       <mo>
         → 
       </mo> 
       <mtext>
         remainder 
       </mtext> 
       <mo>
         → 
       </mo> 
       <mn>
         1 
       </mn> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mn>
         0.0. 
       </mn> 
       <mtext>
         5625 
       </mtext> 
       <mo>
         × 
       </mo> 
       <mtext>
         2 
       </mtext> 
       <mo>
         = 
       </mo> 
       <mtext>
         1 
       </mtext> 
       <mo>
         . 
       </mo> 
       <mtext>
         125 
       </mtext> 
       <mo>
         → 
       </mo> 
       <mtext>
         remainder 
       </mtext> 
       <mo>
         → 
       </mo> 
       <mn>
         1 
       </mn> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mn>
         0.125 
       </mn> 
       <mo>
         × 
       </mo> 
       <mn>
         2 
       </mn> 
       <mo>
         = 
       </mo> 
       <mn>
         0.25 
       </mn> 
       <mo>
         → 
       </mo> 
       <mtext>
         remainder 
       </mtext> 
       <mo>
         → 
       </mo> 
       <mn>
         0 
       </mn> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mn>
         0.25 
       </mn> 
       <mo>
         × 
       </mo> 
       <mn>
         2 
       </mn> 
       <mo>
         = 
       </mo> 
       <mn>
         0.5 
       </mn> 
       <mo>
         → 
       </mo> 
       <mtext>
         remainder 
       </mtext> 
       <mo>
         → 
       </mo> 
       <mn>
         0 
       </mn> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mn>
         0.5 
       </mn> 
       <mo>
         × 
       </mo> 
       <mn>
         2 
       </mn> 
       <mo>
         = 
       </mo> 
       <mn>
         1 
       </mn> 
       <mo>
         → 
       </mo> 
       <mtext>
         remainder 
       </mtext> 
       <mo>
         → 
       </mo> 
       <mn>
         1 
       </mn> 
      </mrow> 
     </math></p>
    <p>Therefore,</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mn>
         0.390625 
       </mn> 
       <mo>
         = 
       </mo> 
       <msub> 
        <mrow> 
         <mn>
           0.011001 
         </mn> 
        </mrow> 
        <mrow> 
         <mtext>
           two 
         </mtext> 
        </mrow> 
       </msub> 
      </mrow> 
     </math></p>
    <p>Now, use the non-recursive Markov approach, with x = 0.390625, b = 2 and N = 6.</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mn>
          1 
        </mn> 
       </msub> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <msup> 
          <mn>
            2 
          </mn> 
          <mn>
            6 
          </mn> 
         </msup> 
         <mrow> 
          <mo>
            ( 
          </mo> 
          <mrow> 
           <mn>
             0.3900625 
           </mn> 
          </mrow> 
          <mo>
            ) 
          </mo> 
         </mrow> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         − 
       </mo> 
       <mn>
         2 
       </mn> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <msup> 
          <mn>
            2 
          </mn> 
          <mn>
            5 
          </mn> 
         </msup> 
         <mrow> 
          <mo>
            ( 
          </mo> 
          <mrow> 
           <mn>
             0.3900625 
           </mn> 
          </mrow> 
          <mo>
            ) 
          </mo> 
         </mrow> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mn>
         1 
       </mn> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mn>
          2 
        </mn> 
       </msub> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <msup> 
          <mn>
            2 
          </mn> 
          <mn>
            5 
          </mn> 
         </msup> 
         <mrow> 
          <mo>
            ( 
          </mo> 
          <mrow> 
           <mn>
             0.3900625 
           </mn> 
          </mrow> 
          <mo>
            ) 
          </mo> 
         </mrow> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         − 
       </mo> 
       <mn>
         2 
       </mn> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <msup> 
          <mn>
            2 
          </mn> 
          <mn>
            4 
          </mn> 
         </msup> 
         <mrow> 
          <mo>
            ( 
          </mo> 
          <mrow> 
           <mn>
             0.3900625 
           </mn> 
          </mrow> 
          <mo>
            ) 
          </mo> 
         </mrow> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mn>
         0 
       </mn> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mn>
          3 
        </mn> 
       </msub> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <msup> 
          <mn>
            2 
          </mn> 
          <mn>
            4 
          </mn> 
         </msup> 
         <mrow> 
          <mo>
            ( 
          </mo> 
          <mrow> 
           <mn>
             0.3900625 
           </mn> 
          </mrow> 
          <mo>
            ) 
          </mo> 
         </mrow> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         − 
       </mo> 
       <mn>
         2 
       </mn> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <msup> 
          <mn>
            2 
          </mn> 
          <mn>
            3 
          </mn> 
         </msup> 
         <mrow> 
          <mo>
            ( 
          </mo> 
          <mrow> 
           <mn>
             0.3900625 
           </mn> 
          </mrow> 
          <mo>
            ) 
          </mo> 
         </mrow> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mn>
         0 
       </mn> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mn>
          4 
        </mn> 
       </msub> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <msup> 
          <mn>
            2 
          </mn> 
          <mn>
            3 
          </mn> 
         </msup> 
         <mrow> 
          <mo>
            ( 
          </mo> 
          <mrow> 
           <mn>
             0.3900625 
           </mn> 
          </mrow> 
          <mo>
            ) 
          </mo> 
         </mrow> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         − 
       </mo> 
       <mn>
         2 
       </mn> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <msup> 
          <mn>
            2 
          </mn> 
          <mn>
            2 
          </mn> 
         </msup> 
         <mrow> 
          <mo>
            ( 
          </mo> 
          <mrow> 
           <mn>
             0.3900625 
           </mn> 
          </mrow> 
          <mo>
            ) 
          </mo> 
         </mrow> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mn>
         1 
       </mn> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mn>
          5 
        </mn> 
       </msub> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <msup> 
          <mn>
            2 
          </mn> 
          <mn>
            2 
          </mn> 
         </msup> 
         <mrow> 
          <mo>
            ( 
          </mo> 
          <mrow> 
           <mn>
             0.3900625 
           </mn> 
          </mrow> 
          <mo>
            ) 
          </mo> 
         </mrow> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         − 
       </mo> 
       <mn>
         2 
       </mn> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <msup> 
          <mn>
            2 
          </mn> 
          <mn>
            1 
          </mn> 
         </msup> 
         <mrow> 
          <mo>
            ( 
          </mo> 
          <mrow> 
           <mn>
             0.3900625 
           </mn> 
          </mrow> 
          <mo>
            ) 
          </mo> 
         </mrow> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mn>
         1 
       </mn> 
      </mrow> 
     </math></p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <msub> 
        <mi>
          a 
        </mi> 
        <mn>
          6 
        </mn> 
       </msub> 
       <mo>
         = 
       </mo> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <msup> 
          <mn>
            2 
          </mn> 
          <mn>
            1 
          </mn> 
         </msup> 
         <mrow> 
          <mo>
            ( 
          </mo> 
          <mrow> 
           <mn>
             0.3900625 
           </mn> 
          </mrow> 
          <mo>
            ) 
          </mo> 
         </mrow> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         − 
       </mo> 
       <mn>
         2 
       </mn> 
       <mrow> 
        <mo>
          ⌊ 
        </mo> 
        <mrow> 
         <msup> 
          <mn>
            2 
          </mn> 
          <mn>
            0 
          </mn> 
         </msup> 
         <mrow> 
          <mo>
            ( 
          </mo> 
          <mrow> 
           <mn>
             0.3900625 
           </mn> 
          </mrow> 
          <mo>
            ) 
          </mo> 
         </mrow> 
        </mrow> 
        <mo>
          ⌋ 
        </mo> 
       </mrow> 
       <mo>
         = 
       </mo> 
       <mn>
         0 
       </mn> 
      </mrow> 
     </math></p>
    <p>Thus, we get the same result:</p>
    <p>
     <math display="inline" xmlns="http://www.w3.org/1998/Math/MathML"> <mrow> 
       <mn>
         0.390625 
       </mn> 
       <mo>
         = 
       </mo> 
       <msub> 
        <mrow> 
         <mn>
           0.011001 
         </mn> 
        </mrow> 
        <mrow> 
         <mtext>
           two 
         </mtext> 
        </mrow> 
       </msub> 
      </mrow> 
     </math></p>
   </sec>
   <sec id="s4">
    <title>4. Conclusion</title>
    <p>Coupling non-recursive base conversion to a deterministic Markov process involves defining states that represent each stage of the conversion, establishing deterministic transition rules that depend solely on the current state, and ensuring the process terminates in a final state representing the converted number. This approach leverages the deterministic nature of both the base conversion algorithm and the Markov process framework to achieve the desired coupling. With the presentation of Theorem I, in this paper, we prove that any recursive base conversion process can be converted into a Markov process with unit transition probabilities and the Markov process is twice as efficient as the standard recursive approach to base conversion.</p>
   </sec>
  </sec>
 </body><back>
  <ref-list>
   <title>References</title>
   <ref id="scirp.133950-ref1">
    <label>1</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Matula, D.W. (1968) The Base Conversion Theorem. Proceedings of the American Mathematical Society, 19, 716-723.
    </mixed-citation>
   </ref>
   <ref id="scirp.133950-ref2">
    <label>2</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Hardy, G.H. and Wright, E.M. (1954) An Introduction to the Theory of Numbers. 3rd Edition, Clarendon Press, Oxford, England.
    </mixed-citation>
   </ref>
   <ref id="scirp.133950-ref3">
    <label>3</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Robertson, J.E. (1958) A New Class of Digital Division Methods. IRE Transactions on Electronic Computers, EC-7, 218-222. &gt;https://doi.org/10.1109/TEC.1958.5222579 
    </mixed-citation>
   </ref>
   <ref id="scirp.133950-ref4">
    <label>4</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Wilson, J.B. and Ledley, R.S. (1961) An Algorithm for Rapid Binary Division. IRE Transactions on Electronic Computers, 12, 662-670.
    </mixed-citation>
   </ref>
   <ref id="scirp.133950-ref5">
    <label>5</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Matula, D.W. (1967) Base Conversion Mappings. 1967 Spring Joint Computer Conference, AFIPS Proceedings, 30, 311-318. &gt;https://doi.org/10.1145/1465482.1465532 
    </mixed-citation>
   </ref>
   <ref id="scirp.133950-ref6">
    <label>6</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Matula, D.W. (1967) Base Conversion Mappings. American Federation of Information Processing Societies, 30, 311-318.
    </mixed-citation>
   </ref>
   <ref id="scirp.133950-ref7">
    <label>7</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Agrawal, D.P. (1975) Arithmetic Algorithms in a Negative Base. IEEE Transactions on Computers, 10, 998-1000.
    </mixed-citation>
   </ref>
   <ref id="scirp.133950-ref8">
    <label>8</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     DeRegt, M.P. (1967) Negative Radix Arithmetic. Computer Design, 6, 52-63.
    </mixed-citation>
   </ref>
   <ref id="scirp.133950-ref9">
    <label>9</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Abramowitz, M. and Stegun, I.A. (Eds.) (1972) Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables. 9th Printing, Dover, New York, p. 10.
    </mixed-citation>
   </ref>
   <ref id="scirp.133950-ref10">
    <label>10</label>
    <mixed-citation publication-type="other" xlink:type="simple">
     Arfken, G. (1985) Mathematical Methods for Physicists. 3rd Edition, Academic Press, Orlando, FL, 278-279.
    </mixed-citation>
   </ref>
  </ref-list>
 </back>
</article>