Carview!

CARVIEW

MOTORHOMES

Select Language

HTTP/2 200 server: GitHub.com content-type: application/xml last-modified: Tue, 16 Dec 2025 13:49:46 GMT access-control-allow-origin: * etag: W/"6941637a-1fb38" expires: Mon, 29 Dec 2025 08:44:49 GMT cache-control: max-age=600 content-encoding: gzip x-proxy-cache: MISS x-github-request-id: E252:1F53DD:886A77:99429D:69523D28 accept-ranges: bytes age: 0 date: Mon, 29 Dec 2025 08:34:49 GMT via: 1.1 varnish x-served-by: cache-bom-vanm7210081-BOM x-cache: MISS x-cache-hits: 0 x-timer: S1766997289.068209,VS0,VE222 vary: Accept-Encoding x-fastly-request-id: faa5f4f5462305683638cd375e1f56b389e3ce45 content-length: 17959 Leonardo de Moura Leonardo de Moura's blog https://leodemoura.github.io Nightly builds for Z3 <h1 id="nightly-builds-for-z3">Nightly builds for Z3</h1> We are now providing Z3 nightly builds for all major platforms (Windows, OSX, Linux and FreeBSD). <a href="https://research.microsoft.com/en-us/people/cwinter/">Christoph Wintersteiger</a> and I implemented a new infrastructure that automatically builds and tests Z3 every night. If it passes the tests, we upload the compiled binaries to <a href="https://z3.codeplex.com">codeplex</a>. This feature is useful for users that found bugs, and do not want to wait the next official release. So far, these users would have to download the source code from the <a href="https://z3.codeplex.com/SourceControl/list/changesets?branch=unstable">“work-in-progress” branch</a> and build Z3 themselves. Note that these nightly builds are not official releases. They are built using the <a href="https://z3.codeplex.com/SourceControl/list/changesets?branch=unstable">“work-in-progress” branch</a>, but our infrastructure only uploads them if they pass the basic set of regression tests we have. Since they are not official releases, we include the <a href="https://www.git-scm.com/book/en/Git-Basics-Viewing-the-Commit-History">git hash</a> associated with the commit we used to build the binaries. That is why the zip files have funny names such as z3-4.3.2.5e72cf0123f6-x64-osx-10.8.2.zip. The value 5e72cf0123f6 is the first 12 digits of the git hash. The hash is also embedded in the z3 executable. We can retrieve it by executing <code class="language-plaintext highlighter-rouge">z3 -h</code>. Users using nightly builds should include this hash when reporting bugs and/or problems. Given a hash such as 5e72cf0123f6, we can use the command <code class="language-plaintext highlighter-rouge">git checkout 5e72cf0123f6</code> to retrieve the source code. Here are the instructions for downloading a nightly build <ul> <li>Go to the <a href="https://z3.codeplex.com/releases">Z3 Downloads page</a></li> <li>Click the Planned link</li> </ul> <img src="https://leodemoura.github.io/images/z3-planned.png" /> We provide pre-compiled binaries for the following platforms: <ul> <li>Windows 32 and 64 bit (Windows 7 and 8)</li> <li>OSX (version 10.8.2)</li> <li>Linux Ubuntu 32 and 64 bit (version 12.04)</li> <li>Linux Debian 64 bit (version 6.0.6)</li> <li>FreeBSD 64 bit (version 9.0)</li> </ul> Fri, 15 Feb 2013 00:00:00 +0000 https://leodemoura.github.io/blog/2013/02/15/precompiled.html https://leodemoura.github.io/blog/2013/02/15/precompiled.html Computing with field extensions <h1 id="computing-with-field-extensions">Computing with field extensions</h1> After we released the Z3 source code, a friend of mine made the following comment: “you have so many different representations for numbers in Z3”. He is correct, we have Naturals, Integers, Rationals, binary Rationals, multiple precision floating and fixed point, and Algebraic numbers. Binary rationals are just rational numbers of the form \(\frac{a}{2 ^ k}\). The basic operations (addition, multiplication, comparison) with binary Rationals are much more efficient than the respective ones with Rational numbers. Algebraic numbers are Real numbers that are roots of polynomials with integer coefficients. For example, the square root of 2 is an Algebraic number because it is a root of the polynomial \(x ^ 2 - 2\). Some Algebraic numbers cannot be represented using radicals. For example, the single Real root of \(x ^ 5 - x - 1\). Nonetheless, we can compute with and compare them, and they are used in the <a href="https://research.microsoft.com/en-us/um/people/leonardo/files/IJCAR2012.pdf">nonlinear solver nlsat</a> that is available in Z3. In this post, I describe yet another representation that <a href="https://www.cl.cam.ac.uk/~gp351/">Grant Passmore</a> and I developed. It supports infinitesimal, transcendental and algebraic extensions of the Rational numbers. That is, we can perform precise computations using multiple precision Rational numbers and elements such as \( \sqrt{2},\, \pi,\, e,\, \sqrt[5]{3},\, \epsilon,\, \ldots \) The new package subsumes the existing Algebraic number package in Z3, and is orders of magnitude more efficient. It is already available in the Z3 C and Python APIs. We can also <a href="https://rise4fun.com/z3rcf">play with it online at rise4fun</a>. Decision methods for nonlinear real arithmetic are essential to the formal verication of cyber-physical systems and formalized mathematics. Classically, these decision methods operate over the theory of real closed fields (RCF). What is a RCF? Every RCF is a <a href="https://en.wikipedia.org/wiki/Field_%28mathematics%29">field</a>, that is, addition and multiplication are associative and commutative, multiplication distributes over addition, additive and multiplicative inverses for non-zero elements exist, etc. The Real and Rational numbers are fields, but the Integers are not because only 1 and -1 have multiplicative inverses. For example, there is no integer \(a\) s.t. \(3 a = 1\). A RCF is also an ordered field, i.e., it is a field equipped with a total order upon its elements. The Reals and Rational numbers are ordered fields. A RCF also has two additional properties, every positive number is a square <div> \[ \forall x y \ \left(0 \leq x \Rightarrow \exists y (x = y^2)\right)\!, \] </div> and second, all polynomials of odd degree have a root. This latter property is expressed using an axiom scheme, with one axiom for each n. <div> \[ \forall a_0 a_1 \ldots a_{2n} \exists z \left( z^{2n+1} + a_{2n} z^{2n} + \ldots + a_1 z + a_0 = 0 \right)\!. \] </div> So, the Rational numbers are not a RCF, but the Real and Algebraic numbers are. The set of Algebraic numbers is countable with computable operations, and thus provides a logically sufficient computational substructure for making RCF decision procedures. Note that the Algebraic numbers do not contain transcendental elements such as \( \pi \mbox{ and } e \). Indeed, a Real number is transcendental precisely when it is not Algebraic. When implementing an RCF decision procedure, one is free to compute over any RCF while still being sure that the resulting computations are valid over the Reals. This is important from a computational point of view, as Reals are uncountable with uncomputable basic operations. On the one hand, this lack of transcendental elements seems logically inconsequential and even computationally desirable, as transcendentals are undefinable over RCF and almost all of them are uncomputable. However, various new applications have given rise to a need for computing in real closed fields containing transcendentals. This need is especially apparent when one considers cyber-physical systems, or mainstream efforts in formalized mathematics, such as Thomas Hales’s <a href="https://code.google.com/p/flyspeck/">Flyspeck project</a>. <h2 id="infinitesimals">Infinitesimals</h2> In addition to RCFs containing common transcendental constants, there is also a need for computing in RCFs containing infinitesimals. Our package allows users to create an arbitrary number of infinitesimal extensions. Each extension adds a new positive element \(\epsilon\) that is smaller than all existing positive elements in the current ordered field \(\mathbb{K}\). <div> \[ \epsilon > 0 \ \wedge \ \forall k \in \mathbb{K} \ \left(k > 0 \ \Rightarrow \ \epsilon < k\right). \] </div> Note that, \(\frac{1}{\epsilon}\) is an infinite element, that is, it is bigger than any element in \(\mathbb{K}\). Infinitesimals are a very useful abstraction, and simplify the implementation of decision procedures. For example, <a href="https://www.csl.sri.com/users/bruno/">Bruno Dutertre</a> and I used infinitesimals to implement a <a href="https://research.microsoft.com/en-us/um/people/leonardo/files/cav06.pdf">decision procedure for linear real arithmetic</a>. The basic idea was to treat a strict inequality \(p < 0\), where \(p\) is a linear polynomial as a non-strict inequality \(p \leq \epsilon\), where \(\epsilon\) is an infinitesimal. Note that, in this application, infinitesimals could be easily encoded because we considered only the linear fragment. The PSPACE and singly exponential procedures of Canny, Grigor’ev-Vorobjov, and Basu-Pollack-Roy for the existential fragment of nonlinear real arithmetic also rely on infinitesimal elements. Most of these procedures were never fully implemented. The lack of a viable library for computing with real closed fields containing infinitesimals has been an impediment to this line of research Grant and I are also using infinitesimals to implement a new procedure for nonlinear programming (aka optimization). Suppose we are trying to minimize a nonlinear polynomial \(p\) subject to a set of nonlinear polynomial constraints. We say \(p\) is an objective function. In this project, we use infinitesimals in two different places. To show that \(p\) is unbounded by constructing a solution where \(p\) evaluates to \(-\frac{1}{\epsilon}\), and to show that \(p\) has no minimum, but an infimum value \(a\), by constructing a solution where \(p\) evaluates to \(a + \epsilon\), and proving that there is no solution \(\leq a\). <h2 id="examples">Examples</h2> The Python API for our package is very simple. It provides the object <code class="language-plaintext highlighter-rouge">RCFNum</code> that is a wrapper for the internal representation used in our package. This object overloads the usual operations <code class="language-plaintext highlighter-rouge">+</code>, <code class="language-plaintext highlighter-rouge">-</code>, <code class="language-plaintext highlighter-rouge">*</code>, <code class="language-plaintext highlighter-rouge"><</code>, etc. We also provide the operations <code class="language-plaintext highlighter-rouge">MkInfinitesimal()</code> for creating a new infinitesimal element, <code class="language-plaintext highlighter-rouge">Pi()</code> and <code class="language-plaintext highlighter-rouge">E()</code> for obtaining the transcendental constants \(\pi\) and \(e\), and <code class="language-plaintext highlighter-rouge">MkRoots([a_0, ..., a_n])</code> that returns the roots of the polynomial \(a_0 + a_1 x + \ldots + a_n x ^ n\). In the following example, I use <code class="language-plaintext highlighter-rouge">MkRoots</code> to “build” \(-\sqrt{2}\) and \(\sqrt{2}\). <figure class="highlight"><pre><code class="language-python" data-lang="python">msqrt2, sqrt2 = MkRoots([-2, 0, 1]) print(msqrt2) >> root(x^2 + -2, (-oo, 0), {}) print(sqrt2) >> root(x^2 + -2, (0, +oo), {})</code></pre></figure> The actual encoding used to represent the numbers is described in the following <a href="https://research.microsoft.com/en-us/um/people/leonardo/files/rcf.pdf">draft</a>. In the example above we distinguish \(-\sqrt{2}\) and \(\sqrt{2}\) using the intervals <code class="language-plaintext highlighter-rouge">(-oo, 0)</code> and <code class="language-plaintext highlighter-rouge">(0, +oo)</code>. For example <code class="language-plaintext highlighter-rouge">root(x^2 + -2, (0, +oo), {})</code> is the single root of \(x ^ 2 - 2\) in the interval \((0, \infty)\). The method <code class="language-plaintext highlighter-rouge">RCFNum.decimal(k)</code> displays a number in decimal notation using <code class="language-plaintext highlighter-rouge">k</code> decimal places. The contract in our package only guarantees that the decimal representation can be produced when the number does not depend on infinitesimal extensions. <figure class="highlight"><pre><code class="language-python" data-lang="python">print(sqrt2.decimal(10)) >> 1.4142135623?</code></pre></figure> The <code class="language-plaintext highlighter-rouge">?</code> in the output above is used to denote that the result is truncated. Now, we show that \(\frac{1}{\sqrt{2}}\) is equal to \(\frac{\sqrt{2}}{2}\), and compute \(\sqrt{2} ^ 5 + 1\) <figure class="highlight"><pre><code class="language-python" data-lang="python">print(1/sqrt2 == sqrt2/2) >> True print(sqrt2**5 + 1) >> 4*root(x^2 + -2, (0, +oo), {}) + 1 print((sqrt2**5 + 1).decimal(10)) >> 6.6568542494?</code></pre></figure> Now, we compute the roots of the polynomial \( \pi - \sqrt{2} x + x ^ 5 \). <figure class="highlight"><pre><code class="language-python" data-lang="python">pi = Pi() rs = MkRoots([pi, - sqrt2, 0, 0, 0, 1]) print(len(rs)) >> 1 print(rs[0]) >> root(x^5 + -1 root(x^2 + -2, (0, +oo), {}) x + pi, (-oo, 0), {}) print(rs[0].decimal()) >> -1.3852383884?</code></pre></figure> Actually, the polynomial has only one root: -1.3852383884?. The output produced also suggests that our representation is recursive. The previous Algebraic number package in Z3 used a “flat” data-structure where every number is encoded using a polynomial with integer coefficients. The main problem in this flat representation is that the polynomials grow really fast. For example, \(\sqrt[11]{2} + \sqrt[7]{2}\) can be compactly encoded in our new package <figure class="highlight"><pre><code class="language-python" data-lang="python">[r1] = MkRoots([-2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]) [r2] = MkRoots([-2, 0, 0, 0, 0, 0, 0, 1]) print(r1 + r2) >> root(x^7 + -2, (0, +oo), {}) + root(x^11 + -2, (0, +oo), {}) print((r1 + r2).decimal(10)) >> 2.1691306031?</code></pre></figure> On the other hand, if we try to represent this value as the root of a polynomial with integer coefficients, we have to use the following polynomial of degree 77. Actually, it is the minimal polynomial (with integer coefficients) for defining this value. <div> \[ \begin{array}{l} -2176 - 19712 x - 670208 x^2 - 2050048 x^3 - 295680 x^4 + 96233984 x^5 - 495599104 x^6 + 11264 x^7 - \\ 198253440 x^8 - 20646191104 x^9 - 650890240 x^{10} + 448 x^{11} - 38011467648 x^{12} + 171371574528 x^{13} - \\ 28160 x^{14} - 37166976 x^{15} - 1268310460032 x^{16} - 11504100608 x^{17} + 34723106880 x^{19} - \\ 2544211567744 x^{20} + 42240 x^{21} - 672 x^{22} - 1992710577088 x^{23} - 43405281920 x^{24} - 186825408 x^{26} + \\ 4024746461120 x^{27} - 42240 x^{28} - 120170824928 x^{30} - 50308241984 x^{31} + 560 x^{33} - 850951467520 x^{34} + 29568 x^{35} - \\ 155813504 x^{37} - 20052576544 x^{38} + 20445649840 x^{41} - 14784 x^{42} - 280 x^{44} - 2670956288 x^{45} - 25531352 x^{48} + \\ 5280 x^{49} - 97853448 x^{52} + 84 x^{55} - 1320 x^{56} - 544236 x^{59} + 220 x^{63} - 14 x^{66} - 22 x^{70} + x^{77} \end{array} \] </div> We can try these examples online <a href="https://rise4fun.com/Z3RCF/D">here</a>. In nonlinear solvers such as nlsat, a procedure such as <code class="language-plaintext highlighter-rouge">MkRoots</code> is extensively used. To demonstrate the basic idea, let us consider a very simple system of polynomial equations in triangular form. <div> \begin{eqnarray*} -1 - x + x^5 & = & 0 \\ -197 + 3131 x - 31 x^2 y^2 + x y^7 & = & 0 \\ -735 x y + 7 y^2 z - 1231 x^3 z^2 + y z^5 & = & 0 \end{eqnarray*} </div> We say the system is in triangular form because the first polynomial equation contains only one variable, the second contains two, and so on. We can solve this kind of system using <code class="language-plaintext highlighter-rouge">MkRoots</code> and “plug-in” the solutions up to step i when solving step i+1. This system has only one solution, and we can find it using <figure class="highlight"><pre><code class="language-python" data-lang="python">[x] = MkRoots([-1, -1, 0, 0, 0, 1]) [y] = MkRoots([-197, 3131, -31*x**2, 0, 0, 0, 0, x]) [z] = MkRoots([-735*x*y, 7*y**2, -1231*x**3, 0, 0, y]) print(x.decimal(10)) >> 1.1673039782? print(y.decimal(10)) >> 0.0629726948? print(z.decimal(10)) >> 31.4453571397?</code></pre></figure> This example in instantaneously solved using our new package. We can try it online <a href="https://rise4fun.com/Z3RCF/1">here</a>. We can also try to solve it using Mathematica <code class="language-plaintext highlighter-rouge">Root</code> primitive that is roughly equivalent to <code class="language-plaintext highlighter-rouge">MkRoots</code>. However, Mathematica builds a “flat” representation like the old Algebraic package in Z3, and takes approximately 10min to find the solution on my machine. The solution for z is encoded using a polynomial with integer coefficients of degree 175 that is too big to display here. Here is the Mathematica script I used <figure class="highlight"><pre><code class="language-pascal" data-lang="pascal">x = Root[#^5 - # - 1 &, 1] y = Root[x #^7 - 31 x^2 #^2 + 3131 # - 197 &, 1] z = Root[y #^5 - 1231 x^3 #^2 + 7 y^2 # - 735 x y &, 1]</code></pre></figure> In the next example, we create infinitesimal elements, and perform some basic operations with them. <figure class="highlight"><pre><code class="language-python" data-lang="python">eps = MkInfinitesimal() print(eps < 0.000000000000001) >> True print(1/eps > 10000000000000000000000) >> True print(1/eps + 1 > 1/eps) >> True print(eps**2 + 1/eps) >> (eps!1^3 + 1)/(eps!1) print(eps**2 < eps) >> True # r is the cubic root of eps [r] = MkRoots([-eps, 0, 0, 1]) print(r) >> root(x^3 + -1 eps!1, (0, +oo), {}) print(r > eps) >> True # We need to use sign conditions to distinguish the roots of for r in MkRoots([1, 0, -eps, -eps, 0, eps**2]): print(r) >> root(eps!1^2*x^5 + -1*eps!1*x^3 + -1*eps!1*x^2 + 1, (-oo, 0), {}) >> root(eps!1^2*x^5 + -1*eps!1*x^3 + -1*eps!1*x^2 + 1, (0, +oo), {60*eps!1^2*x^2 + -6*eps!1 > 0}) >> root(eps!1^2*x^5 + -1*eps!1*x^3 + -1*eps!1*x^2 + 1, (0, +oo), {60*eps!1^2*x^2 + -6*eps!1 < 0}) # The irreducible polynomial: eps x^3 - 6x^2 + 9x - 1 # has three infinite positive roots for r in MkRoots([-1, 9, -6, eps]): print(r) >> root(eps!1*x^3 + -6*x^2 + 9*x + -1, (0, +oo), {3*eps!1*x^2 + -12*x + 9 > 0, 6*eps!1*x + -12 > 0}) >> root(eps!1*x^3 + -6*x^2 + 9*x + -1, (0, +oo), {3*eps!1*x^2 + -12*x + 9 > 0, 6*eps!1*x + -12 < 0}) >> root(eps!1*x^3 + -6*x^2 + 9*x + -1, (0, +oo), {3*eps!1*x^2 + -12*x + 9 < 0, 6*eps!1*x + -12 < 0})</code></pre></figure> Note that <code class="language-plaintext highlighter-rouge">1/eps</code> is an “infinite” value, and we use <a href="https://en.wikipedia.org/wiki/Rational_function">Rational functions</a> to represent elements of infinitesimal (and transcendental) extensions. For example, <code class="language-plaintext highlighter-rouge">eps**2 + 1/eps</code> is internally encoded as \(\frac{\epsilon ^ 3 + 1}{\epsilon}\). Finally, we use sign conditions to identify the roots of \(1 - \epsilon x ^ 2 - \epsilon x ^ 3 + \epsilon ^ 2 x ^ 5\) and \(-1 + 9 x - 6 x ^ 2 + \epsilon x ^ 3 \). We cannot identify them using just intervals with binary Rational end-points because these roots are infinite values. A similar problem occur when we have roots that are infinitely close to each other. Thom’s lemma guarantees that we can always identify the roots of a polynomial using the signs of its derivatives. In our implementation, we minimize the number of sign conditions needed using the intervals whenever possible. For example, our package did not use sign conditions to encode the negative root of \(1 - \epsilon x ^ 2 - \epsilon x ^ 3 + \epsilon ^ 2 x ^ 5\). Moreover, it only needed the sign of one derivative to identify the two positive roots. In principle, we can use the signs of arbitrary polynomials to identify/discriminate the different roots of a polynomial \(p\), Thom’s lemma just says we can find these polynomials by checking the derivatives of \(p\). We can try this example online <a href="https://rise4fun.com/Z3RCF/Do">here</a>. Many other examples are available at <a href="https://rise4fun.com/Z3RCF">rise4fun</a>. Well, we hope you will find new applications for this kind of package. The source code is available online at <a href="https://z3.codeplex.com">codeplex</a>. I think Grant would agree that we had \(\frac{1}{\epsilon}\) fun working on this package :) Sat, 02 Feb 2013 00:00:00 +0000 https://leodemoura.github.io/blog/2013/02/02/inf-trans.html https://leodemoura.github.io/blog/2013/02/02/inf-trans.html Complex Numbers in Z3 <h1 id="complex-numbers-in-z3">Complex Numbers in Z3</h1> A user recently asked me if Z3 had support for Complex numbers. Unfortunately, it does not. This is on my TODO list, but it is has very low priority at this moment. Internally, Z3 already has a lot of machinery for supporting Complex numbers, but there is a lot of “plumbing” missing, such as extending the parsers, simplifiers, models, and root isolation procedures. Most of this work is not really fun. In the meantime, we can encode Complex numbers on top of the Real numbers provided by Z3. The basic idea is to represent a Complex number as a pair of Real numbers. This is not the most efficient way of implementing a decision procedure for the theory of Complex numbers, but it is simple and allows us to handle problems that mix Real and Complex number reasoning. Moreover, we can decide the resulting problem using the new nonlinear arithmetic solver <a href="https://research.microsoft.com/en-us/um/people/leonardo/files/IJCAR2012.pdf">nlsat</a> that is available in Z3. We can represent a complex number <div> \[ a + b i \] </div> as a pair of real numbers <div> \[ (a, b) \] </div> Then the operations on Complex numbers can be easily encode on top of the operations on Real numbers provided by Z3. Here is the encoding of the main operations. <div> \begin{eqnarray*} (a_1, b_1) + (a_2, b_2) & = & (a_1 + a_2,\, b_1 + b_2) \\ (a_1, b_1) - (a_2, b_2) & = & (a_1 - a_2,\, b_1 - b_2) \\ (a_1, b_1) \times (a_2, b_2) & = & (a_1 a_2 - b_1 b_2,\, a_1 b_2 + b_1 a_2) \\ (a, b)^{-1} & = & (\frac{a}{a^2 + b^2}, -\frac{b}{a^2 + b^2}) \mbox { if } a \neq 0 \vee b \neq 0 \\ (a_1, b_1) \div (a_2, b_2) & = & (a_1, b_1) \times (a_2, b_2)^{-1} \mbox { if } a \neq 0 \vee b \neq 0 \\ \end{eqnarray*} </div> The definition of the multiplicative inverse follows from basic algebraic manipulation <div> \[ \frac{1}{a + b i} = \frac{a - b i}{(a + b i)(a - b i)} = \frac{a - b i}{a^2 + b^2} = \frac{a}{a^2 + b^2} - \frac{b}{a^2 + b^2} i \] </div> It is straightforward to implement the operations above using the Z3 Python API. We can even create a class <code class="language-plaintext highlighter-rouge">ComplexExpr</code> to wrap the pair of Z3 real expressions and overload the usual operators <code class="language-plaintext highlighter-rouge">+</code>, <code class="language-plaintext highlighter-rouge">-</code>, <code class="language-plaintext highlighter-rouge">*</code>, <code class="language-plaintext highlighter-rouge">/</code>. This class has two fields <code class="language-plaintext highlighter-rouge">.r</code> (the real part) and <code class="language-plaintext highlighter-rouge">.i</code> (the imaginary part). The auxiliary function <code class="language-plaintext highlighter-rouge">_to_complex</code> is used to convert <code class="language-plaintext highlighter-rouge">a</code> into a Z3 “Complex” number if it is not already one. <figure class="highlight"><pre><code class="language-python" data-lang="python">def _to_complex(a): if isinstance(a, ComplexExpr): return a else: return ComplexExpr(a, RealVal(0)) def _is_zero(a): return (isinstance(a, int) and a == 0) or (is_rational_value(a) and a.numerator_as_long() == 0) class ComplexExpr: def __init__(self, r, i): self.r = r self.i = i def __add__(self, other): other = _to_complex(other) return ComplexExpr(self.r + other.r, self.i + other.i) def __radd__(self, other): other = _to_complex(other) return ComplexExpr(other.r + self.r, other.i + self.i) def __sub__(self, other): other = _to_complex(other) return ComplexExpr(self.r - other.r, self.i - other.i) def __rsub__(self, other): other = _to_complex(other) return ComplexExpr(other.r - self.r, other.i - self.i) def __mul__(self, other): other = _to_complex(other) return ComplexExpr(self.r*other.r - self.i*other.i, self.r*other.i + self.i*other.r) def __mul__(self, other): other = _to_complex(other) return ComplexExpr(other.r*self.r - other.i*self.i, other.i*self.r + other.r*self.i) def inv(self): den = self.r*self.r + self.i*self.i return ComplexExpr(self.r/den, -self.i/den) def __div__(self, other): inv_other = _to_complex(other).inv() return self.__mul__(inv_other) def __rdiv__(self, other): other = _to_complex(other) return self.inv().__mul__(other) def __eq__(self, other): other = _to_complex(other) return And(self.r == other.r, self.i == other.i) def __neq__(self, other): return Not(self.__eq__(other)) def simplify(self): return ComplexExpr(simplify(self.r), simplify(self.i)) def repr_i(self): if is_rational_value(self.i): return "%s*I" % self.i else: return "(%s)*I" % str(self.i) def __repr__(self): if _is_zero(self.i): return str(self.r) elif _is_zero(self.r): return self.repr_i() else: return "%s + %s" % (self.r, self.repr_i())</code></pre></figure> The function <code class="language-plaintext highlighter-rouge">Complex(a)</code> creates a new “Complex” variable. Actually, it creates two real variables named <code class="language-plaintext highlighter-rouge">a.r</code> and <code class="language-plaintext highlighter-rouge">a.i</code>. The constant <code class="language-plaintext highlighter-rouge">I</code> is just an alias for the pair <code class="language-plaintext highlighter-rouge">(0, 1)</code>. <figure class="highlight"><pre><code class="language-python" data-lang="python">def Complex(a): return ComplexExpr(Real('%s.r' % a), Real('%s.i' % a)) I = ComplexExpr(RealVal(0), RealVal(1))</code></pre></figure> The function <code class="language-plaintext highlighter-rouge">evaluate_cexpr</code> “retrieves” the value of a Complex expression <code class="language-plaintext highlighter-rouge">e</code> in the model <code class="language-plaintext highlighter-rouge">m</code>. <figure class="highlight"><pre><code class="language-python" data-lang="python">def evaluate_cexpr(m, e): return ComplexExpr(m[e.r], m[e.i])</code></pre></figure> Now, we have all the pieces we need to solve our first problem. Find a root of <code class="language-plaintext highlighter-rouge">x*x + 2</code>. <figure class="highlight"><pre><code class="language-python" data-lang="python">x = Complex("x") s = Tactic('qfnra-nlsat').solver() s.add(x*x + 2 == 0) print(s.check()) m = s.model() print('x = %s' % evaluate_cexpr(m, x))</code></pre></figure> In the example above, I used <code class="language-plaintext highlighter-rouge">Tactic('qfnra-nlsat').solver()</code> to create a solver based on nlsat. Note that, the problem above is unsatisfiable on the Reals. <a href="https://rise4fun.com/Z3Py/uepl">We can try this example online at rise4fun</a>. Sat, 26 Jan 2013 00:00:00 +0000 https://leodemoura.github.io/blog/2013/01/26/complex.html https://leodemoura.github.io/blog/2013/01/26/complex.html Z3 for Java <h1 id="z3-for-java">Z3 for Java</h1> <a href="https://z3.codeplex.com">Z3</a> now provides support for <a href="https://en.wikipedia.org/wiki/Java_\(programming_language\)">Java</a>. The new Java bindings are based on the .Net bindings developed by Christoph Wintersteiger. They will be included in the next official release. In the meantime, we can already try them using the <a href="https://z3.codeplex.com/SourceControl/changeset/view/8bfbdf1e680d"><code class="language-plaintext highlighter-rouge">unstable</code></a> branch. Please try the new Java bindings and <a href="https://z3.codeplex.com/WorkItem/Create">submit problems and bugs</a>. Here are the instructions to build the Z3 Java bindings. First, we have to clone the <code class="language-plaintext highlighter-rouge">unstable</code> branch from <a href="https://z3.codeplex.com/SourceControl/changeset/view/8bfbdf1e680d">codeplex</a>. <figure class="highlight"><pre><code class="language-bash" data-lang="bash">git clone https://git01.codeplex.com/z3 -b unstable</code></pre></figure> CodePlex requires <a href="https://git-scm.com/">git</a> 1.7.10 or later to avoid HTTPS cloning errors. If we get a cloning error, we should use the instructions found <a href="https://z3.codeplex.com/wikipage?title=Git%20HTTPS%20cloning%20errors">here</a>. Next, we have to checkout the <code class="language-plaintext highlighter-rouge">z3-java</code> tag. This tag “points” to a fairly stable commit in the <code class="language-plaintext highlighter-rouge">unstable</code> branch. <figure class="highlight"><pre><code class="language-bash" data-lang="bash">cd z3 git checkout z3-java</code></pre></figure> Next, we generate the Z3 make file with the option <code class="language-plaintext highlighter-rouge">--java</code>. <figure class="highlight"><pre><code class="language-bash" data-lang="bash">python scripts/mk_make.py --java</code></pre></figure> Now, we build Z3 and the example applications. <figure class="highlight"><pre><code class="language-bash" data-lang="bash">cd build make all examples</code></pre></figure> That is it. Now, we can execute the example located at <a href="https://z3.codeplex.com/SourceControl/changeset/view/8bfbdf1e680d#examples%2fjava%2fJavaExample.java"><code class="language-plaintext highlighter-rouge">examples/java/JavaExample.java</code></a> using: <ul> <li> <code class="language-plaintext highlighter-rouge">java -cp com.microsoft.z3.jar;. JavaExample</code> (on Windows) </li> <li> <code class="language-plaintext highlighter-rouge">LD_LIBRARY_PATH=. java -cp com.microsoft.z3.jar:. JavaExample</code> (on Linux and FreeBSD) </li> <li> <code class="language-plaintext highlighter-rouge">java -cp com.microsoft.z3.jar:. JavaExample</code> (on OSX) </li> </ul> Mon, 10 Dec 2012 00:00:00 +0000 https://leodemoura.github.io/blog/2012/12/10/z3-for-java.html https://leodemoura.github.io/blog/2012/12/10/z3-for-java.html External contributions <h1 id="external-contributions">External contributions</h1> Today, we started to accept external contributions to the Z3 code base. First, I’d like to emphasize that Z3 does not have a liberal license such as GPL or Apache. The source code is available, but it cannot be used for commercial purposes. Moreover, if we read the <a href="https://z3.codeplex.com/license">license</a> carefully, item 3 says that Microsoft can use external contributions for commercial purposes. It is understandable that some may think this is a unfair clause. If you do not agree with the license terms, please do not contribute any code. We initially did not want to accept external contributions. The main issue was that some Z3 internal users have strict rules against external contributions. They can only use code bases that were implemented by Microsoft employees and/or contractors. However, as we gained experience with <a href="https://git-scm.com/">git</a>, it became clear that we can easily maintain a <code class="language-plaintext highlighter-rouge">pure</code> branch containing only internal contributions, and the <code class="language-plaintext highlighter-rouge">master</code> branch with internal and external contributions. Now, the 4 main branches in the Z3 project are <ul> <li><code class="language-plaintext highlighter-rouge">master</code> the official branch containing internal and external contributions.</li> <li><code class="language-plaintext highlighter-rouge">pure</code> the official branch for internal users that cannot use external contributions.</li> <li><code class="language-plaintext highlighter-rouge">unstable</code> the branch for working in progress being done by the Z3 team.</li> <li><code class="language-plaintext highlighter-rouge">contrib</code> the branch for new external contributions and new changes from <code class="language-plaintext highlighter-rouge">unstable</code>.</li> </ul> Remark: We also have other branches for experimental features we are working on. Our plan is to use the following work-flow. The Z3 team works on the <code class="language-plaintext highlighter-rouge">unstable</code> branch. When the code in the <code class="language-plaintext highlighter-rouge">unstable</code> branch becomes “stable”, it is merged into the <code class="language-plaintext highlighter-rouge">pure</code> branch. External contributors submit “pull requests” to the <code class="language-plaintext highlighter-rouge">contrib</code> branch. When the changes in <code class="language-plaintext highlighter-rouge">pure</code> and <code class="language-plaintext highlighter-rouge">contrib</code> are stable, they are merged into the <code class="language-plaintext highlighter-rouge">master</code> branch. The Z3 code base is big and not very well documented. So, it is hard to make contributions to the main engines. At this point, it is more realistic to target contributions such as <ul> <li>Bindings for other programming languages (e.g., Java).</li> <li>New functionality on top of the existing API (e.g., maxsat, allsat, etc).</li> <li>New examples using the Z3 API.</li> <li>Regression tests</li> </ul> In future blog posts, I’m planning to describe the main data-structures used in Z3, and how to add more complicated functionality. I suggest anybody interested in submitting code to contact a Z3 team member before investing time working on it. The idea is to coordinate where the contribution will fit in the project, the scope, and how it will integrate with the other components. Important: Please, do not submit bug fixes using pull requests. Instead submit a bug report using the <a href="https://z3.codeplex.com/WorkItem/Create">issue tracker</a>. Feel free to describe a potential fix. Here are some instructions on how to fork, modify and submit your modifications to the Z3 project. <ul> <li> Make sure you have <a href="https://git-scm.com/">git</a> installed in your system. </li> <li> <a href="https://www.codeplex.com/site/login?RedirectUrl=http%3a%2f%2fwww.codeplex.com%2f">Create an account at Codeplex</a>. </li> <li> Fork the <a href="https://z3.codeplex.com/SourceControl/list/changesets?branch=contrib">Z3 code base</a>. You just have to click the Fork link as described below. </li> </ul> <img src="https://leodemoura.github.io/images/fork1.png" /> <ul> <li>Name your fork. In the following example, I used the name <code class="language-plaintext highlighter-rouge">z3exp</code>.</li> </ul> <img src="https://leodemoura.github.io/images/fork2.png" /> <ul> <li>Retrieve your fork using <code class="language-plaintext highlighter-rouge">git</code>. In the following command, the option <code class="language-plaintext highlighter-rouge">-b contrib</code> is used to retrieve the <code class="language-plaintext highlighter-rouge">contrib</code> branch. Note that you have to replace <code class="language-plaintext highlighter-rouge">leodemoura</code> with your username, and <code class="language-plaintext highlighter-rouge">z3exp</code> with the name you used for your Fork.</li> </ul> <figure class="highlight"><pre><code class="language-bash" data-lang="bash">git clone https://git01.codeplex.com/forks/leodemoura/z3exp -b contrib</code></pre></figure> Remark: CodePlex requires git 1.7.10 or later to avoid HTTPS cloning errors. If you are using an older version of git, you might get an error. If that is your case, here are some <a href="https://z3.codeplex.com/wikipage?title=Git%20HTTPS%20cloning%20errors">instructions</a> on how to fix it. <ul> <li>Perform your modifications and commit them and submit to codeplex. This is your Fork. You can make changes locally and save them at codeplex.</li> </ul> <figure class="highlight"><pre><code class="language-bash" data-lang="bash">... modify/create files ... git commit -a -s -m "my modifications" git push</code></pre></figure> <ul> <li>After you implemented and tested your contribution, you can submit a pull request to the Z3 code base.</li> </ul> <img src="https://leodemoura.github.io/images/fork3.png" /> You are essentially submitting your changes in the <code class="language-plaintext highlighter-rouge">contrib</code> branch (in your Fork) to the <code class="language-plaintext highlighter-rouge">contrib</code> branch in the Z3 code base. You have to make sure that the <code class="language-plaintext highlighter-rouge">from</code> and <code class="language-plaintext highlighter-rouge">to</code> branches are selected correctly like in the following example. <img src="https://leodemoura.github.io/images/fork4.png" /> Mon, 19 Nov 2012 00:00:00 +0000 https://leodemoura.github.io/blog/2012/11/19/external-contrib.html https://leodemoura.github.io/blog/2012/11/19/external-contrib.html Reorganizing the Z3 code base <h1 id="reorganizing-the-z3-code-base">Reorganizing the Z3 code base</h1> Today, we release <a href="https://z3.codeplex.com/SourceControl/changeset/view/a6db55d21f22">Z3 4.3.0</a>. This release contains many bug fixes, a new build system, and, more importantly, a complete reorganization of the code base. Now, the code is organized in sub-directories under the directory <code class="language-plaintext highlighter-rouge">src</code>. It is much easier to find the module we are interested in. For example, if we want to read the nlsat source code, we just have to go to the directory <code class="language-plaintext highlighter-rouge">src/nlsat</code>. The new code reorganization also allow us to easily create binaries/libraries that contain only a subset of the components available in <a href="https://z3.codeplex.com">Z3</a>. We are also officially switching to a three number naming scheme for version numbers. The plan is to have more frequent releases. We skipped version 4.2 because the binary tagged as 4.1.2 was reporting version 4.2. Many thanks to Claude Marche for reporting this problem. Moreover, we realized that it does not make sense to provide zip files with source code at <a href="https://z3.codeplex.com">codeplex</a>. Codeplex provides a “Download” button that automatically creates the zip file for any version/branch/commit. We just have to go to the <a href="https://z3.codeplex.com/SourceControl/changeset/view/a6db55d21f22#">“Source Code” tab</a>, select the version we want and click “Download”. <img src="https://leodemoura.github.io/images/z3-download-page.png" /> The <code class="language-plaintext highlighter-rouge">master</code> branch is the official branch. We use the <code class="language-plaintext highlighter-rouge">unstable</code> branch for work-in-progress that will be included in the next release. Finally, we re-started to provide <a href="https://z3.codeplex.com/releases">pre-compiled binaries for Windows</a>. The new binary distribution is much simpler, it is just a zip file with the binaries, DLLs, and include files. We have a zip file for <a href="https://z3.codeplex.com/downloads/get/528588">32</a> and <a href="https://z3.codeplex.com/downloads/get/528578">64 bits</a>. One bad news is that the ML bindings are still not working in this version, but we will fix that in future releases. <h1 id="building-z3">Building Z3</h1> The new build system is based on python. The script <code class="language-plaintext highlighter-rouge">scripts/mk_make.py</code> creates the Makefile, generates bindings for .Net and Python, DLL definitions, etc. It can also optionally create an auxiliary Visual Project file for people that cannot live without Visual Studio intellisense. The generated Makefiles can be compiled using Visual Studio <code class="language-plaintext highlighter-rouge">nmake</code> or GNU <code class="language-plaintext highlighter-rouge">make</code>. By default, the script <code class="language-plaintext highlighter-rouge">scripts/mk_make.py</code> generates the Makefile in the subdirectory <code class="language-plaintext highlighter-rouge">build</code>. <h2 id="building-z3-on-windows">Building Z3 on Windows</h2> To compile Z3 on a Windows machine, we should open a Visual Studio Command Prompt (All Programs > Microsoft Visual Studio 20xx > Visual Studio Tools), go to the directory where the Z3 source code is located, and type <figure class="highlight"><pre><code class="language-bash" data-lang="bash">python scripts/mk_make.py cd build nmake</code></pre></figure> <h2 id="building-z3-on-linux-osx-and-cygwin">Building Z3 on Linux, OSX (and cygwin)</h2> In other platforms, we just have to execute the following commands. <figure class="highlight"><pre><code class="language-bash" data-lang="bash">autoconf ./configure python scripts/mk_make.py cd build make</code></pre></figure> The example applications can be built using <figure class="highlight"><pre><code class="language-bash" data-lang="bash">make examples</code></pre></figure> Z3 can be installed in these platforms using the standard <figure class="highlight"><pre><code class="language-bash" data-lang="bash">sudo make install</code></pre></figure> The binaries and libraries are installed in the “prefix” specified in the <code class="language-plaintext highlighter-rouge">./configure</code> script. The default “prefix” is <code class="language-plaintext highlighter-rouge">/usr</code>. To uninstall, we just have to execute <figure class="highlight"><pre><code class="language-bash" data-lang="bash">sudo make uninstall</code></pre></figure> <h2 id="custom-builds">Custom builds</h2> To list all command line options available in <code class="language-plaintext highlighter-rouge">scripts/mk_make.py</code>, we just have to execute <figure class="highlight"><pre><code class="language-bash" data-lang="bash">python scripts/mk_make.py --help</code></pre></figure> For example, the option <code class="language-plaintext highlighter-rouge">--debug</code> generates a Makefile that builds Z3 in debug mode. The file <code class="language-plaintext highlighter-rouge">scripts/mk_project.py</code> defines all existing modules and dependencies between them. Sun, 11 Nov 2012 00:00:00 +0000 https://leodemoura.github.io/blog/2012/11/11/reorg-z3.html https://leodemoura.github.io/blog/2012/11/11/reorg-z3.html Releasing the Z3 source code <h1 id="releasing-the-z3-source-code">Releasing the Z3 source code</h1> <strike>Z3 is now open source.</strike> Z3 source code is now available. The source code is available under the MSR-LA license. This is the same license used to distribute the Z3 binaries. The source code can be used for non-commercial purposes. The license allows users to redistribute, copy and modify Z3. For more information see <a href="https://z3.codeplex.com/license">https://z3.codeplex.com/license</a>. EDIT MSR-LA is not as “open” as GPL, Apache or BSD, but it allows users to read, copy, redistribute, modify, and experiment with Z3 source code. I believe MSR-LA matches academic openness and transparency. The main restriction is that the source code cannot be used for commercial purposes. END EDIT Nikolaj Bjorner, Christoph Wintersteiger and I wrote several papers describing new algorithms and heuristics for SMT solvers. Some of them are non trivial and hard to reproduce. I believe the source code complements these papers, and may help others to clarify misunderstandings, dispute claims made in our papers, experiment new ideas, reproduce our results, and advance the state-of-the-art. Perhaps, the actual implementation is as important as the abstract procedures described in our papers. By having the source code available, some features become obsolete. For example, the theory plugin API is not needed anymore. Now, users can directly implement their extensions inside the Z3 code base. I think the code is quite readable, but it was not originally written for external consumption. We wrote the code for ourselves. Several parts have been rewritten several times, and some duplication exists. Anyway, I will try to cleanup the code in the future. Please, fell free to bug me if you are interested in hacking and/or understanding the source code. All important files are located in the directory <code class="language-plaintext highlighter-rouge">lib</code>. The source code can be compiled in all major platforms. I tried on Windows (using Visual Studio) and Linux (using g++). If you find a problem, please contact me, and I will fix it. Tue, 02 Oct 2012 00:00:00 +0000 https://leodemoura.github.io/blog/2012/10/02/open-z3.html https://leodemoura.github.io/blog/2012/10/02/open-z3.html

Original Source | Taken Source