Fix some spelling errors (mostly in comments).

src/math/euclid/euclidean_solver.cpp

@@ -690,7 +690,7 @@ struct euclidean_solver::imp {
             m().del(eq.m_as[j]);
         eq.m_as.shrink(new_sz);
         eq.m_xs.shrink(new_sz);
-        // ajust c
+        // adjust c
         mpz new_c;
         decompose(m_next_pos_a, m_next_a, eq.m_c, new_c, eq.m_c);
         // create auxiliary equation

src/math/polynomial/algebraic_numbers.cpp

@@ -948,7 +948,7 @@ namespace algebraic_numbers {
                     // zero is a root of p, and r_i is an isolating interval containing zero,
                     // then c is zero
                     reset(c);
-                    TRACE("algebraic", tout << "reseting\nresult: "; display_root(tout, c); tout << "\n";);
+                    TRACE("algebraic", tout << "resetting\nresult: "; display_root(tout, c); tout << "\n";);
                     return;
                 }
                 int zV = upm().sign_variations_at_zero(seq);
@@ -1728,7 +1728,7 @@ namespace algebraic_numbers {
             COMPARE_INTERVAL();
 
             // if cell_a and cell_b, contain the same polynomial,
-            // and the intervals are overlaping, then they are
+            // and the intervals are overlapping, then they are
             // the same root.
             if (compare_p(cell_a, cell_b)) {
                 m_compare_poly_eq++;
@@ -1825,7 +1825,7 @@ namespace algebraic_numbers {
 
            // Here is an unexplored option for comparing numbers.
            //
-           // The isolating intervals of a and b are still overlaping
+           // The isolating intervals of a and b are still overlapping
            // Then we compute
            //    r(x) = Resultant(x - y1 + y2, p1(y1), p2(y2))
            //    where p1(y1) and p2(y2) are the polynomials defining a and b.

src/math/polynomial/polynomial.cpp

@@ -4052,7 +4052,7 @@ namespace polynomial {
 
         // select a new random value in GF(p) that is not in vals, and store it in r
         void peek_fresh(scoped_numeral_vector const & vals, unsigned p, scoped_numeral & r) {
-            SASSERT(vals.size() < p); // otherwise we cant keep the fresh value
+            SASSERT(vals.size() < p); // otherwise we can't keep the fresh value
             unsigned sz = vals.size();
             while (true) {
                 m().set(r, rand() % p);
@@ -4149,7 +4149,7 @@ namespace polynomial {
                 TRACE("mgcd_detail", tout << "counter: " << counter << "\nidx: " << idx << "\nq: " << q << "\ndeg_q: " << deg_q << "\nmin_deg_q: " <<
                       min_deg_q << "\nnext_x: x" << vars[idx+1] << "\nmax_var(q): " << q_var << "\n";);
                 if (deg_q < min_deg_q) {
-                    TRACE("mgcd_detail", tout << "reseting...\n";);
+                    TRACE("mgcd_detail", tout << "resetting...\n";);
                     counter   = 0;
                     min_deg_q = deg_q;
                     // start from scratch

src/math/polynomial/polynomial.h

@@ -131,12 +131,12 @@ namespace polynomial {
             ~factors();
             
             /**
-               \brief Numer of distinct factors (not counting multiplicities).
+               \brief Number of distinct factors (not counting multiplicities).
             */
             unsigned distinct_factors() const { return m_factors.size(); }
             
             /**
-               \brief Numer of distinct factors (counting multiplicities).
+               \brief Number of distinct factors (counting multiplicities).
             */
             unsigned total_factors() const { return m_total_factors; }
 

src/math/polynomial/upolynomial.cpp

@@ -362,7 +362,7 @@ namespace upolynomial {
         set_size(sz-1, buffer);
     }
 
-    // Divide coeffients of p by their GCD
+    // Divide coefficients of p by their GCD
     void core_manager::normalize(unsigned sz, numeral * p) {
         if (sz == 0)
             return;
@@ -395,7 +395,7 @@ namespace upolynomial {
         }
     }
 
-    // Divide coeffients of p by their GCD
+    // Divide coefficients of p by their GCD
     void core_manager::normalize(numeral_vector & p) {
         normalize(p.size(), p.c_ptr());
     }
@@ -568,7 +568,7 @@ namespace upolynomial {
         SASSERT(!is_alias(p1, buffer)); SASSERT(!is_alias(p2, buffer));
         unsigned d;
         rem(sz1, p1, sz2, p2, d, buffer);
-        // We don't ned to flip the sign if d is odd and leading coefficient of p2 is negative
+        // We don't need to flip the sign if d is odd and leading coefficient of p2 is negative
         if (d % 2 == 0 || (sz2 > 0 && m().is_pos(p2[sz2-1])))
             neg(buffer.size(), buffer.c_ptr());
     }
@@ -2005,7 +2005,7 @@ namespace upolynomial {
                 continue;
             bool pos_a_n_k = m().is_pos(a_n_k);
             if (pos_a_n_k == pos_a_n)
-                continue; // must have oposite signs
+                continue; // must have opposite signs
             unsigned log2_a_n_k = pos_a_n_k ? m().log2(a_n_k) : m().mlog2(a_n_k);
             if (log2_a_n > log2_a_n_k)
                 continue;
@@ -2103,7 +2103,7 @@ namespace upolynomial {
         frame_stack.pop_back();
     }
 
-    // Auxiliar method for isolating the roots of p in the interval (0, 1).
+    // Auxiliary method for isolating the roots of p in the interval (0, 1).
     // The basic idea is to split the interval in: (0, 1/2) and (1/2, 1).
     // This is accomplished by analyzing the roots in the interval (0, 1) of the following polynomials.
     //   p1(x) := 2^n * p(x/2)   where n = sz-1
@@ -2574,10 +2574,10 @@ namespace upolynomial {
        We say an interval (a, b) of a polynomial p is ISOLATING if p has only one root in the
        interval (a, b).
 
-       We say an isolating interval (a, b) of a square free polynomial p is REFINEABLE if
+       We say an isolating interval (a, b) of a square free polynomial p is REFINABLE if
          sign(p(a)) = -sign(p(b))
 
-       Not every isolating interval (a, b) of a square free polynomial p is refineable, because
+       Not every isolating interval (a, b) of a square free polynomial p is refinable, because
        sign(p(a)) or sign(p(b)) may be zero.
 
        Refinable intervals of square free polynomials are useful, because we can increase precision

src/math/polynomial/upolynomial.h

@@ -256,12 +256,12 @@ namespace upolynomial {
         void derivative(numeral_vector const & p, numeral_vector & d_p) { derivative(p.size(), p.c_ptr(), d_p); }
 
         /**
-           \brief Divide coeffients of p by their GCD
+           \brief Divide coefficients of p by their GCD
         */
         void normalize(unsigned sz, numeral * p);
         
         /**
-           \brief Divide coeffients of p by their GCD
+           \brief Divide coefficients of p by their GCD
         */
         void normalize(numeral_vector & p);
 

src/math/polynomial/upolynomial_factorization_int.h

@@ -195,7 +195,7 @@ namespace upolynomial {
 
                 // the index we are currently trying to fix
                 int current_i = m_current_size - 1;
-                // the value we found as plausable (-1 we didn't find anything)
+                // the value we found as plausible (-1 we didn't find anything)
                 int current_value = -1;
 
                 if (remove_current) {

src/math/realclosure/mpz_matrix.h

@@ -107,7 +107,7 @@ public:
        this method will give preference to the row that occurs first.
        
        \remark The vector r must have at least A.n() capacity
-       The numer of linear independent rows is returned.
+       The number of linear independent rows is returned.
 
        Store the new matrix in B.
     */

src/math/realclosure/rcf_params.pyg

@@ -6,5 +6,5 @@ def_module_params('rcf',
                           ('initial_precision', UINT, 24, "a value k that is the initial interval size (as 1/2^k) when creating transcendentals and approximated division"),
                           ('inf_precision', UINT, 24, "a value k that is the initial interval size (i.e., (0, 1/2^l)) used as an approximation for infinitesimal values"),
                           ('max_precision', UINT, 128, "during sign determination we switch from interval arithmetic to complete methods when the interval size is less than 1/2^k, where k is the max_precision"),
-                          ('lazy_algebraic_normalization', BOOL, True, "during sturm-seq and square-free polynomial computations, only normalize algebraic polynomial expressions when the definining polynomial is monic")
+                          ('lazy_algebraic_normalization', BOOL, True, "during sturm-seq and square-free polynomial computations, only normalize algebraic polynomial expressions when the defining polynomial is monic")
                           ))

src/math/realclosure/realclosure.cpp

@@ -4790,7 +4790,7 @@ namespace realclosure {
 
         /**
            \brief Determine the sign of the new rational function value.
-           The idea is to keep refinining the interval until interval of v does not contain 0.
+           The idea is to keep refining the interval until interval of v does not contain 0.
            After a couple of steps we switch to expensive sign determination procedure.
 
            Return false if v is actually zero.
@@ -5474,7 +5474,7 @@ namespace realclosure {
                 }
                 else {
                     // Let sdt be alpha->sdt();
-                    // In pricipal, the signs of the polynomials sdt->qs can be used
+                    // In principal, the signs of the polynomials sdt->qs can be used
                     // to discriminate the roots of new_p. The signs of this polynomials
                     // depend only on alpha, and not on the polynomial used to define alpha
                     // So, in principle, we can reuse m_qs and m_sign_conditions.

src/math/simplex/network_flow.h

@@ -148,7 +148,7 @@ namespace smt {
         vector<numeral>      m_potentials;   // nodes + 1 |-> initial: +/- 1  
                                              // Duals of flows which are convenient to compute dual solutions 
                                              // become solutions to Dual simplex.
-        vector<numeral>      m_flows;        // edges + nodes |-> assignemnt Basic feasible flows
+        vector<numeral>      m_flows;        // edges + nodes |-> assignment Basic feasible flows
         svector<edge_state>  m_states;
         unsigned             m_step;
         edge_id              m_enter_id;

src/math/subpaving/subpaving_t.h

@@ -202,7 +202,7 @@ public:
     public:
         node(context_t & s, unsigned id);
         node(node * parent, unsigned id);
-        // return unique indentifier.
+        // return unique identifier.
         unsigned id() const { return m_id; }
         bound_array_manager & bm() const { return m_bm; }
         bound_array & lowers() { return m_lowers; }

src/math/subpaving/subpaving_t_def.h

@@ -248,7 +248,7 @@ public:
 
 
 /**
-   \brief Auxiliary static method used to diplay a bound specified by (x, k, lower, open).
+   \brief Auxiliary static method used to display a bound specified by (x, k, lower, open).
 */
 template<typename C>
 void context_t<C>::display(std::ostream & out, numeral_manager & nm, display_var_proc const & proc, var x, numeral & k, bool lower, bool open) {