Repository: sympy/sympy

Issue:
simplify is not able to cancel exponentials that would result in a simpler expression:
```
# Example:
from sympy import *
t, k01, k11 = symbols('t k01 k11', real=True)
myexp = (exp(k01*t) - exp(k11*t))*exp(-t*(k01 + k11))/(k01 - k11)

# simplify does nothing:
myexp2 = print(simplify(myexp))
(exp(k01*t) - exp(k11*t))*exp(-t*(k01 + k11))/(k01 - k11)

# removing denominator, simplifying, and then putting back does simplify:
myexp3 = print(simplify(myexp*(k01 - k11))/(k01 - k11))
(exp(-k11*t) - exp(-k01*t))/(k01 - k11)
```

Discussion:
sympy-bot: :white_check_mark:

Hi, I am the [SymPy bot](https://github.com/sympy/sympy-bot). I'm here to help you write a release notes entry. Please read the [guide on how to write release notes](https://github.com/sympy/sympy/wiki/Writing-Release-Notes).



Your release notes are in good order.

Here is what the release notes will look like:
* core
  * expand will now accept the hint `exact` which  may be useful when trying to expand the numerator of a fraction having a power like `x**-y` which is to be kept in the numerator instead of defaulting to the denominator ([#26347](https://github.com/sympy/sympy/pull/26347) by [@smichr](https://github.com/smichr))

This will be added to https://github.com/sympy/sympy/wiki/Release-Notes-for-1.13.

<details><summary>Click here to see the pull request description that was parsed.</summary>

    Now `expand` will pass along hints to `fraction` to allow it to leave powers with negative leading coefficients in the numerator rather than the denominator. I don't think the same issue can apply to denominators since a power with a negative exponent is automatically associated with the numerator. i.e. exp(-x) can be interpreted as being in the numerator or denominator while 1/exp(-x) will be identified as exp(x) (for which there is no ambiguity).

    <!-- Your title above should be a short description of what
    was changed. Do not include the issue number in the title. -->

    #### References to other Issues or PRs
    <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact
    format, e.g. "Fixes #1234" (see
    https://tinyurl.com/auto-closing for more information). Also, please
    write a comment on that issue linking back to this pull request once it is
    open. -->

    closes #26329
    #### Brief description of what is fixed or changed


    #### Other comments


    #### Release Notes

    <!-- Write the release notes for this release below between the BEGIN and END
    statements. The basic format is a bulleted list with the name of the subpackage
    and the release note for this PR. For example:

    * solvers
      * Added a new solver for logarithmic equations.

    * functions
      * Fixed a bug with log of integers. Formerly, `log(-x)` incorrectly gave `-log(x)`.

    * physics.units
      * Corrected a semantical error in the conversion between volt and statvolt which
        reported the volt as being larger than the statvolt.

    or if no release note(s) should be included use:

    NO ENTRY

    See https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more
    information on how to write release notes. The bot will check your release
    notes automatically to see if they are formatted correctly. -->

    <!-- BEGIN RELEASE NOTES -->
    * core
      * expand will now accept the hint `exact` which  may be useful when trying to expand the numerator of a fraction having a power like `x**-y` which is to be kept in the numerator instead of defaulting to the denominator
    <!-- END RELEASE NOTES -->


</details><p>


Patch:
diff --git a/.mailmap b/.mailmap
index 9769de1266..82bc75fd23 100644
--- a/.mailmap
+++ b/.mailmap
@@ -530,8 +530,6 @@ Dimitra Konomi <t8130064@dias.aueb.gr>
 Divyanshu Thakur <divyanshu@iiitmanipur.ac.in> Divyanshu <divyanshu@iiitmanipur.ac.in>
 Dmitry Batkovich <batya239@gmail.com>
 Dmitry Savransky <dsavransky@gmail.com>
-Dodopalu <87149525+Dodopalu@users.noreply.github.com>
-Dodopalu <87149525+Dodopalu@users.noreply.github.com>
 Dominik Stańczak <stanczakdominik@gmail.com>
 Donald Wilson <donwilson1029@gmail.com> wilds-23 <wilds-23@rhodes.edu>
 Duane Nykamp <nykamp@umn.edu>
@@ -861,7 +859,6 @@ Langston Barrett <langston.barrett@gmail.com>
 Lars Buitinck <larsmans@gmail.com>
 Laura Domine <temigo@gmx.com>
 Lauren Glattly <laurenglattly@gmail.com>
-Lauren Yim <31467609+cherryblossom000@users.noreply.github.com>
 Laurence Warne <laurencewarne@gmail.com>
 Le Cong Minh Hieu <hieu.lecongminh@gmail.com>
 Lee Johnston <lee.johnston.100@gmail.com>
@@ -1124,7 +1121,6 @@ Prateek Papriwal <papriwalprateek@gmail.com>
 Praveen Sahu <povinsahu@gmail.com> povinsahu1909 <povinsahu@gmail.com>
 Prayush Dawda <35144226+iamprayush@users.noreply.github.com>
 Prempal Singh <prempal.42@gmail.com>
-Prey Patel <patel.prey@iitgn.ac.in>
 Priit Laes <plaes@plaes.org>
 Prince Gupta <codemastercpp@gmail.com> LAPTOP-AS1M2R8B\codem <codemastercpp@gmail.com>
 Prionti Nasir <pdn3628@rit.edu>
@@ -1550,7 +1546,6 @@ dandiez <47832466+dandiez@users.noreply.github.com>
 der-blaue-elefant <github@kklein.de>
 dimasvq <dimas.vq.2020@bristol.ac.uk>
 dispasha <dispasha@users.noreply.github.com>
-dodo <palumbododo@gmail.com>
 dps7ud <dps7ud@virginia.edu>
 dranknight09 <cbhaavan@gmail.com>
 dustyrockpyle <dustyrockpyle@gmail.com>
diff --git a/doc/src/modules/physics/vector/vectors.rst b/doc/src/modules/physics/vector/vectors.rst
index 0e164b350f..d92f478302 100644
--- a/doc/src/modules/physics/vector/vectors.rst
+++ b/doc/src/modules/physics/vector/vectors.rst
@@ -607,18 +607,18 @@ relationship between the two frames has been defined. ::
   >>> A.x + N.x
   N.x + A.x
 
-If we want to do vector multiplication, first we have to define and
+If we want to do vector multiplication, first we have to define an
 orientation. The ``orient`` method of ``ReferenceFrame`` provides that
 functionality. ::
 
   >>> A.orient(N, 'Axis', [x, N.y])
 
-If we desire, we can view the DCM between these two frames at any time. This
-can be calculated with the ``dcm`` method. This code: ``N.dcm(A)`` gives the
-dcm :math:`^{\mathbf{A}} \mathbf{C} ^{\mathbf{N}}`.
-
 This orients the :math:`\mathbf{A}` frame relative to the :math:`\mathbf{N}`
-frame by a simple rotation around the Y axis, by an amount x. Other, more
+frame by a simple rotation, around the Y axis, by an amount x.
+The DCM between these two frames can be viewed at any time with the
+``dcm`` method: ``A.dcm(N)`` gives the dcm :math:`^{\mathbf{A}} \mathbf{C} ^{\mathbf{N}}`.
+
+Other, more
 complicated rotation types include Body rotations, Space rotations,
 quaternions, and arbitrary axis rotations. Body and space rotations are
 equivalent to doing 3 simple rotations in a row, each about a basis vector in
diff --git a/sympy/core/expr.py b/sympy/core/expr.py
index 1e9c67d179..c6be21344a 100644
--- a/sympy/core/expr.py
+++ b/sympy/core/expr.py
@@ -3631,15 +3631,17 @@ def expand(self, deep=True, modulus=None, power_base=True, power_exp=True,
            log=log, multinomial=multinomial, basic=basic)
 
         expr = self
+        # default matches fraction's default
+        _fraction = lambda x: fraction(x, hints.get('exact', False))
         if hints.pop('frac', False):
             n, d = [a.expand(deep=deep, modulus=modulus, **hints)
-                    for a in fraction(self)]
+                    for a in _fraction(self)]
             return n/d
         elif hints.pop('denom', False):
-            n, d = fraction(self)
+            n, d = _fraction(self)
             return n/d.expand(deep=deep, modulus=modulus, **hints)
         elif hints.pop('numer', False):
-            n, d = fraction(self)
+            n, d = _fraction(self)
             return n.expand(deep=deep, modulus=modulus, **hints)/d
 
         # Although the hints are sorted here, an earlier hint may get applied
diff --git a/sympy/core/mul.py b/sympy/core/mul.py
index 660accba60..b921c3cf52 100644
--- a/sympy/core/mul.py
+++ b/sympy/core/mul.py
@@ -920,7 +920,8 @@ def _eval_expand_mul(self, **hints):
         # Handle things like 1/(x*(x + 1)), which are automatically converted
         # to 1/x*1/(x + 1)
         expr = self
-        n, d = fraction(expr)
+        # default matches fraction's default
+        n, d = fraction(expr, hints.get('exact', False))
         if d.is_Mul:
             n, d = [i._eval_expand_mul(**hints) if i.is_Mul else i
                 for i in (n, d)]
diff --git a/sympy/logic/algorithms/z3_wrapper.py b/sympy/logic/algorithms/z3_wrapper.py
index fe44f713a2..1b75a42dce 100644
--- a/sympy/logic/algorithms/z3_wrapper.py
+++ b/sympy/logic/algorithms/z3_wrapper.py
@@ -29,16 +29,11 @@ def z3_satisfiable(expr, all_models=False):
     if res == "unsat":
         return False
     elif res == "sat":
-        return z3_model_to_sympy_model(s.model(), expr)
+        return True
     else:
         return None
 
 
-def z3_model_to_sympy_model(z3_model, enc_cnf):
-    rev_enc = {value : key for key, value in enc_cnf.encoding.items()}
-    return {rev_enc[int(var.name()[1:])] : bool(z3_model[var]) for var in z3_model}
-
-
 def clause_to_assertion(clause):
     clause_strings = [f"d{abs(lit)}" if lit > 0 else f"(not d{abs(lit)})" for lit in clause]
     return "(assert (or " + " ".join(clause_strings) + "))"
diff --git a/sympy/physics/continuum_mechanics/beam.py b/sympy/physics/continuum_mechanics/beam.py
index a9a9bc20cc..fc9c436414 100644
--- a/sympy/physics/continuum_mechanics/beam.py
+++ b/sympy/physics/continuum_mechanics/beam.py
@@ -934,8 +934,8 @@ def max_shear_force(self):
             if isinstance(term, Mul):
                 term = term.args[-1]    # SingularityFunction in the term
             singularity.append(term.args[1])
-        singularity = list(set(singularity))
         singularity.sort()
+        singularity = list(set(singularity))
 
         intervals = []    # List of Intervals with discrete value of shear force
         shear_values = []   # List of values of shear force in each interval
@@ -1018,8 +1018,8 @@ def max_bmoment(self):
             if isinstance(term, Mul):
                 term = term.args[-1]    # SingularityFunction in the term
             singularity.append(term.args[1])
-        singularity = list(set(singularity))
         singularity.sort()
+        singularity = list(set(singularity))
 
         intervals = []    # List of Intervals with discrete value of bending moment
         moment_values = []   # List of values of bending moment in each interval
@@ -1027,10 +1027,7 @@ def max_bmoment(self):
             if s == 0:
                 continue
             try:
-                moment_slope = Piecewise(
-                    (float("nan"), x <= singularity[i - 1]),
-                    (self.shear_force().rewrite(Piecewise), x < s),
-                    (float("nan"), True))
+                moment_slope = Piecewise((float("nan"), x<=singularity[i-1]),(self.shear_force().rewrite(Piecewise), x<s), (float("nan"), True))
                 points = solve(moment_slope, x)
                 val = []
                 for point in points:
@@ -1040,7 +1037,6 @@ def max_bmoment(self):
                 max_moment = max(val)
                 moment_values.append(max_moment)
                 intervals.append(points[val.index(max_moment)])
-
             # If bending moment in a particular Interval has zero or constant
             # slope, then above block gives NotImplementedError as solve
             # can't represent Interval solutions.
diff --git a/sympy/printing/latex.py b/sympy/printing/latex.py
index 834c57626b..7b70e294e6 100644
--- a/sympy/printing/latex.py
+++ b/sympy/printing/latex.py
@@ -167,7 +167,6 @@ class LatexPrinter(Printer):
         "min": None,
         "max": None,
         "diff_operator": "d",
-        "adjoint_style": "dagger",
     }
 
     def __init__(self, settings=None):
@@ -1756,23 +1755,17 @@ def _print_Trace(self, expr):
         return r"\operatorname{tr}\left(%s \right)" % self._print(mat)
 
     def _print_Adjoint(self, expr):
-        style_to_latex = {
-            "dagger"   : r"\dagger",
-            "star"     : r"\ast",
-            "hermitian": r"\mathsf{H}"
-        }
-        adjoint_style = style_to_latex.get(self._settings["adjoint_style"], r"\dagger")
         mat = expr.arg
         from sympy.matrices import MatrixSymbol, BlockMatrix
         if (not isinstance(mat, MatrixSymbol) and
             not isinstance(mat, BlockMatrix) and mat.is_MatrixExpr):
-            return r"\left(%s\right)^{%s}" % (self._print(mat), adjoint_style)
+            return r"\left(%s\right)^{\dagger}" % self._print(mat)
         else:
             s = self.parenthesize(mat, precedence_traditional(expr), True)
             if '^' in s:
-                return r"\left(%s\right)^{%s}" % (s, adjoint_style)
+                return r"\left(%s\right)^{\dagger}" % s
             else:
-                return r"%s^{%s}" % (s, adjoint_style)
+                return r"%s^{\dagger}" % s
 
     def _print_MatMul(self, expr):
         from sympy import MatMul
@@ -3052,9 +3045,6 @@ def latex(expr, **settings):
     diff_operator: string, optional
         String to use for differential operator. Default is ``'d'``, to print in italic
         form. ``'rd'``, ``'td'`` are shortcuts for ``\mathrm{d}`` and ``\text{d}``.
-    adjoint_style: string, optional
-        String to use for the adjoint symbol. Defined options are ``'dagger'``
-        (default),``'star'``, and ``'hermitian'``.
 
     Notes
     =====
diff --git a/sympy/printing/pretty/pretty.py b/sympy/printing/pretty/pretty.py
index b44302be66..48c8698c82 100644
--- a/sympy/printing/pretty/pretty.py
+++ b/sympy/printing/pretty/pretty.py
@@ -20,7 +20,7 @@
 from sympy.printing.pretty.stringpict import prettyForm, stringPict
 from sympy.printing.pretty.pretty_symbology import hobj, vobj, xobj, \
     xsym, pretty_symbol, pretty_atom, pretty_use_unicode, greek_unicode, U, \
-    pretty_try_use_unicode, annotated, is_subscriptable_in_unicode, center_pad,  root as nth_root
+    pretty_try_use_unicode, annotated, is_subscriptable_in_unicode, center_pad
 
 # rename for usage from outside
 pprint_use_unicode = pretty_use_unicode
@@ -233,14 +233,14 @@ def _print_Not(self, e):
             arg = e.args[0]
             pform = self._print(arg)
             if isinstance(arg, Equivalent):
-                return self._print_Equivalent(arg, altchar=pretty_atom('NotEquiv'))
+                return self._print_Equivalent(arg, altchar="\N{LEFT RIGHT DOUBLE ARROW WITH STROKE}")
             if isinstance(arg, Implies):
-                return self._print_Implies(arg, altchar=pretty_atom('NotArrow'))
+                return self._print_Implies(arg, altchar="\N{RIGHTWARDS ARROW WITH STROKE}")
 
             if arg.is_Boolean and not arg.is_Not:
                 pform = prettyForm(*pform.parens())
 
-            return prettyForm(*pform.left(pretty_atom('Not')))
+            return prettyForm(*pform.left("\N{NOT SIGN}"))
         else:
             return self._print_Function(e)
 
@@ -267,43 +267,43 @@ def __print_Boolean(self, e, char, sort=True):
 
     def _print_And(self, e):
         if self._use_unicode:
-            return self.__print_Boolean(e, pretty_atom('And'))
+            return self.__print_Boolean(e, "\N{LOGICAL AND}")
         else:
             return self._print_Function(e, sort=True)
 
     def _print_Or(self, e):
         if self._use_unicode:
-            return self.__print_Boolean(e, pretty_atom('Or'))
+            return self.__print_Boolean(e, "\N{LOGICAL OR}")
         else:
             return self._print_Function(e, sort=True)
 
     def _print_Xor(self, e):
         if self._use_unicode:
-            return self.__print_Boolean(e, pretty_atom("Xor"))
+            return self.__print_Boolean(e, "\N{XOR}")
         else:
             return self._print_Function(e, sort=True)
 
     def _print_Nand(self, e):
         if self._use_unicode:
-            return self.__print_Boolean(e, pretty_atom('Nand'))
+            return self.__print_Boolean(e, "\N{NAND}")
         else:
             return self._print_Function(e, sort=True)
 
     def _print_Nor(self, e):
         if self._use_unicode:
-            return self.__print_Boolean(e, pretty_atom('Nor'))
+            return self.__print_Boolean(e, "\N{NOR}")
         else:
             return self._print_Function(e, sort=True)
 
     def _print_Implies(self, e, altchar=None):
         if self._use_unicode:
-            return self.__print_Boolean(e, altchar or pretty_atom('Arrow'), sort=False)
+            return self.__print_Boolean(e, altchar or "\N{RIGHTWARDS ARROW}", sort=False)
         else:
             return self._print_Function(e)
 
     def _print_Equivalent(self, e, altchar=None):
         if self._use_unicode:
-            return self.__print_Boolean(e, altchar or pretty_atom('Equiv'))
+            return self.__print_Boolean(e, altchar or "\N{LEFT RIGHT DOUBLE ARROW}")
         else:
             return self._print_Function(e, sort=True)
 
@@ -511,7 +511,7 @@ def _print_Product(self, expr):
         if self._use_unicode:
             # use unicode corners
             horizontal_chr = xobj('-', 1)
-            corner_chr = xobj('UpTack', 1)
+            corner_chr = '\N{BOX DRAWINGS LIGHT DOWN AND HORIZONTAL}'
 
         func_height = pretty_func.height()
 
@@ -673,7 +673,7 @@ def _print_Limit(self, l):
 
         LimArg = self._print(z)
         if self._use_unicode:
-            LimArg = prettyForm(*LimArg.right(f"{xobj('-', 1)}{pretty_atom('Arrow')}"))
+            LimArg = prettyForm(*LimArg.right('\N{BOX DRAWINGS LIGHT HORIZONTAL}\N{RIGHTWARDS ARROW}'))
         else:
             LimArg = prettyForm(*LimArg.right('->'))
         LimArg = prettyForm(*LimArg.right(self._print(z0)))
@@ -682,7 +682,7 @@ def _print_Limit(self, l):
             dir = ""
         else:
             if self._use_unicode:
-                dir = pretty_atom('SuperscriptPlus') if str(dir) == "+" else pretty_atom('SuperscriptMinus')
+                dir = '\N{SUPERSCRIPT PLUS SIGN}' if str(dir) == "+" else '\N{SUPERSCRIPT MINUS}'
 
         LimArg = prettyForm(*LimArg.right(self._print(dir)))
 
@@ -864,7 +864,7 @@ def _print_Adjoint(self, expr):
         mat = expr.arg
         pform = self._print(mat)
         if self._use_unicode:
-            dag = prettyForm(pretty_atom('Dagger'))
+            dag = prettyForm('\N{DAGGER}')
         else:
             dag = prettyForm('+')
         from sympy.matrices import MatrixSymbol, BlockMatrix
@@ -912,19 +912,19 @@ def _print_MatMul(self, expr):
 
     def _print_Identity(self, expr):
         if self._use_unicode:
-            return prettyForm(pretty_atom('IdentityMatrix'))
+            return prettyForm('\N{MATHEMATICAL DOUBLE-STRUCK CAPITAL I}')
         else:
             return prettyForm('I')
 
     def _print_ZeroMatrix(self, expr):
         if self._use_unicode:
-            return prettyForm(pretty_atom('ZeroMatrix'))
+            return prettyForm('\N{MATHEMATICAL DOUBLE-STRUCK DIGIT ZERO}')
         else:
             return prettyForm('0')
 
     def _print_OneMatrix(self, expr):
         if self._use_unicode:
-            return prettyForm(pretty_atom("OneMatrix"))
+            return prettyForm('\N{MATHEMATICAL DOUBLE-STRUCK DIGIT ONE}')
         else:
             return prettyForm('1')
 
@@ -974,7 +974,7 @@ def _print_KroneckerProduct(self, expr):
         from sympy.matrices.expressions.matadd import MatAdd
         from sympy.matrices.expressions.matmul import MatMul
         if self._use_unicode:
-            delim = f" {pretty_atom('TensorProduct')} "
+            delim = ' \N{N-ARY CIRCLED TIMES OPERATOR} '
         else:
             delim = ' x '
         return self._print_seq(expr.args, None, None, delim,
@@ -1166,23 +1166,23 @@ def _print_BasisDependent(self, expr):
             if '\n' in partstr:
                 tempstr = partstr
                 tempstr = tempstr.replace(vectstrs[i], '')
-                if xobj(')_ext', 1) in tempstr:   # If scalar is a fraction
+                if '\N{RIGHT PARENTHESIS EXTENSION}' in tempstr:   # If scalar is a fraction
                     for paren in range(len(tempstr)):
                         flag[i] = 1
-                        if tempstr[paren] == xobj(')_ext', 1) and tempstr[paren + 1] == '\n':
+                        if tempstr[paren] == '\N{RIGHT PARENTHESIS EXTENSION}' and tempstr[paren + 1] == '\n':
                             # We want to place the vector string after all the right parentheses, because
                             # otherwise, the vector will be in the middle of the string
-                            tempstr = tempstr[:paren] + xobj(')_ext', 1)\
+                            tempstr = tempstr[:paren] + '\N{RIGHT PARENTHESIS EXTENSION}'\
                                          + ' '  + vectstrs[i] + tempstr[paren + 1:]
                             break
-                elif xobj(')_lower_hook', 1) in tempstr:
+                elif '\N{RIGHT PARENTHESIS LOWER HOOK}' in tempstr:
                     # We want to place the vector string after all the right parentheses, because
                     # otherwise, the vector will be in the middle of the string. For this reason,
                     # we insert the vector string at the rightmost index.
-                    index = tempstr.rfind(xobj(')_lower_hook', 1))
+                    index = tempstr.rfind('\N{RIGHT PARENTHESIS LOWER HOOK}')
                     if index != -1: # then this character was found in this string
                         flag[i] = 1
-                        tempstr = tempstr[:index] + xobj(')_lower_hook', 1)\
+                        tempstr = tempstr[:index] + '\N{RIGHT PARENTHESIS LOWER HOOK}'\
                                      + ' '  + vectstrs[i] + tempstr[index + 1:]
                 o1[i] = tempstr
 
@@ -1730,7 +1730,7 @@ def _print_Lambda(self, e):
         expr = e.expr
         sig = e.signature
         if self._use_unicode:
-            arrow = f" {pretty_atom('ArrowFromBar')} "
+            arrow = " \N{RIGHTWARDS ARROW FROM BAR} "
         else:
             arrow = " -> "
         if len(sig) == 1 and sig[0].is_symbol:
@@ -1749,7 +1749,7 @@ def _print_Order(self, expr):
             elif len(expr.variables):
                 pform = prettyForm(*pform.right(self._print(expr.variables[0])))
             if self._use_unicode:
-                pform = prettyForm(*pform.right(f" {pretty_atom('Arrow')} "))
+                pform = prettyForm(*pform.right(" \N{RIGHTWARDS ARROW} "))
             else:
                 pform = prettyForm(*pform.right(" -> "))
             if len(expr.point) > 1:
@@ -2042,7 +2042,7 @@ def _print_nth_root(self, base, root):
             and root == 2 and bpretty.height() == 1
             and (bpretty.width() == 1
                  or (base.is_Integer and base.is_nonnegative))):
-            return prettyForm(*bpretty.left(nth_root[2]))
+            return prettyForm(*bpretty.left('\N{SQUARE ROOT}'))
 
         # Construct root sign, start with the \/ shape
         _zZ = xobj('/', 1)
@@ -2137,7 +2137,7 @@ def _print_ProductSet(self, p):
         if len(p.sets) >= 1 and not has_variety(p.sets):
             return self._print(p.sets[0]) ** self._print(len(p.sets))
         else:
-            prod_char = pretty_atom('Multiplication') if self._use_unicode else 'x'
+            prod_char = "\N{MULTIPLICATION SIGN}" if self._use_unicode else 'x'
             return self._print_seq(p.sets, None, None, ' %s ' % prod_char,
                                    parenthesize=lambda set: set.is_Union or
                                    set.is_Intersection or set.is_ProductSet)
@@ -2149,7 +2149,7 @@ def _print_FiniteSet(self, s):
     def _print_Range(self, s):
 
         if self._use_unicode:
-            dots = pretty_atom('Dots')
+            dots = "\N{HORIZONTAL ELLIPSIS}"
         else:
             dots = '...'
 
@@ -2228,7 +2228,7 @@ def _print_Complement(self, u):
 
     def _print_ImageSet(self, ts):
         if self._use_unicode:
-            inn = pretty_atom("SmallElementOf")
+            inn = "\N{SMALL ELEMENT OF}"
         else:
             inn = 'in'
         fun = ts.lamda
@@ -2257,10 +2257,10 @@ def _print_ImageSet(self, ts):
 
     def _print_ConditionSet(self, ts):
         if self._use_unicode:
-            inn = pretty_atom('SmallElementOf')
+            inn = "\N{SMALL ELEMENT OF}"
             # using _and because and is a keyword and it is bad practice to
             # overwrite them
-            _and = pretty_atom('And')
+            _and = "\N{LOGICAL AND}"
         else:
             inn = 'in'
             _and = 'and'
@@ -2288,7 +2288,7 @@ def _print_ConditionSet(self, ts):
 
     def _print_ComplexRegion(self, ts):
         if self._use_unicode:
-            inn = pretty_atom('SmallElementOf')
+            inn = "\N{SMALL ELEMENT OF}"
         else:
             inn = 'in'
         variables = self._print_seq(ts.variables)
@@ -2303,7 +2303,7 @@ def _print_ComplexRegion(self, ts):
     def _print_Contains(self, e):
         var, set = e.args
         if self._use_unicode:
-            el = f" {pretty_atom('ElementOf')} "
+            el = " \N{ELEMENT OF} "
             return prettyForm(*stringPict.next(self._print(var),
                                                el, self._print(set)), binding=8)
         else:
@@ -2313,7 +2313,7 @@ def _print_FourierSeries(self, s):
         if s.an.formula is S.Zero and s.bn.formula is S.Zero:
             return self._print(s.a0)
         if self._use_unicode:
-            dots = pretty_atom('Dots')
+            dots = "\N{HORIZONTAL ELLIPSIS}"
         else:
             dots = '...'
         return self._print_Add(s.truncate()) + self._print(dots)
@@ -2328,7 +2328,7 @@ def _print_SetExpr(self, se):
 
     def _print_SeqFormula(self, s):
         if self._use_unicode:
-            dots = pretty_atom('Dots')
+            dots = "\N{HORIZONTAL ELLIPSIS}"
         else:
             dots = '...'
 
@@ -2435,7 +2435,7 @@ def _print_frozenset(self, s):
 
     def _print_UniversalSet(self, s):
         if self._use_unicode:
-            return prettyForm(pretty_atom('Universe'))
+            return prettyForm("\N{MATHEMATICAL DOUBLE-STRUCK CAPITAL U}")
         else:
             return prettyForm('UniversalSet')
 
@@ -2479,7 +2479,7 @@ def _print_RootSum(self, expr):
 
     def _print_FiniteField(self, expr):
         if self._use_unicode:
-            form = f"{pretty_atom('Integers')}_%d"
+            form = '\N{DOUBLE-STRUCK CAPITAL Z}_%d'
         else:
             form = 'GF(%d)'
 
@@ -2487,19 +2487,19 @@ def _print_FiniteField(self, expr):
 
     def _print_IntegerRing(self, expr):
         if self._use_unicode:
-            return prettyForm(pretty_atom('Integers'))
+            return prettyForm('\N{DOUBLE-STRUCK CAPITAL Z}')
         else:
             return prettyForm('ZZ')
 
     def _print_RationalField(self, expr):
         if self._use_unicode:
-            return prettyForm(pretty_atom('Rationals'))
+            return prettyForm('\N{DOUBLE-STRUCK CAPITAL Q}')
         else:
             return prettyForm('QQ')
 
     def _print_RealField(self, domain):
         if self._use_unicode:
-            prefix = pretty_atom("Reals")
+            prefix = '\N{DOUBLE-STRUCK CAPITAL R}'
         else:
             prefix = 'RR'
 
@@ -2510,7 +2510,7 @@ def _print_RealField(self, domain):
 
     def _print_ComplexField(self, domain):
         if self._use_unicode:
-            prefix = pretty_atom('Complexes')
+            prefix = '\N{DOUBLE-STRUCK CAPITAL C}'
         else:
             prefix = 'CC'
 
@@ -2630,7 +2630,7 @@ def _print_tribonacci(self, e):
 
     def _print_stieltjes(self, e):
         if self._use_unicode:
-            return self._print_number_function(e, greek_unicode['gamma'])
+            return self._print_number_function(e, '\N{GREEK SMALL LETTER GAMMA}')
         else:
             return self._print_number_function(e, "stieltjes")
 
@@ -2792,7 +2792,7 @@ def _print_BaseVectorField(self, field):
 
     def _print_Differential(self, diff):
         if self._use_unicode:
-            d = pretty_atom('Differential')
+            d = '\N{DOUBLE-STRUCK ITALIC SMALL D}'
         else:
             d = 'd'
         field = diff._form_field
@@ -2831,10 +2831,7 @@ def _print_primeomega(self, e):
 
     def _print_Quantity(self, e):
         if e.name.name == 'degree':
-            if self._use_unicode:
-                pform = self._print(pretty_atom('Degree'))
-            else:
-                pform = self._print(chr(176))
+            pform = self._print("\N{DEGREE SIGN}")
             return pform
         else:
             return self.emptyPrinter(e)
diff --git a/sympy/printing/pretty/pretty_symbology.py b/sympy/printing/pretty/pretty_symbology.py
index d12fff7267..2b0f54e16b 100644
--- a/sympy/printing/pretty/pretty_symbology.py
+++ b/sympy/printing/pretty/pretty_symbology.py
@@ -243,38 +243,30 @@ def xstr(*args):
 _xobj_unicode = {
 
     # vertical symbols
-    #                       (( ext, top, bot, mid ), c1)
-    '(':                    (( EXT('('), HUP('('), HLO('(') ), '('),
-    ')':                    (( EXT(')'), HUP(')'), HLO(')') ), ')'),
-    '[':                    (( EXT('['), CUP('['), CLO('[') ), '['),
-    ']':                    (( EXT(']'), CUP(']'), CLO(']') ), ']'),
-    '{':                    (( EXT('{}'), HUP('{'), HLO('{'), MID('{') ), '{'),
-    '}':                    (( EXT('{}'), HUP('}'), HLO('}'), MID('}') ), '}'),
-    '|':                    U('BOX DRAWINGS LIGHT VERTICAL'),
-    'Tee':                  U('BOX DRAWINGS LIGHT UP AND HORIZONTAL'),
-    'UpTack':               U('BOX DRAWINGS LIGHT DOWN AND HORIZONTAL'),
-    'corner_up_centre'
-    '(_ext':                U('LEFT PARENTHESIS EXTENSION'),
-    ')_ext':                U('RIGHT PARENTHESIS EXTENSION'),
-    '(_lower_hook':         U('LEFT PARENTHESIS LOWER HOOK'),
-    ')_lower_hook':         U('RIGHT PARENTHESIS LOWER HOOK'),
-    '(_upper_hook':         U('LEFT PARENTHESIS UPPER HOOK'),
-    ')_upper_hook':         U('RIGHT PARENTHESIS UPPER HOOK'),
-    '<':                  ((U('BOX DRAWINGS LIGHT VERTICAL'),
-                            U('BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT'),
-                            U('BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT')), '<'),
-
-    '>':                  ((U('BOX DRAWINGS LIGHT VERTICAL'),
-                            U('BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT'),
-                            U('BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT')), '>'),
-
-    'lfloor':               (( EXT('['), EXT('['), CLO('[') ), U('LEFT FLOOR')),
-    'rfloor':               (( EXT(']'), EXT(']'), CLO(']') ), U('RIGHT FLOOR')),
-    'lceil':                (( EXT('['), CUP('['), EXT('[') ), U('LEFT CEILING')),
-    'rceil':                (( EXT(']'), CUP(']'), EXT(']') ), U('RIGHT CEILING')),
-
-    'int':                  (( EXT('int'), U('TOP HALF INTEGRAL'), U('BOTTOM HALF INTEGRAL') ), U('INTEGRAL')),
-    'sum':                  (( U('BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT'), '_', U('OVERLINE'), U('BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT')), U('N-ARY SUMMATION')),
+    #       (( ext, top, bot, mid ), c1)
+    '(':    (( EXT('('), HUP('('), HLO('(') ), '('),
+    ')':    (( EXT(')'), HUP(')'), HLO(')') ), ')'),
+    '[':    (( EXT('['), CUP('['), CLO('[') ), '['),
+    ']':    (( EXT(']'), CUP(']'), CLO(']') ), ']'),
+    '{':    (( EXT('{}'), HUP('{'), HLO('{'), MID('{') ), '{'),
+    '}':    (( EXT('{}'), HUP('}'), HLO('}'), MID('}') ), '}'),
+    '|':    U('BOX DRAWINGS LIGHT VERTICAL'),
+
+    '<':    ((U('BOX DRAWINGS LIGHT VERTICAL'),
+              U('BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT'),
+              U('BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT')), '<'),
+
+    '>':    ((U('BOX DRAWINGS LIGHT VERTICAL'),
+              U('BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT'),
+              U('BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT')), '>'),
+
+    'lfloor': (( EXT('['), EXT('['), CLO('[') ), U('LEFT FLOOR')),
+    'rfloor': (( EXT(']'), EXT(']'), CLO(']') ), U('RIGHT FLOOR')),
+    'lceil':  (( EXT('['), CUP('['), EXT('[') ), U('LEFT CEILING')),
+    'rceil':  (( EXT(']'), CUP(']'), EXT(']') ), U('RIGHT CEILING')),
+
+    'int':  (( EXT('int'), U('TOP HALF INTEGRAL'), U('BOTTOM HALF INTEGRAL') ), U('INTEGRAL')),
+    'sum':  (( U('BOX DRAWINGS LIGHT DIAGONAL UPPER LEFT TO LOWER RIGHT'), '_', U('OVERLINE'), U('BOX DRAWINGS LIGHT DIAGONAL UPPER RIGHT TO LOWER LEFT')), U('N-ARY SUMMATION')),
 
     # horizontal objects
     #'-':   '-',
@@ -488,49 +480,19 @@ def xsym(sym):
     'ImaginaryUnit':           U('DOUBLE-STRUCK ITALIC SMALL I'),
     'EmptySet':                U('EMPTY SET'),
     'Naturals':                U('DOUBLE-STRUCK CAPITAL N'),
-    'Naturals0':              (U('DOUBLE-STRUCK CAPITAL N') and
-                              (U('DOUBLE-STRUCK CAPITAL N') +
-                               U('SUBSCRIPT ZERO'))),
+    'Naturals0':               (U('DOUBLE-STRUCK CAPITAL N') and
+                                (U('DOUBLE-STRUCK CAPITAL N') +
+                                 U('SUBSCRIPT ZERO'))),
     'Integers':                U('DOUBLE-STRUCK CAPITAL Z'),
     'Rationals':               U('DOUBLE-STRUCK CAPITAL Q'),
     'Reals':                   U('DOUBLE-STRUCK CAPITAL R'),
     'Complexes':               U('DOUBLE-STRUCK CAPITAL C'),
-    'Universe':                U('MATHEMATICAL DOUBLE-STRUCK CAPITAL U'),
-    'IdentityMatrix':          U('MATHEMATICAL DOUBLE-STRUCK CAPITAL I'),
-    'ZeroMatrix':              U('MATHEMATICAL DOUBLE-STRUCK DIGIT ZERO'),
-    'OneMatrix':               U('MATHEMATICAL DOUBLE-STRUCK DIGIT ONE'),
-    'Differential':            U('DOUBLE-STRUCK ITALIC SMALL D'),
     'Union':                   U('UNION'),
-    'ElementOf':               U('ELEMENT OF'),
-    'SmallElementOf':          U('SMALL ELEMENT OF'),
     'SymmetricDifference':     U('INCREMENT'),
     'Intersection':            U('INTERSECTION'),
     'Ring':                    U('RING OPERATOR'),
-    'Multiplication':          U('MULTIPLICATION SIGN'),
-    'TensorProduct':           U('N-ARY CIRCLED TIMES OPERATOR'),
-    'Dots':                    U('HORIZONTAL ELLIPSIS'),
     'Modifier Letter Low Ring':U('Modifier Letter Low Ring'),
     'EmptySequence':           'EmptySequence',
-    'SuperscriptPlus':         U('SUPERSCRIPT PLUS SIGN'),
-    'SuperscriptMinus':        U('SUPERSCRIPT MINUS'),
-    'Dagger':                  U('DAGGER'),
-    'Degree':                  U('DEGREE SIGN'),
-    #Logic Symbols
-    'And':                     U('LOGICAL AND'),
-    'Or':                      U('LOGICAL OR'),
-    'Not':                     U('NOT SIGN'),
-    'Nor':                     U('NOR'),
-    'Nand':                    U('NAND'),
-    'Xor':                     U('XOR'),
-    'Equiv':                   U('LEFT RIGHT DOUBLE ARROW'),
-    'NotEquiv':                U('LEFT RIGHT DOUBLE ARROW WITH STROKE'),
-    'Implies':                 U('LEFT RIGHT DOUBLE ARROW'),
-    'NotImplies':              U('LEFT RIGHT DOUBLE ARROW WITH STROKE'),
-    'Arrow':                   U('RIGHTWARDS ARROW'),
-    'ArrowFromBar':            U('RIGHTWARDS ARROW FROM BAR'),
-    'NotArrow':                U('RIGHTWARDS ARROW WITH STROKE'),
-    'Tautology':               U('BOX DRAWINGS LIGHT UP AND HORIZONTAL'),
-    'Contradiction':           U('BOX DRAWINGS LIGHT DOWN AND HORIZONTAL')
 }
 
 
diff --git a/sympy/series/series.py b/sympy/series/series.py
index e9feec7d3b..b355bf430b 100644
--- a/sympy/series/series.py
+++ b/sympy/series/series.py
@@ -22,7 +22,7 @@ def series(expr, x=None, x0=0, n=6, dir="+"):
 
     dir : String, optional
           The series-expansion can be bi-directional. If ``dir="+"``,
-          then (x->x0+). If ``dir="-"``, then (x->x0-). For infinite
+          then (x->x0+). If ``dir="-", then (x->x0-). For infinite
           ``x0`` (``oo`` or ``-oo``), the ``dir`` argument is determined
           from the direction of the infinity (i.e., ``dir="-"`` for
           ``oo``).
diff --git a/sympy/simplify/radsimp.py b/sympy/simplify/radsimp.py
index 1cfd5d5f06..8c1fe8d5c3 100644
--- a/sympy/simplify/radsimp.py
+++ b/sympy/simplify/radsimp.py
@@ -1074,7 +1074,7 @@ def fraction(expr, exact=False):
        (x, y**(-k))
 
        If we know nothing about sign of some exponent and ``exact``
-       flag is unset, then structure this exponent's structure will
+       flag is unset, then the exponent's structure will
        be analyzed and pretty fraction will be returned:
 
        >>> from sympy import exp, Mul
@@ -1116,7 +1116,7 @@ def fraction(expr, exact=False):
             elif ex.is_positive:
                 numer.append(term)
             elif not exact and ex.is_Mul:
-                n, d = term.as_numer_denom()
+                n, d = term.as_numer_denom()  # this will cause evaluation
                 if n != 1:
                     numer.append(n)
                 denom.append(d)
@@ -1131,12 +1131,12 @@ def fraction(expr, exact=False):
     return Mul(*numer, evaluate=not exact), Mul(*denom, evaluate=not exact)
 
 
-def numer(expr):
-    return fraction(expr)[0]
+def numer(expr, exact=False):  # default matches fraction's default
+    return fraction(expr, exact=exact)[0]
 
 
-def denom(expr):
-    return fraction(expr)[1]
+def denom(expr, exact=False):  # default matches fraction's default
+    return fraction(expr, exact=exact)[1]
 
 
 def fraction_expand(expr, **hints):
@@ -1144,12 +1144,14 @@ def fraction_expand(expr, **hints):
 
 
 def numer_expand(expr, **hints):
-    a, b = fraction(expr)
+    # default matches fraction's default
+    a, b = fraction(expr, exact=hints.get('exact', False))
     return a.expand(numer=True, **hints) / b
 
 
 def denom_expand(expr, **hints):
-    a, b = fraction(expr)
+    # default matches fraction's default
+    a, b = fraction(expr, exact=hints.get('exact', False))
     return a / b.expand(denom=True, **hints)
 
 
diff --git a/sympy/simplify/simplify.py b/sympy/simplify/simplify.py
index b627be8c91..82466cdc24 100644
--- a/sympy/simplify/simplify.py
+++ b/sympy/simplify/simplify.py
@@ -1214,7 +1214,7 @@ def besselsimp(expr):
     works on the Bessel J and I functions, however. It works by looking at all
     such functions in turn, and eliminating factors of "I" and "-1" (actually
     their polar equivalents) in front of the argument. Then, functions of
-    half-integer order are rewritten using strigonometric functions and
+    half-integer order are rewritten using trigonometric functions and
     functions of integer order (> 1) are rewritten using functions
     of low order.  Finally, if the expression was changed, compute
     factorization of the result with factor().
diff --git a/sympy/solvers/diophantine/diophantine.py b/sympy/solvers/diophantine/diophantine.py
index e9870ae5f6..7b2a408dc4 100644
--- a/sympy/solvers/diophantine/diophantine.py
+++ b/sympy/solvers/diophantine/diophantine.py
@@ -21,7 +21,6 @@
 from sympy.ntheory.factor_ import divisors, factorint, perfect_power
 from sympy.ntheory.generate import nextprime
 from sympy.ntheory.primetest import is_square, isprime
-from sympy.ntheory.modular import symmetric_residue
 from sympy.ntheory.residue_ntheory import sqrt_mod, sqrt_mod_iter
 from sympy.polys.polyerrors import GeneratorsNeeded
 from sympy.polys.polytools import Poly, factor_list
@@ -2032,41 +2031,92 @@ def diop_DN(D, N, t=symbols("t", integer=True)):
     if N == 0:
         return [(0, 0)]
 
-    sol = []
     if abs(N) == 1:
         pqa = PQa(0, 1, D)
-        *_, prev_B, prev_G = next(pqa)
-        for j, (*_, a, _, _B, _G) in enumerate(pqa):
-            if a == 2*sD:
+        j = 0
+        G = []
+        B = []
+
+        for i in pqa:
+
+            a = i[2]
+            G.append(i[5])
+            B.append(i[4])
+
+            if j != 0 and a == 2*sD:
                 break
-            prev_B, prev_G = _B, _G
-        if j % 2:
+            j = j + 1
+
+        if _odd(j):
+
+            if N == -1:
+                x = G[j - 1]
+                y = B[j - 1]
+            else:
+                count = j
+                while count < 2*j - 1:
+                    i = next(pqa)
+                    G.append(i[5])
+                    B.append(i[4])
+                    count += 1
+
+                x = G[count]
+                y = B[count]
+        else:
             if N == 1:
-                sol.append((prev_G, prev_B))
-            return sol
-        if N == -1:
-            return [(prev_G, prev_B)]
-        for _ in range(j):
-            *_, _B, _G = next(pqa)
-        return [(_G, _B)]
-
-    for f in divisors(square_factor(N), generator=True):
+                x = G[j - 1]
+                y = B[j - 1]
+            else:
+                return []
+
+        return [(x, y)]
+
+    fs = []
+    sol = []
+    div = divisors(N)
+
+    for d in div:
+        if divisible(N, d**2):
+            fs.append(d)
+
+    for f in fs:
         m = N // f**2
-        am = abs(m)
-        for sqm in sqrt_mod(D, am, all_roots=True):
-            z = symmetric_residue(sqm, am)
-            pqa = PQa(z, am, D)
-            *_, prev_B, prev_G = next(pqa)
-            for _ in range(length(z, am, D) - 1):
-                _, q, *_, _B, _G = next(pqa)
-                if abs(q) == 1:
-                    if prev_G**2 - D*prev_B**2 == m:
-                        sol.append((f*prev_G, f*prev_B))
-                    elif a := diop_DN(D, -1):
-                        sol.append((f*(prev_G*a[0][0] + prev_B*D*a[0][1]),
-                                    f*(prev_G*a[0][1] + prev_B*a[0][0])))
+
+        zs = sqrt_mod(D, abs(m), all_roots=True)
+        zs = [i for i in zs if i <= abs(m) // 2 ]
+
+        if abs(m) != 2:
+            zs = zs + [-i for i in zs if i]  # omit dupl 0
+
+        for z in zs:
+
+            pqa = PQa(z, abs(m), D)
+            j = 0
+            G = []
+            B = []
+
+            for i in pqa:
+
+                G.append(i[5])
+                B.append(i[4])
+
+                if j != 0 and abs(i[1]) == 1:
+                    r = G[j-1]
+                    s = B[j-1]
+
+                    if r**2 - D*s**2 == m:
+                        sol.append((f*r, f*s))
+
+                    elif diop_DN(D, -1) != []:
+                        a = diop_DN(D, -1)
+                        sol.append((f*(r*a[0][0] + a[0][1]*s*D), f*(r*a[0][1] + s*a[0][0])))
+
                     break
-                prev_B, prev_G = _B, _G
+
+                j = j + 1
+                if j == length(z, abs(m), D):
+                    break
+
     return sol
 
 
diff --git a/sympy/solvers/solvers.py b/sympy/solvers/solvers.py
index de8be8b9ff..4f761ee4f6 100644
--- a/sympy/solvers/solvers.py
+++ b/sympy/solvers/solvers.py
@@ -1417,15 +1417,8 @@ def _solve(f, *symbols, **flags):
         result = set()
         if any(e.is_zero for e, c in f.args):
             f = f.simplify()  # failure imminent w/o help
-
-        cond = neg = True
-        for i, (expr, cnd) in enumerate(f.args):
-            # the explicit condition for this expr is the current cond
-            # and none of the previous conditions
-            cond = And(neg, cnd)
-            neg = And(neg, ~cond)
-
-            if expr.is_zero and cond.simplify() != False:
+        for i, (expr, cond) in enumerate(f.args):
+            if expr.is_zero:
                 raise NotImplementedError(filldedent('''
                     An expression is already zero when %s.
                     This means that in this *region* the solution
@@ -1434,7 +1427,10 @@ def _solve(f, *symbols, **flags):
                     interval it might be resolved with simplification
                     of the Piecewise conditions.''' % cond))
             candidates = _vsolve(expr, symbol, **flags)
-
+            # the explicit condition for this expr is the current cond
+            # and none of the previous conditions
+            args = [~c for _, c in f.args[:i]] + [cond]
+            cond = And(*args)
             for candidate in candidates:
                 if candidate in result:
                     # an unconditional value was already there


Test patch:
diff --git a/sympy/core/tests/test_expand.py b/sympy/core/tests/test_expand.py
index 6c9ed4aa99..e7abb5daac 100644
--- a/sympy/core/tests/test_expand.py
+++ b/sympy/core/tests/test_expand.py
@@ -137,6 +137,13 @@ def test_expand_frac():
         y*(x + y)/(x**2 + x)
     eq = (x + 1)**2/y
     assert expand_numer(eq, multinomial=False) == eq
+    # issue 26329
+    eq = (exp(x*z) - exp(y*z))/exp(z*(x + y))
+    ans = exp(-y*z) - exp(-x*z)
+    assert eq.expand(numer=True) != ans
+    assert eq.expand(numer=True, exact=True) == ans
+    assert expand_numer(eq) != ans
+    assert expand_numer(eq, exact=True) == ans
 
 
 def test_issue_6121():
@@ -245,7 +252,7 @@ def test_expand_mul():
     e = Mul(2, 3, evaluate=False)
     assert e.expand() == 6
 
-    e = Mul(2, 3, 1/x, evaluate = False)
+    e = Mul(2, 3, 1/x, evaluate=False)
     assert e.expand() == 6/x
     e = Mul(2, R(1, 3), evaluate=False)
     assert e.expand() == R(2, 3)
diff --git a/sympy/logic/tests/test_inference.py b/sympy/logic/tests/test_inference.py
index 2b6f49224d..eaae05e2f9 100644
--- a/sympy/logic/tests/test_inference.py
+++ b/sympy/logic/tests/test_inference.py
@@ -332,10 +332,7 @@ def test_z3():
     x, y, z = symbols('x,y,z')
     assert z3_satisfiable((x >= 2) & (x < 1)) is False
     assert z3_satisfiable( A & ~A ) is False
-
-    model = z3_satisfiable(A & (~A | B | C))
-    assert bool(model) is True
-    assert model[A] is True
+    assert z3_satisfiable(A & (~A | B | C)) is True
 
     # test nonlinear function
     assert z3_satisfiable((x ** 2 >= 2) & (x < 1) & (x > -1)) is False
diff --git a/sympy/physics/continuum_mechanics/tests/test_beam.py b/sympy/physics/continuum_mechanics/tests/test_beam.py
index 7891a2a8cf..3ee6b044b4 100644
--- a/sympy/physics/continuum_mechanics/tests/test_beam.py
+++ b/sympy/physics/continuum_mechanics/tests/test_beam.py
@@ -514,9 +514,7 @@ def test_max_shear_force():
     b.apply_load(R2, l, -1)
     b.apply_load(P, 0, 0, end=l)
     b.solve_for_reaction_loads(R1, R2)
-    max_shear = b.max_shear_force()
-    assert max_shear[0] == 0
-    assert simplify(max_shear[1] - (l*Abs(P)/2)) == 0
+    assert b.max_shear_force() == (0, l*Abs(P)/2)
 
 
 def test_max_bmoment():
diff --git a/sympy/printing/tests/test_latex.py b/sympy/printing/tests/test_latex.py
index 1000e9b412..e8b4c5f757 100644
--- a/sympy/printing/tests/test_latex.py
+++ b/sympy/printing/tests/test_latex.py
@@ -2115,13 +2115,6 @@ def test_Adjoint():
     Mx = MatrixSymbol('M^x', 2, 2)
     assert latex(Adjoint(Mx)) == r'\left(M^{x}\right)^{\dagger}'
 
-    # adjoint style
-    assert latex(Adjoint(X), adjoint_style="star") == r'X^{\ast}'
-    assert latex(Adjoint(X + Y), adjoint_style="hermitian") == r'\left(X + Y\right)^{\mathsf{H}}'
-    assert latex(Adjoint(X) + Adjoint(Y), adjoint_style="dagger") == r'X^{\dagger} + Y^{\dagger}'
-    assert latex(Adjoint(Y)*Adjoint(X)) == r'Y^{\dagger} X^{\dagger}'
-    assert latex(Adjoint(X**2), adjoint_style="star") == r'\left(X^{2}\right)^{\ast}'
-    assert latex(Adjoint(X)**2, adjoint_style="hermitian") == r'\left(X^{\mathsf{H}}\right)^{2}'
 
 def test_Transpose():
     from sympy.matrices import Transpose, MatPow, HadamardPower