diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
index 5d702d09a..0f5845f97 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -51,7 +51,7 @@ If this is too long, then try narrowing the problem to something short.
 
 ## Your Environment
 
-<!-- _This information can be helpful..
+<!-- _This information can be helpful...
 
 **All: Mathics version, Installed Python Python packages.
 
diff --git a/.github/workflows/consistency-checks.yml b/.github/workflows/consistency-checks.yml
index 0cbf4dc4c..e2ac8212b 100644
--- a/.github/workflows/consistency-checks.yml
+++ b/.github/workflows/consistency-checks.yml
@@ -23,7 +23,7 @@ jobs:
         sudo apt update -qq && sudo apt install llvm-dev remake
         python -m pip install --upgrade pip
         # We can comment out after next Mathics-Scanner release
-        # python -m pip install -e git+https://github.com/Mathics3/mathics-scanner#egg=Mathics-Scanner[full]
+        python -m pip install -e git+https://github.com/Mathics3/mathics-scanner#egg=Mathics-Scanner[full]
         git clone https://github.com/Mathics3/mathics-scanner.git
         cd mathics-scanner/
         pip install -e .
diff --git a/.github/workflows/macos.yml b/.github/workflows/macos.yml
index d55c82980..c5fb49e44 100644
--- a/.github/workflows/macos.yml
+++ b/.github/workflows/macos.yml
@@ -15,7 +15,7 @@ jobs:
     strategy:
       matrix:
         os: [macOS]
-        python-version: ['3.9', '3.10']
+        python-version: ['3.10', '3.11']
     steps:
     - uses: actions/checkout@v4
     - name: Set up Python ${{ matrix.python-version }}
diff --git a/.github/workflows/mypy.yml b/.github/workflows/mypy.yml
index 54cbcd302..ba593df16 100644
--- a/.github/workflows/mypy.yml
+++ b/.github/workflows/mypy.yml
@@ -23,7 +23,7 @@ jobs:
         sudo apt update -qq && sudo apt install llvm-dev remake
         python -m pip install --upgrade pip
         # We can comment out after next Mathics-Scanner release
-        # python -m pip install -e git+https://github.com/Mathics3/mathics-scanner#egg=Mathics-Scanner[full]
+        python -m pip install -e git+https://github.com/Mathics3/mathics-scanner#egg=Mathics-Scanner[full]
         git clone https://github.com/Mathics3/mathics-scanner.git
         cd mathics-scanner/
         pip install -e .
diff --git a/.github/workflows/ubuntu-cython.yml b/.github/workflows/ubuntu-cython.yml
index 2d0051dc4..433a0d562 100644
--- a/.github/workflows/ubuntu-cython.yml
+++ b/.github/workflows/ubuntu-cython.yml
@@ -25,13 +25,12 @@ jobs:
         sudo apt-get update -qq && sudo apt-get install -qq liblapack-dev llvm-dev tesseract-ocr
         python -m pip install --upgrade pip
         # We can comment out after next Mathics-Scanner release
-        # python -m pip install -e git+https://github.com/Mathics3/mathics-scanner#egg=Mathics-Scanner[full]
+        python -m pip install -e git+https://github.com/Mathics3/mathics-scanner#egg=Mathics-Scanner[full]
         git clone https://github.com/Mathics3/mathics-scanner.git
         cd mathics-scanner/
         pip install -e .
         cd ..
 
-        # python -m pip install Mathics-Scanner[full]
     - name: Install Mathics with full dependencies
       run: |
         make develop-full-cython
diff --git a/.github/workflows/ubuntu.yml b/.github/workflows/ubuntu.yml
index 38cbf6fc7..35bdd7b29 100644
--- a/.github/workflows/ubuntu.yml
+++ b/.github/workflows/ubuntu.yml
@@ -29,6 +29,7 @@ jobs:
         git clone https://github.com/Mathics3/mathics-scanner.git
         cd mathics-scanner/
         pip install -e .
+        python -m mathics_scanner.generate.build_tables
         cd ..
 
         # python -m pip install Mathics-Scanner[full]
diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml
index ce29e3cfd..f7c86d1bc 100755
--- a/.github/workflows/windows.yml
+++ b/.github/workflows/windows.yml
@@ -34,11 +34,12 @@ jobs:
     - name: Install Mathics3 with Python dependencies
       run: |
         # We can comment out after next Mathics-Scanner release
-        # python -m pip install -e git+https://github.com/Mathics3/mathics-scanner#egg=Mathics-Scanner[full]
+        python -m pip install -e git+https://github.com/Mathics3/mathics-scanner#egg=Mathics-Scanner[full]
 
         git clone https://github.com/Mathics3/mathics-scanner.git
         cd mathics-scanner
         pip install -e .
+        python -m mathics_scanner.generate.build_tables
         cd ..
 
         # python -m pip install Mathics-Scanner[full]
diff --git a/COPYING.txt b/COPYING.txt
index 6c818d8d4..68065d9e8 100644
--- a/COPYING.txt
+++ b/COPYING.txt
@@ -1,28 +1,28 @@
-This file is about the copyright on Mathics and all included components. 
- 
+This file is about the copyright on Mathics3 and all included components.
+
 * ORIGINAL MATHICS CODE:
 
-  All original Mathics code is distributed under the terms of the 
+  All original Mathics code is distributed under the terms of the
   GNU General Public License, version 3.
- 
+
      This code is distributed in the hope that it will be useful,
      but WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      General Public License for more details.
- 
+
 The full text of the GPL is available below in this file. Details of
 the licenses of the components of Mathics are included below as well.
- 
+
 * LICENSES OF INCLUDED DATA:
 
-Mathics includes data from Wikipedia that is published under the Creative 
-Commons Attribution-Sharealike 3.0 Unported License and the GNU Free 
-Documentation License contributed by the respective authors that are listed 
+Mathics includes data from Wikipedia that is published under the Creative
+Commons Attribution-Sharealike 3.0 Unported License and the GNU Free
+Documentation License contributed by the respective authors that are listed
 on the websites specified in "data/elements.txt".
 
 
 * LICENSES OF INCLUDED SOFTWARE:
- 
+
 SOFTWARE                           LICENSE
 ----------------------------------------------
 scripaculous                       MIT
@@ -31,14 +31,14 @@ MathJax                            Apache 2.0
 Three.js                           MIT
 pymimemagic                        BSD 3-Clause
 SciPy                              BSD 3-Clause
- 
+
 CONTACT INFO:
-     Jan Poeschko; jan@poeschko.com; 
+     Jan Poeschko; jan@poeschko.com;
      https://mathics.org/
 
 =========================================================================
- 
- 
+
+
                     GNU GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
 
@@ -713,7 +713,7 @@ may consider it more useful to permit linking proprietary applications with
 the library.  If this is what you want to do, use the GNU Lesser General
 Public License instead of this License.  But first, please read
 <http://www.gnu.org/philosophy/why-not-lgpl.html>.
- 
+
 ================================================================================
 
 scriptaculous:
diff --git a/Makefile b/Makefile
index 41111d2ca..0619c3fc6 100644
--- a/Makefile
+++ b/Makefile
@@ -142,10 +142,9 @@ latexdoc texdoc doc:
 	(cd mathics/doc/latex && $(MAKE) doc)
 
 #: Build JSON ASCII to unicode opcode table and operator table
-mathics/data/op-tables.json mathics/data/operators.json:
+mathics/data/operator-tables.json mathics/data/op-tables.json mathics/data/operators.json:
 	$(BASH) ./admin-tools/make-op-tables.sh
 
-
 #: Remove ChangeLog
 rmChangeLog:
 	$(RM) ChangeLog || true
diff --git a/SYMBOLS_MANIFEST.txt b/SYMBOLS_MANIFEST.txt
index befa0791c..f8cd76064 100644
--- a/SYMBOLS_MANIFEST.txt
+++ b/SYMBOLS_MANIFEST.txt
@@ -134,8 +134,10 @@ System`Automatic
 System`Axes
 System`Axis
 System`Background
+System`Backslash
 System`BarChart
 System`BaseForm
+System`Because
 System`Begin
 System`BeginPackage
 System`BellB
@@ -182,6 +184,8 @@ System`C
 System`CMYKColor
 System`CanberraDistance
 System`Cancel
+System`Cap
+System`CapitalDifferentialD
 System`Cases
 System`Catalan
 System`CatalanNumber
@@ -189,6 +193,7 @@ System`Catch
 System`Catenate
 System`Ceiling
 System`Center
+System`CenterDot
 System`CentralMoment
 System`Character
 System`CharacterRange
@@ -203,6 +208,10 @@ System`ChessboardDistance
 System`Chop
 System`Circle
 System`CircleBox
+System`CircleDot
+System`CircleMinus
+System`CirclePlus
+System`CircleTimes
 System`Clear
 System`ClearAll
 System`ClearAttributes
@@ -215,6 +224,7 @@ System`Coefficient
 System`CoefficientArrays
 System`CoefficientList
 System`Collect
+System`Colon
 System`ColorConvert
 System`ColorData
 System`ColorDataFunction
@@ -239,6 +249,7 @@ System`Condition
 System`ConditionalExpression
 System`Cone
 System`Cone3DBox
+System`Congruent
 System`Conjugate
 System`ConjugateTranspose
 System`Constant
@@ -253,6 +264,7 @@ System`Convert`B64Dump`B64Encode
 System`ConvertersDump`$ExtensionMappings
 System`ConvertersDump`$FormatMappings
 System`CoprimeQ
+System`Coproduct
 System`CopyDirectory
 System`CopyFile
 System`Correlation
@@ -271,6 +283,8 @@ System`Csc
 System`CubeRoot
 System`Cuboid
 System`Cuboid3DBox
+System`Cup
+System`CupCap
 System`Curl
 System`Cyan
 System`Cylinder
@@ -289,6 +303,7 @@ System`Default
 System`DefaultValues
 System`Definition
 System`Degree
+System`Del
 System`Delete
 System`DeleteCases
 System`DeleteDirectory
@@ -302,8 +317,10 @@ System`DesignMatrix
 System`Det
 System`Diagonal
 System`DiagonalMatrix
+System`Diamond
 System`DiamondMatrix
 System`DiceDissimilarity
+System`DifferentialD
 System`DigitCharacter
 System`DigitCount
 System`DigitQ
@@ -332,6 +349,31 @@ System`Do
 System`Dodecahedron
 System`DominantColors
 System`Dot
+System`DotEqual
+System`DoubleDownArrow
+System`DoubleLeftArrow
+System`DoubleLeftRightArrow
+System`DoubleLeftTee
+System`DoubleLongLeftArrow
+System`DoubleLongLeftRightArrow
+System`DoubleLongRightArrow
+System`DoubleRightArrow
+System`DoubleRightTee
+System`DoubleUpArrow
+System`DoubleUpDownArrow
+System`DoubleVerticalBar
+System`DownArrow
+System`DownArrowBar
+System`DownArrowUpArrow
+System`DownLeftRightVector
+System`DownLeftTeeVector
+System`DownLeftVector
+System`DownLeftVectorBar
+System`DownRightTeeVector
+System`DownRightVector
+System`DownRightVectorBar
+System`DownTee
+System`DownTeeArrow
 System`DownValues
 System`Drop
 System`E
@@ -355,6 +397,8 @@ System`EndOfString
 System`EndPackage
 System`Environment
 System`Equal
+System`EqualTilde
+System`Equilibrium
 System`Equivalent
 System`Erf
 System`Erfc
@@ -462,6 +506,12 @@ System`Gray
 System`GrayLevel
 System`Greater
 System`GreaterEqual
+System`GreaterEqualLess
+System`GreaterFullEqual
+System`GreaterGreater
+System`GreaterLess
+System`GreaterSlantEqual
+System`GreaterTilde
 System`Green
 System`Grid
 System`GridBox
@@ -485,6 +535,8 @@ System`HoldForm
 System`HoldPattern
 System`HoldRest
 System`Hue
+System`HumpDownHump
+System`HumpEqual
 System`HypergeometricU
 System`I
 System`Icosahedron
@@ -552,6 +604,8 @@ System`InverseErf
 System`InverseErfc
 System`InverseGudermannian
 System`InverseHaversine
+System`InvisiblePostfixScriptBase
+System`InvisiblePrefixScriptBase
 System`JaccardDissimilarity
 System`JacobiP
 System`JacobiSymbol
@@ -579,12 +633,38 @@ System`Last
 System`LeafCount
 System`LeastSquares
 System`Left
+System`LeftArrow
+System`LeftArrowBar
+System`LeftArrowRightArrow
+System`LeftDownTeeVector
+System`LeftDownVector
+System`LeftDownVectorBar
+System`LeftRightArrow
+System`LeftRightVector
+System`LeftTee
+System`LeftTeeArrow
+System`LeftTeeVector
+System`LeftTriangle
+System`LeftTriangleBar
+System`LeftTriangleEqual
+System`LeftUpDownVector
+System`LeftUpTeeVector
+System`LeftUpVector
+System`LeftUpVectorBar
+System`LeftVector
+System`LeftVectorBar
 System`LegendreP
 System`LegendreQ
 System`Length
 System`LerchPhi
 System`Less
 System`LessEqual
+System`LessEqualGreater
+System`LessFullEqual
+System`LessGreater
+System`LessLess
+System`LessSlantEqual
+System`LessTilde
 System`LetterCharacter
 System`LetterNumber
 System`LetterQ
@@ -625,9 +705,14 @@ System`Log2
 System`LogGamma
 System`LogPlot
 System`LogisticSigmoid
+System`LongLeftArrow
+System`LongLeftRightArrow
+System`LongRightArrow
 System`Longest
 System`Lookup
 System`LowerCaseQ
+System`LowerLeftArrow
+System`LowerRightArrow
 System`LucasL
 System`MachineNumberQ
 System`MachinePrecision
@@ -670,6 +755,7 @@ System`MinFilter
 System`MinimalPolynomial
 System`Minimize
 System`Minus
+System`MinusPlus
 System`Missing
 System`Mod
 System`ModularInverse
@@ -692,6 +778,8 @@ System`Negative
 System`Nest
 System`NestList
 System`NestWhile
+System`NestedGreaterGreater
+System`NestedLessLess
 System`NextPrime
 System`NonAssociative
 System`NonNegative
@@ -703,8 +791,42 @@ System`Norm
 System`Normal
 System`Normalize
 System`Not
+System`NotCongruent
+System`NotCupCap
+System`NotDoubleVerticalBar
+System`NotGreater
+System`NotGreaterEqual
+System`NotGreaterFullEqual
+System`NotGreaterLess
+System`NotGreaterTilde
+System`NotLeftTriangle
+System`NotLeftTriangleEqual
+System`NotLess
+System`NotLessEqual
+System`NotLessFullEqual
+System`NotLessGreater
+System`NotLessTilde
 System`NotListQ
 System`NotOptionQ
+System`NotPrecedes
+System`NotPrecedesSlantEqual
+System`NotPrecedesTilde
+System`NotReverseElement
+System`NotRightTriangle
+System`NotRightTriangleEqual
+System`NotSquareSubsetEqual
+System`NotSquareSupersetEqual
+System`NotSubset
+System`NotSubsetEqual
+System`NotSucceeds
+System`NotSucceedsSlantEqual
+System`NotSucceedsTilde
+System`NotSuperset
+System`NotSupersetEqual
+System`NotTilde
+System`NotTildeEqual
+System`NotTildeFullEqual
+System`NotTildeTilde
 System`Now
 System`Null
 System`NullSpace
@@ -759,6 +881,7 @@ System`PatternsOrderedQ
 System`PauliMatrix
 System`Pause
 System`Permutations
+System`Perpendicular
 System`Pi
 System`Pick
 System`PieChart
@@ -771,6 +894,7 @@ System`Plot3D
 System`PlotPoints
 System`PlotRange
 System`Plus
+System`PlusMinus
 System`Pochhammer
 System`Point
 System`Point3DBox
@@ -796,6 +920,10 @@ System`PreDecrement
 System`PreIncrement
 System`Precedence
 System`PrecedenceForm
+System`Precedes
+System`PrecedesEqual
+System`PrecedesSlantEqual
+System`PrecedesTilde
 System`Precision
 System`Prefix
 System`Prepend
@@ -811,6 +939,8 @@ System`Private`$ContextStack
 System`Product
 System`ProductLog
 System`Projection
+System`Proportion
+System`Proportional
 System`Protect
 System`Protected
 System`PseudoInverse
@@ -880,15 +1010,38 @@ System`ResetDirectory
 System`Rest
 System`Return
 System`Reverse
+System`ReverseElement
+System`ReverseEquilibrium
 System`ReverseSort
+System`ReverseUpEquilibrium
 System`Riffle
 System`Right
+System`RightArrow
+System`RightArrowBar
+System`RightArrowLeftArrow
+System`RightDownTeeVector
+System`RightDownVector
+System`RightDownVectorBar
+System`RightTee
+System`RightTeeArrow
+System`RightTeeVector
+System`RightTriangle
+System`RightTriangleBar
+System`RightTriangleEqual
+System`RightUpDownVector
+System`RightUpTeeVector
+System`RightUpVector
+System`RightUpVectorBar
+System`RightVector
+System`RightVectorBar
 System`RogersTanimotoDissimilarity
 System`Root
+System`RootSum
 System`RotateLeft
 System`RotateRight
 System`RotationTransform
 System`Round
+System`RoundImplies
 System`Row
 System`RowBox
 System`RowReduce
@@ -920,6 +1073,10 @@ System`SetStreamPosition
 System`Share
 System`Sharpen
 System`ShearingTransform
+System`ShortDownArrow
+System`ShortLeftArrow
+System`ShortRightArrow
+System`ShortUpArrow
 System`Shortest
 System`Show
 System`ShowStringCharacters
@@ -934,6 +1091,7 @@ System`Skip
 System`Slot
 System`SlotSequence
 System`Small
+System`SmallCircle
 System`SokalSneathDissimilarity
 System`Solve
 System`Sort
@@ -952,10 +1110,18 @@ System`Split
 System`SplitBy
 System`Sqrt
 System`SqrtBox
+System`Square
+System`SquareIntersection
+System`SquareSubset
+System`SquareSubsetEqual
+System`SquareSuperset
+System`SquareSupersetEqual
+System`SquareUnion
 System`SquaredEuclideanDistance
 System`SquaresR
 System`StandardDeviation
 System`StandardForm
+System`Star
 System`StartOfLine
 System`StartOfString
 System`StieltjesGamma
@@ -992,15 +1158,24 @@ System`SubValues
 System`Subfactorial
 System`Subscript
 System`SubscriptBox
+System`Subset
+System`SubsetEqual
 System`SubsetQ
 System`Subsets
 System`Subsuperscript
 System`SubsuperscriptBox
 System`Subtract
 System`SubtractFrom
+System`Succeeds
+System`SucceedsEqual
+System`SucceedsSlantEqual
+System`SucceedsTilde
+System`SuchThat
 System`Sum
 System`Superscript
 System`SuperscriptBox
+System`Superset
+System`SupersetEqual
 System`Switch
 System`Symbol
 System`SymbolName
@@ -1026,6 +1201,7 @@ System`Tetrahedron
 System`Text
 System`TextData
 System`TextRecognize
+System`Therefore
 System`Thick
 System`Thickness
 System`Thin
@@ -1035,6 +1211,10 @@ System`Threshold
 System`Through
 System`Throw
 System`TicksStyle
+System`Tilde
+System`TildeEqual
+System`TildeFullEqual
+System`TildeTilde
 System`TimeConstrained
 System`TimeRemaining
 System`TimeUsed
@@ -1076,25 +1256,39 @@ System`Unevaluated
 System`UniformPolyhedron
 System`UniformPolyhedron3DBox
 System`Union
+System`UnionPlus
 System`Unique
 System`UnitConvert
 System`UnitVector
 System`Unprotect
 System`UnsameQ
 System`Unset
+System`UpArrow
+System`UpArrowBar
+System`UpArrowDownArrow
+System`UpDownArrow
+System`UpEquilibrium
 System`UpSet
 System`UpSetDelayed
+System`UpTee
+System`UpTeeArrow
 System`UpTo
 System`UpValues
 System`UpperCaseQ
+System`UpperLeftArrow
+System`UpperRightArrow
 System`ValueQ
 System`Values
 System`Variables
 System`Variance
 System`VectorAngle
 System`VectorQ
+System`Vee
 System`Verbatim
+System`VerticalBar
+System`VerticalTilde
 System`WeberE
+System`Wedge
 System`Which
 System`While
 System`White
diff --git a/admin-tools/make-op-tables.sh b/admin-tools/make-op-tables.sh
index 33c54766d..ce3fa01ba 100755
--- a/admin-tools/make-op-tables.sh
+++ b/admin-tools/make-op-tables.sh
@@ -13,3 +13,5 @@ mathics3-generate-json-table \
     --field=operator-to-unicode \
     -o op-tables.json
 mathics3-generate-operator-json-table -o operator-tables.json
+# tokenizer looks for the table in the default place...
+mathics3-generate-operator-json-table
diff --git a/examples/symbolic_logic/gries_schneider/GS1.m b/examples/symbolic_logic/gries_schneider/GS1.m
index 41ec8bb50..c51af83f8 100644
--- a/examples/symbolic_logic/gries_schneider/GS1.m
+++ b/examples/symbolic_logic/gries_schneider/GS1.m
@@ -1,6 +1,7 @@
+(* -*- wolfram -*- *)
 (* ****************************************************************************
 
-    by Brian Beckman. License the same as for mathics.
+    by Brian Beckman. License the same as for Mathics3: GPL3.
 
     Oct 2020
 
diff --git a/mathics/__init__.py b/mathics/__init__.py
index be503c0dc..5f364025a 100644
--- a/mathics/__init__.py
+++ b/mathics/__init__.py
@@ -68,3 +68,26 @@
 This is free software, and you are welcome to redistribute it
 under certain conditions.
 See the documentation for the full license."""
+
+
+def disabled_breakpoint():
+    """
+    This breakpoint handler can be used as a dummy breakpoint
+    handler function which does not stop in Mathics3 when `Breakpoint[]` is
+    called. In effect, it disables, going into a Python breakpoint handler.
+
+    Here is how to set this from inside Mathics3:
+        SetEnvironment["PYTHONBREAKPOINT" -> "mathics.disabled_breakpoint"];
+
+    Or when invoking `mathics` from a POSIX shell:
+
+       PYTHONBREAKPOINT=mathics.disabled_breakpoint mathics # other arguments
+
+    See https://docs.python.org/3/library/functions.html#breakpoint for information on
+    the Python builtin breakpoint() function
+
+    """
+    # Note that we were called. In Django and other front-ends, the
+    # print message below will appear on the console; it might not be user
+    # visible by default.
+    print("Hit disabled breakpoint.")
diff --git a/mathics/builtin/arithfns/basic.py b/mathics/builtin/arithfns/basic.py
index 08da3d38a..bd6dd2d7b 100644
--- a/mathics/builtin/arithfns/basic.py
+++ b/mathics/builtin/arithfns/basic.py
@@ -31,8 +31,8 @@
     A_READ_PROTECTED,
 )
 from mathics.core.builtin import (
-    BinaryOperator,
     Builtin,
+    InfixOperator,
     MPMathFunction,
     PrefixOperator,
     SympyFunction,
@@ -107,7 +107,7 @@ def eval(self, n, evaluation):
         )
 
 
-class Divide(BinaryOperator):
+class Divide(InfixOperator):
     """
     <url>
     :Division:
@@ -219,7 +219,7 @@ def eval_int(self, x: Integer, evaluation):
         return Integer(-x.value)
 
 
-class Plus(BinaryOperator, SympyFunction):
+class Plus(InfixOperator, SympyFunction):
     """
     <url>
     :Addition:
@@ -345,7 +345,7 @@ def eval(self, items, evaluation):
         return eval_Plus(*items_tuple)
 
 
-class Power(BinaryOperator, MPMathFunction):
+class Power(InfixOperator, MPMathFunction):
     """
     <url>
     :Exponentiation:
@@ -525,7 +525,7 @@ class Sqrt(SympyFunction):
     summary_text = "square root"
 
 
-class Subtract(BinaryOperator):
+class Subtract(InfixOperator):
     """
     <url>
     :Subtraction:
@@ -559,7 +559,7 @@ class Subtract(BinaryOperator):
     summary_text = "subtract"
 
 
-class Times(BinaryOperator, SympyFunction):
+class Times(InfixOperator, SympyFunction):
     """
     <url>
     :Multiplication:
diff --git a/mathics/builtin/assignments/assign_binaryop.py b/mathics/builtin/assignments/assign_binaryop.py
index 9def274f5..49b8d226e 100644
--- a/mathics/builtin/assignments/assign_binaryop.py
+++ b/mathics/builtin/assignments/assign_binaryop.py
@@ -16,11 +16,33 @@
 """
 
 
+from mathics.core.atoms import Integer1, IntegerM1
 from mathics.core.attributes import A_HOLD_FIRST, A_PROTECTED, A_READ_PROTECTED
-from mathics.core.builtin import BinaryOperator, PostfixOperator, PrefixOperator
+from mathics.core.builtin import InfixOperator, PostfixOperator, PrefixOperator
+from mathics.core.evaluation import Evaluation
+from mathics.core.systemsymbols import SymbolPlus
+from mathics.eval.assignments.assign_binaryop import eval_inplace_op
 
 
-class AddTo(BinaryOperator):
+class InplaceInfixOperator:
+    grouping = "Right"
+    operator_symbol = SymbolPlus
+    increment_symbol = Integer1
+    returns_updated_value: bool = True
+
+    def eval(self, expr, evaluation: Evaluation):
+        """%(name)s[expr_]"""
+        return eval_inplace_op(
+            self,
+            expr,
+            self.operator_symbol,
+            self.increment_symbol,
+            self.returns_updated_value,
+            evaluation,
+        )
+
+
+class AddTo(InfixOperator, InplaceInfixOperator):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/AddTo.html</url>
 
@@ -38,16 +60,27 @@ class AddTo(BinaryOperator):
     """
 
     attributes = A_HOLD_FIRST | A_PROTECTED
-    grouping = "Right"
     operator = "+="
 
-    rules = {
-        "x_ += dx_": "x = x + dx",
-    }
+    operator_symbol = SymbolPlus
+    return_before_value: bool = True
     summary_text = "add a value and assigns that returning the new value"
 
-
-class Decrement(PostfixOperator):
+    def eval(self, expr, increment, evaluation: Evaluation):
+        """%(name)s[expr_, increment_]"""
+        return eval_inplace_op(
+            self,
+            expr,
+            self.operator_symbol,
+            increment,
+            self.return_before_value,
+            evaluation,
+        )
+
+
+# Decrement has Infix properties for evaluation purposes, but Postfix
+# properties for operator association.
+class Decrement(InplaceInfixOperator, InfixOperator, PostfixOperator):
     """
     <url>:WMA link
     :https://reference.wolfram.com/language/ref/Decrement.html</url>
@@ -59,26 +92,43 @@ class Decrement(PostfixOperator):
       <dd>decrements $x$ by 1, returning the original value of $x$.
     </dl>
 
-    >> a = 5;
-    X> a--
+    >> a = 5; a--
      = 5
-    X> a
+    >> a
      = 4
+
+    Decrement a numerical value:
+
+    >> a = 1.6; a--; a
+     = 0.6
+
+    Decrement all values in a list:
+
+    >> a = {1, 3, 5}
+     = {1, 3, 5}
+
+    >> a--; a
+     = {0, 2, 4}
+
+    Compare with <url>:PreDecrement:
+    /doc/reference-of-built-in-symbols/assignments/in-place-binary-assignment-operator/predecrement
+    </url> which returns the value before updating, and <url>:Increment:
+    /doc/reference-of-built-in-symbols/assignments/in-place-binary-assignment-operator/increment
+    </url> which goes the other way.
     """
 
-    operator = "--"
     attributes = A_HOLD_FIRST | A_PROTECTED | A_READ_PROTECTED
+    increment_symbol = IntegerM1
+    operator = "--"
+    operator_symbol = SymbolPlus
 
-    rules = {
-        "x_--": "Module[{t=x}, x = x - 1; t]",
-    }
-
+    returns_updated_value = False
     summary_text = (
         "decreases the value by one and assigns that returning the original value"
     )
 
 
-class DivideBy(BinaryOperator):
+class DivideBy(InplaceInfixOperator, InfixOperator):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/DivideBy.html</url>
 
@@ -105,7 +155,7 @@ class DivideBy(BinaryOperator):
     summary_text = "divide a value and assigns that returning the new value"
 
 
-class Increment(PostfixOperator):
+class Increment(InplaceInfixOperator, InfixOperator, PostfixOperator):
     """
     <url>:WMA link:
     https://reference.wolfram.com/language/ref/Increment.html</url>
@@ -117,34 +167,90 @@ class Increment(PostfixOperator):
       <dd>increments $x$ by 1, returning the original value of $x$.
     </dl>
 
-    >> a = 2;
-    >> a++
+    >> a = 1; a++
+     = 1
+    >> a
      = 2
+
+    Increment a numeric value:
+
+    >> a = 1.5; a++
+     = 1.5
+
     >> a
-     = 3
+     = 2.5
+
+    Increment a symbolic value:
+
+    >> y = 2 x; y++; y
+     = 1 + 2 x
+
+    Increment all values in a list:
+
+    >> x = {1, 3, 5}
+     = {1, 3, 5}
+
+    x++; x
+     = {2, 4, 6}
+
     Grouping of 'Increment', 'PreIncrement' and 'Plus':
     >> ++++a+++++2//Hold//FullForm
      = Hold[Plus[PreIncrement[PreIncrement[Increment[Increment[a]]]], 2]]
-    """
 
-    operator = "++"
-    attributes = A_HOLD_FIRST | A_PROTECTED | A_READ_PROTECTED
+    Compare with <url>:PreIncrement:
+    /doc/reference-of-built-in-symbols/assignments/in-place-binary-assignment-operator/preincrement
+    </url> which returns the value before update.
 
-    rules = {
-        "x_++": (
-            "Module[{Internal`IncrementTemporary = x},"
-            "       x = x + 1;"
-            "       Internal`IncrementTemporary"
-            "]"
-        ),
-    }
+    #> Clear[a, x, y]
+    """
 
+    attributes = A_HOLD_FIRST | A_PROTECTED | A_READ_PROTECTED
+    increment_symbol = Integer1
+    operator = "++"
+    operator_symbol = SymbolPlus
+    returns_updated_value: bool = False
     summary_text = (
         "increases the value by one and assigns that returning the original value"
     )
 
 
-class PreIncrement(PrefixOperator):
+class PreDecrement(InplaceInfixOperator, PrefixOperator):
+    """
+    <url>:WMA link:
+    https://reference.wolfram.com/language/ref/PreDecrement.html</url>
+
+    <dl>
+      <dt>'PreDecrement[$x$]'
+
+      <dt>'--$x$'
+      <dd>decrements $x$ by 1, returning the new value of $x$.
+    </dl>
+
+    '--$a$' is equivalent to '$a$ = $a$ - 1':
+    >> a = 2;
+    >> --a
+     = 1
+    >> a
+     = 1
+
+    Compare with <url>:Decrement:
+    /doc/reference-of-built-in-symbols/assignments/in-place-binary-assignment-operator/decrement
+    </url> which returns the updated value, and <url>:Increment:
+    /doc/reference-of-built-in-symbols/assignments/in-place-binary-assignment-operator/increment
+    </url> which goes the other way.
+
+    #> Clear[a]
+    """
+
+    attributes = A_HOLD_FIRST | A_PROTECTED | A_READ_PROTECTED
+    increment_symbol = IntegerM1
+    operator = "--"
+    operator_symbol = SymbolPlus
+    returns_updated_value: bool = True
+    summary_text = "decrease the value by one and assigns that returning the new value"
+
+
+class PreIncrement(InplaceInfixOperator, PrefixOperator):
     """
     <url>:WMA link:
     https://reference.wolfram.com/language/ref/PreIncrement.html</url>
@@ -156,53 +262,49 @@ class PreIncrement(PrefixOperator):
     </dl>
 
     '++$a$' is equivalent to '$a$ = $a$ + 1':
-    >> a = 2;
+    >> a = 2
+     = 2
+
     >> ++a
      = 3
+
     >> a
      = 3
-    """
 
-    attributes = A_HOLD_FIRST | A_PROTECTED | A_READ_PROTECTED
-    operator = "++"
+    PreIncrement a numeric value:
 
-    rules = {
-        "++x_": "x = x + 1",
-    }
+    >> a + 1.6
+     = 4.6
 
-    summary_text = "increase the value by one and assigns that returning the new value"
 
+    PreIncrement a symbolic value:
 
-class PreDecrement(PrefixOperator):
-    """
-    <url>:WMA link:
-    https://reference.wolfram.com/language/ref/PreDecrement.html</url>
+    #> Clear[x, y]
 
-    <dl>
-      <dt>'PreDecrement[$x$]'
+    >> y = x; ++y
+     = 1 + x
 
-      <dt>'--$x$'
-      <dd>decrements $x$ by 1, returning the new value of $x$.
-    </dl>
+    >> y
+     = 1 + x
 
-    '--$a$' is equivalent to '$a$ = $a$ - 1':
-    >> a = 2;
-    >> --a
-     = 1
-    >> a
-     = 1
+    Compare with <url>:Increment:
+    /doc/reference-of-built-in-symbols/assignments/in-place-binary-assignment-operator/increment
+    </url> which returns the updated value, and <url>:PreDecrement:
+    /doc/reference-of-built-in-symbols/assignments/in-place-binary-assignment-operator/predecrement
+    </url> which goes the other way.
+
+    #> Clear[a, x, y]
     """
 
-    operator = "--"
     attributes = A_HOLD_FIRST | A_PROTECTED | A_READ_PROTECTED
+    operator = "++"
+    operator_symbol = SymbolPlus
+    return_before_value: bool = False
 
-    rules = {
-        "--x_": "x = x - 1",
-    }
-    summary_text = "decrease the value by one and assigns that returning the new value"
+    summary_text = "increase the value by one and assigns that returning the new value"
 
 
-class SubtractFrom(BinaryOperator):
+class SubtractFrom(InfixOperator):
     """
     <url>:WMA link:
     https://reference.wolfram.com/language/ref/SubtractFrom.html</url>
@@ -218,6 +320,8 @@ class SubtractFrom(BinaryOperator):
      = 8
     >> a
      = 8
+
+    #> Clear[a]
     """
 
     attributes = A_HOLD_FIRST | A_PROTECTED
@@ -230,7 +334,7 @@ class SubtractFrom(BinaryOperator):
     summary_text = "subtract a value and assins that returning the new value"
 
 
-class TimesBy(BinaryOperator):
+class TimesBy(InfixOperator):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/TimesBy.html</url>
 
@@ -245,6 +349,8 @@ class TimesBy(BinaryOperator):
      = 20
     >> a
      = 20
+
+    #> Clear[a]
     """
 
     operator = "*="
diff --git a/mathics/builtin/assignments/assignment.py b/mathics/builtin/assignments/assignment.py
index 32b5cddfe..955ecd474 100644
--- a/mathics/builtin/assignments/assignment.py
+++ b/mathics/builtin/assignments/assignment.py
@@ -17,7 +17,7 @@
     A_PROTECTED,
     A_SEQUENCE_HOLD,
 )
-from mathics.core.builtin import BinaryOperator, Builtin
+from mathics.core.builtin import Builtin, InfixOperator
 from mathics.core.symbols import SymbolNull
 from mathics.core.systemsymbols import SymbolFailed
 from mathics.eval.pymathics import PyMathicsLoadException, eval_LoadModule
@@ -94,7 +94,7 @@ def eval(self, module, evaluation):
         return module
 
 
-class Set(BinaryOperator, _SetOperator):
+class Set(InfixOperator, _SetOperator):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/Set.html</url>
 
@@ -338,7 +338,7 @@ def eval(self, f, lhs, rhs, evaluation):
             return SymbolFailed
 
 
-class UpSet(BinaryOperator, _SetOperator):
+class UpSet(InfixOperator, _SetOperator):
     """
     <url>:WMA link:
          https://reference.wolfram.com/language/ref/UpSet.html</url>
diff --git a/mathics/builtin/atomic/symbols.py b/mathics/builtin/atomic/symbols.py
index 7f5e4b32e..7ca6c32fd 100644
--- a/mathics/builtin/atomic/symbols.py
+++ b/mathics/builtin/atomic/symbols.py
@@ -8,7 +8,7 @@
 
 import re
 
-from mathics_scanner import is_symbol_name
+from mathics_scanner.tokeniser import is_symbol_name
 
 from mathics.core.assignment import get_symbol_values
 from mathics.core.atoms import String
@@ -51,7 +51,7 @@
 )
 
 
-def _get_usage_string(symbol, evaluation, is_long_form: bool, htmlout=False):
+def _get_usage_string(symbol, evaluation, is_long_form: bool):
     """
     Returns a python string with the documentation associated to a given symbol.
     """
@@ -78,16 +78,13 @@ def _get_usage_string(symbol, evaluation, is_long_form: bool, htmlout=False):
     if bio is not None:
         if not is_long_form and hasattr(bio.builtin.__class__, "summary_text"):
             return bio.builtin.__class__.summary_text
-        from mathics.doc.common_doc import XMLDoc
+        from mathics.doc.common_doc import XMLDOC
 
         docstr = bio.builtin.__class__.__doc__
         title = bio.builtin.__class__.__name__
         if docstr is None:
             return None
-        if htmlout:
-            usagetext = XMLDoc(docstr, title).html()
-        else:
-            usagetext = XMLDoc(docstr, title).text(0)
+        usagetext = XMLDOC(docstr, title).text(0)
         usagetext = re.sub(r"\$([0-9a-zA-Z]*)\$", r"\1", usagetext)
         return usagetext
     return None
diff --git a/mathics/builtin/datentime.py b/mathics/builtin/datentime.py
index d0a2aebb7..df6c8d9ed 100644
--- a/mathics/builtin/datentime.py
+++ b/mathics/builtin/datentime.py
@@ -27,16 +27,13 @@
 from mathics.core.convert.expression import to_expression, to_mathics_list
 from mathics.core.convert.python import from_python
 from mathics.core.element import ImmutableValueMixin
-from mathics.core.evaluation import (
-    Evaluation,
-    TimeoutInterrupt,
-    run_with_timeout_and_stack,
-)
+from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
 from mathics.core.list import ListExpression
-from mathics.core.symbols import Symbol, SymbolNull
+from mathics.core.symbols import Symbol
 from mathics.core.systemsymbols import (
     SymbolAborted,
+    SymbolAbsoluteTime,
     SymbolAutomatic,
     SymbolInfinity,
     SymbolRowBox,
@@ -109,11 +106,9 @@ def total_seconds(td):
 else:
     total_seconds = timedelta.total_seconds
 
-SymbolAbsoluteTime = Symbol("AbsoluteTime")
 SymbolDateObject = Symbol("DateObject")
 SymbolDateString = Symbol("DateString")
 SymbolGregorian = Symbol("Gregorian")
-SymbolPause = Symbol("Pause")
 
 
 class _Date:
@@ -1026,39 +1021,6 @@ def eval(self, year, evaluation):
         return ListExpression(year, Integer(month), Integer(day))
 
 
-class Pause(Builtin):
-    """
-    <url>:WMA link:https://reference.wolfram.com/language/ref/Pause.html</url>
-
-    <dl>
-    <dt>'Pause[n]'
-      <dd>pauses for $n$ seconds.
-    </dl>
-
-    >> Pause[0.5]
-    """
-
-    messages = {
-        "numnm": (
-            "Non-negative machine-sized number expected at " "position 1 in `1`."
-        ),
-    }
-
-    summary_text = "pause for a number of seconds"
-
-    def eval(self, n, evaluation):
-        "Pause[n_]"
-        sleeptime = n.to_python()
-        if not isinstance(sleeptime, (int, float)) or sleeptime < 0:
-            evaluation.message(
-                "Pause", "numnm", Expression(SymbolPause, from_python(n))
-            )
-            return
-
-        time.sleep(sleeptime)
-        return SymbolNull
-
-
 class SystemTimeZone(Predefined):
     """
     <url>
@@ -1103,7 +1065,8 @@ def evaluate(self, evaluation):
         return Expression(SymbolDateObject.evaluate(evaluation))
 
 
-if sys.platform != "win32" and not hasattr(sys, "pyston_version_info"):
+if sys.platform != "emscripten":
+    import stopit
 
     class TimeConstrained(Builtin):
         """
@@ -1124,23 +1087,6 @@ class TimeConstrained(Builtin):
         the state of the Mathics3 kernel.
         """
 
-        # FIXME: these tests sometimes cause SEGVs which probably means
-        # that TimeConstraint has bugs.
-
-        # Consider testing via unit tests.
-        # >> TimeConstrained[Integrate[Sin[x]^1000000,x],1]
-        # = $Aborted
-
-        # >> TimeConstrained[Integrate[Sin[x]^1000000,x], 1, Integrate[Cos[x],x]]
-        # = Sin[x]
-
-        # >> s=TimeConstrained[Integrate[Sin[x] ^ 3, x], a]
-        #  : Number of seconds a is not a positive machine-sized number or Infinity.
-        #  = TimeConstrained[Integrate[Sin[x] ^ 3, x], a]
-
-        # >> a=1; s
-        # =  Cos[x] (-5 + Cos[2 x]) / 6
-
         attributes = A_HOLD_ALL | A_PROTECTED
         messages = {
             "timc": (
@@ -1162,18 +1108,22 @@ def eval_3(self, expr, t, failexpr, evaluation):
                 evaluation.message("TimeConstrained", "timc", t)
                 return
             try:
-                t = float(t.to_python())
-                evaluation.timeout_queue.append((t, datetime.now().timestamp()))
+                timeout = float(t.to_python())
+                evaluation.timeout_queue.append((timeout, datetime.now().timestamp()))
                 request = lambda: expr.evaluate(evaluation)
-                res = run_with_timeout_and_stack(request, t, evaluation)
-            except TimeoutInterrupt:
-                evaluation.timeout_queue.pop()
-                return failexpr.evaluate(evaluation)
+                done = False
+                with stopit.ThreadingTimeout(timeout) as to_ctx_mgr:
+                    assert to_ctx_mgr.state == to_ctx_mgr.EXECUTING
+                    result = request()
+                    done = True
+                if done:
+                    evaluation.timeout_queue.pop()
+                    return result
             except Exception:
                 evaluation.timeout_queue.pop()
                 raise
             evaluation.timeout_queue.pop()
-            return res
+            return failexpr.evaluate(evaluation)
 
 
 class TimeZone(Predefined):
diff --git a/mathics/builtin/directories/system_directories.py b/mathics/builtin/directories/system_directories.py
index 4296ead51..1c9df0615 100644
--- a/mathics/builtin/directories/system_directories.py
+++ b/mathics/builtin/directories/system_directories.py
@@ -6,8 +6,8 @@
 from mathics.core.attributes import A_NO_ATTRIBUTES
 from mathics.core.builtin import Predefined
 from mathics.core.evaluation import Evaluation
-from mathics.core.streams import ROOT_DIR
 from mathics.eval.directories import INITIAL_DIR, SYS_ROOT_DIR, TMP_DIR
+from mathics.settings import ROOT_DIR
 
 
 class BaseDirectory_(Predefined):
diff --git a/mathics/builtin/distance/clusters.py b/mathics/builtin/distance/clusters.py
index 382fce982..a72438bf8 100644
--- a/mathics/builtin/distance/clusters.py
+++ b/mathics/builtin/distance/clusters.py
@@ -27,7 +27,7 @@
     SymbolFindClusters,
     SymbolRule,
 )
-from mathics.eval.distance import (
+from mathics.eval.distance.clusters import (
     IllegalDataPoint,
     IllegalDistance,
     dist_repr,
@@ -495,7 +495,7 @@ def pick():
                 else:
                     candidates = heapq.nsmallest(py_n, py_distances)
 
-                for d, i in candidates:
+                for _, i in candidates:
                     yield repr_p[i]
 
             return ListExpression(*list(pick()))
diff --git a/mathics/builtin/distance/numeric.py b/mathics/builtin/distance/numeric.py
index 04d22270c..7dd278729 100644
--- a/mathics/builtin/distance/numeric.py
+++ b/mathics/builtin/distance/numeric.py
@@ -2,7 +2,10 @@
 Numerical Data
 """
 
-from mathics.core.atoms import Integer1, Integer2
+# Don't use from ... import for eval functions so that
+# tracers/debuggers can tap/switch eval functions
+import mathics.eval.distance.numeric as distance_numeric
+from mathics.core.atoms import Complex, Integer, Integer1, Integer2, Real
 from mathics.core.builtin import Builtin
 from mathics.core.expression import Evaluation, Expression
 from mathics.core.symbols import (
@@ -10,15 +13,15 @@
     SymbolDivide,
     SymbolPlus,
     SymbolPower,
-    SymbolTimes,
+    SymbolTrue,
 )
 from mathics.core.systemsymbols import (
-    SymbolDot,
     SymbolMax,
     SymbolNorm,
     SymbolSubtract,
     SymbolTotal,
 )
+from mathics.eval.testing_expressions import eval_ArrayQ
 
 
 def _norm_calc(head, u, v, evaluation: Evaluation):
@@ -143,44 +146,77 @@ class CosineDistance(Builtin):
     r"""
     <url>
     :Cosine similarity:
-    https://en.wikipedia.org/wiki/Cosine_similarity</url> \
-    (<url>:WMA:
+    https://en.wikipedia.org/wiki/Cosine_similarity</url> (<url>:WMA:
     https://reference.wolfram.com/language/ref/CosineDistance.html</url>)
 
     <dl>
       <dt>'CosineDistance[$u$, $v$]'
-      <dd>returns the cosine distance between $u$ and $v$.
+      <dd>returns the angular cosine distance between vectors $u$ and $v$.
     </dl>
 
-    The cosine distance is given by $1 - u\cdot v/(Norm[u] Norm[v])=2\sin(\phi/2)^2$ with $\phi$
-    the angle between both vectors.
+    The cosine distance is equivalent to 1 - ($u$.Conjugate[$v$]) / ('Norm[$u$] Norm[$v$]').
 
     >> N[CosineDistance[{7, 9}, {71, 89}]]
      = 0.0000759646
 
-    >> CosineDistance[{a, b}, {c, d}]
-     = 1 + (-a c - b d) / (Sqrt[Abs[a] ^ 2 + Abs[b] ^ 2] Sqrt[Abs[c] ^ 2 + Abs[d] ^ 2])
+    When the length of either vector is 0, the result is 0:
+    >> CosineDistance[{0.0, 0.0}, {x, y}]
+     = 0
+
+    >> CosineDistance[{1, 0}, {x, y}]
+     = 1 - Conjugate[x] / Sqrt[Abs[x] ^ 2 + Abs[y] ^ 2]
+
+    The order of the vectors influences the result:
+    >> CosineDistance[{x, y}, {1, 0}]
+     = 1 - x / Sqrt[Abs[x] ^ 2 + Abs[y] ^ 2]
+
+    Cosine distance includes a dot product scaled by norms:
+    >> CosineDistance[{a, b, c}, {x, y, z}]
+     = 1 + (-a Conjugate[x] - b Conjugate[y] - c Conjugate[z]) / (Sqrt[Abs[a] ^ 2 + Abs[b] ^ 2 + Abs[c] ^ 2] Sqrt[Abs[x] ^ 2 + Abs[y] ^ 2 + Abs[z] ^ 2])
+
+    A Cosine distance applied to complex numbers, uses 'Abs[]' for 'Norm[]' and complex multiplication for dot product,
+    1 - $u$ * Conjugate[$v$] / ('Abs[$u$] Abs[$v$]'):
+
+    >> CosineDistance[1+2I, 5]
+     = 1 - (1 / 5 + 2 I / 5) Sqrt[5]
     """
 
+    messages = {
+        "bldim": "The arguments `1` and `2` do not have compatible dimensions.",
+    }
+
     summary_text = "cosine distance"
 
     def eval(self, u, v, evaluation: Evaluation):
         "CosineDistance[u_, v_]"
-        dot = _norm_calc(SymbolDot, u, v, evaluation)
-        if dot is not None:
-            return Expression(
-                SymbolSubtract,
-                Integer1,
-                Expression(
-                    SymbolDivide,
-                    dot,
-                    Expression(
-                        SymbolTimes,
-                        Expression(SymbolNorm, u),
-                        Expression(SymbolNorm, v),
-                    ),
-                ),
-            )
+
+        u_is_vector = eval_ArrayQ(u, Integer1, None, evaluation) is SymbolTrue
+        v_is_vector = eval_ArrayQ(u, Integer1, None, evaluation) is SymbolTrue
+
+        if not u_is_vector:
+            if not isinstance(u, (Complex, Integer, Real)) and isinstance(
+                v, (Complex, Integer, Real)
+            ):
+                return
+
+            if v_is_vector:
+                # u and v are not both vectors nor are they
+                # both numeric scalars. There is nothing we can do here.
+                return
+
+            # FIXME: what to do about scalar vs vector?
+
+        if v_is_vector:
+            # Check dimensions.
+            # FIXME: do we need something more general than len() here?
+            if len(u.elements) != len(v.elements):
+                evaluation.message("CosineDistance", "bldim", u, v)
+                return
+
+        # Note: use distance.eval_... not
+        # eval_...  This allows tracers and debuggers
+        # to redirect eval_ functions.
+        return distance_numeric.eval_CosineDistance(u, v)
 
 
 class EuclideanDistance(Builtin):
diff --git a/mathics/builtin/exp_structure/general.py b/mathics/builtin/exp_structure/general.py
index 49b9fcc85..f5f1720e2 100644
--- a/mathics/builtin/exp_structure/general.py
+++ b/mathics/builtin/exp_structure/general.py
@@ -4,7 +4,7 @@
 """
 
 from mathics.core.atoms import Integer
-from mathics.core.builtin import BinaryOperator, Builtin, Predefined
+from mathics.core.builtin import Builtin, InfixOperator, Predefined
 from mathics.core.exceptions import InvalidLevelspecError
 from mathics.core.expression import Evaluation, Expression
 from mathics.core.list import ListExpression
@@ -14,7 +14,7 @@
 from mathics.eval.parts import python_levelspec, walk_levels
 
 
-class MapApply(BinaryOperator):
+class MapApply(InfixOperator):
     """
     <url>
     :WMA link:
diff --git a/mathics/builtin/files_io/files.py b/mathics/builtin/files_io/files.py
index 3746d3915..939ee7734 100644
--- a/mathics/builtin/files_io/files.py
+++ b/mathics/builtin/files_io/files.py
@@ -12,11 +12,11 @@
 # We use the below import for access to variables that may change
 # at runtime.
 import mathics.eval.files_io.files as io_files
-from mathics.core.atoms import Integer, Integer3, String, SymbolString
+from mathics.core.atoms import Integer, String, SymbolString
 from mathics.core.attributes import A_PROTECTED, A_READ_PROTECTED
 from mathics.core.builtin import (
-    BinaryOperator,
     Builtin,
+    InfixOperator,
     MessageException,
     Predefined,
     PrefixOperator,
@@ -109,13 +109,13 @@ def eval_empty(self, evaluation: Evaluation, options: dict):
             tmpf = tempfile.NamedTemporaryFile(dir=TMP_DIR, delete=False)
             path = String(tmpf.name)
             tmpf.close()
-            return self.eval_path(path, evaluation, options)
+            return self.eval_name(path, evaluation, options)
         else:
             evaluation.message("OpenRead", "argx")
             return
 
-    def eval_path(self, path, evaluation: Evaluation, options: dict):
-        "%(name)s[path_?NotOptionQ, OptionsPattern[]]"
+    def eval_name(self, name, evaluation: Evaluation, options: dict):
+        "%(name)s[name_?NotOptionQ, OptionsPattern[]]"
 
         # Options
         # BinaryFormat
@@ -124,17 +124,18 @@ def eval_path(self, path, evaluation: Evaluation, options: dict):
             if not self.mode.endswith("b"):
                 mode += "b"
 
-        if not (isinstance(path, String) and len(path.to_python()) > 2):
-            evaluation.message(self.__class__.__name__, "fstr", path)
+        if not (isinstance(name, String) and len(name.to_python()) > 2):
+            evaluation.message(self.__class__.__name__, "fstr", name)
             return
 
-        path_string = path.get_string_value()
+        name_string = name.get_string_value()
 
-        tmp, is_temporary_file = path_search(path_string)
+        tmp, is_temporary_file = path_search(name_string)
         if tmp is None:
             if mode in ["r", "rb"]:
-                evaluation.message("General", "noopen", path)
+                evaluation.message("General", "noopen", name)
                 return
+            path_string = name_string
         else:
             path_string = tmp
 
@@ -146,19 +147,20 @@ def eval_path(self, path, evaluation: Evaluation, options: dict):
             opener = MathicsOpen(
                 path_string,
                 mode=mode,
+                name=name_string,
                 encoding=encoding.value,
                 is_temporary_file=is_temporary_file,
             )
             opener.__enter__(is_temporary_file=is_temporary_file)
             n = opener.n
         except IOError:
-            evaluation.message("General", "noopen", path)
+            evaluation.message("General", "noopen", name)
             return
         except MessageException as e:
             e.message(evaluation)
             return
 
-        return Expression(Symbol(self.stream_type), path, Integer(n))
+        return Expression(Symbol(self.stream_type), name, Integer(n))
 
 
 class Character(Builtin):
@@ -511,7 +513,7 @@ class OpenAppend(_OpenAction):
     )
 
 
-class Put(BinaryOperator):
+class Put(InfixOperator):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/Put.html</url>
 
@@ -615,7 +617,7 @@ def eval_default(self, exprs, filename, evaluation):
         return expr
 
 
-class PutAppend(BinaryOperator):
+class PutAppend(InfixOperator):
     """
     <url>
     :WMA link:
@@ -1612,11 +1614,9 @@ class WriteString(Builtin):
 
     def eval(self, channel, expr, evaluation: Evaluation):
         """WriteString[channel_, expr___]"""
+
         if isinstance(channel, String):
-            if channel.value == "stdout":
-                stream = stream_manager.lookup_stream(1)
-            elif channel.value == "stderr":
-                stream = stream_manager.lookup_stream(2)
+            stream = stream_manager.get_stream_by_name(channel.value)
         elif isinstance(channel, Stream):
             stream = channel
         elif isinstance(channel, ListExpression):
diff --git a/mathics/builtin/files_io/importexport.py b/mathics/builtin/files_io/importexport.py
index 3120b2242..5b54eebca 100644
--- a/mathics/builtin/files_io/importexport.py
+++ b/mathics/builtin/files_io/importexport.py
@@ -1326,9 +1326,15 @@ class Import(Builtin):
       <dt>'Import["$file$"]'
       <dd>imports data from a file.
 
+      <dt>'Import["$file$", "$fmt$"]'
+      <dd>imports file assuming the specified file format.
+
       <dt>'Import["$file$", $elements$]'
       <dd>imports the specified elements from a file.
 
+      <dt>'Import["$file$", {"$fmt$", $elements$}]'
+      <dd>imports the specified elements from a file asuming the specified file format.
+
       <dt>'Import["http://$url$", ...]' and 'Import["ftp://$url$", ...]'
       <dd>imports from a URL.
     </dl>
diff --git a/mathics/builtin/functional/apply_fns_to_lists.py b/mathics/builtin/functional/apply_fns_to_lists.py
index 57f7b6ab8..ff47f3adc 100644
--- a/mathics/builtin/functional/apply_fns_to_lists.py
+++ b/mathics/builtin/functional/apply_fns_to_lists.py
@@ -9,14 +9,11 @@
 they are always applied to every element in a list.
 """
 
-# This tells documentation how to sort this module
-sort_order = "mathics.builtin.applying-functions-to-lists"
-
 from typing import Iterable
 
 from mathics.builtin.list.constructing import List
 from mathics.core.atoms import Integer, Integer3
-from mathics.core.builtin import BinaryOperator, Builtin
+from mathics.core.builtin import Builtin, InfixOperator
 from mathics.core.convert.expression import to_mathics_list
 from mathics.core.evaluation import Evaluation
 from mathics.core.exceptions import (
@@ -30,8 +27,11 @@
 from mathics.core.systemsymbols import SymbolMapThread, SymbolRule
 from mathics.eval.parts import python_levelspec, walk_levels
 
+# This tells documentation how to sort this module
+sort_order = "mathics.builtin.applying-functions-to-lists"
+
 
-class Apply(BinaryOperator):
+class Apply(InfixOperator):
     """
     <dl>
       <dt>'Apply[$f$, $expr$]'
@@ -69,7 +69,6 @@ class Apply(BinaryOperator):
     """
 
     summary_text = "apply a function to a list, at specified levels"
-    operator = "@@"
     grouping = "Right"
 
     options = {
@@ -103,7 +102,7 @@ def callback(level):
         return result
 
 
-class Map(BinaryOperator):
+class Map(InfixOperator):
     """
     <dl>
       <dt>'Map[$f$, $expr$]' or '$f$ /@ $expr$'
@@ -128,7 +127,6 @@ class Map(BinaryOperator):
     """
 
     summary_text = "map a function over a list, at specified levels"
-    operator = "/@"
     grouping = "Right"
 
     options = {
@@ -197,17 +195,17 @@ class MapAt(Builtin):
      = {f[a], b, c, d}
     """
 
-    summary_text = "map a function at particular positions"
     rules = {
         "MapAt[f_, pos_][expr_]": "MapAt[f, expr, pos]",
     }
+    summary_text = "map a function at particular positions"
 
-    def eval(self, f, expr, args, evaluation, options={}):
+    def eval(self, f, expr, args, evaluation: Evaluation):
         "MapAt[f_, expr_, args_]"
 
         m = len(expr.elements)
 
-        def map_at_one(i, elements):
+        def map_at_one(i):
             if 1 <= i <= m:
                 j = i - 1
             elif -m <= i <= -1:
@@ -230,13 +228,13 @@ def map_at_one(i, elements):
         a = args.to_python()
         if isinstance(a, int):
             new_elements = list(expr.elements)
-            new_elements = map_at_one(a, new_elements)
+            new_elements = map_at_one(a)
             return List(*new_elements)
         elif isinstance(a, list):
             new_elements = list(expr.elements)
             for item in a:
                 if len(item) == 1 and isinstance(item[0], int):
-                    new_elements = map_at_one(item[0], new_elements)
+                    new_elements = map_at_one(item[0])
             return List(*new_elements)
 
 
@@ -483,5 +481,5 @@ def eval(self, f, args, h, evaluation: Evaluation):
 
         args = args.get_sequence()
         expr = Expression(f, *args)
-        threaded, result = expr.thread(evaluation, head=h)
+        _, result = expr.thread(evaluation, head=h)
         return result
diff --git a/mathics/builtin/list/eol.py b/mathics/builtin/list/eol.py
index a78f848a0..01da60253 100644
--- a/mathics/builtin/list/eol.py
+++ b/mathics/builtin/list/eol.py
@@ -18,7 +18,7 @@
     A_PROTECTED,
     A_READ_PROTECTED,
 )
-from mathics.core.builtin import BinaryOperator, Builtin
+from mathics.core.builtin import Builtin, InfixOperator
 from mathics.core.convert.expression import to_mathics_list
 from mathics.core.convert.python import from_python
 from mathics.core.evaluation import Evaluation
@@ -129,9 +129,6 @@ class AppendTo(Builtin):
 
     attributes = A_HOLD_FIRST | A_PROTECTED
 
-    messages = {
-        "rvalue": "`1` is not a variable with a value, so its value cannot be changed.",
-    }
     summary_text = "add an element at the end of an stored list or expression"
 
     def eval(self, s, element, evaluation):
@@ -1344,7 +1341,6 @@ class PrependTo(Builtin):
     attributes = A_HOLD_FIRST | A_PROTECTED
 
     messages = {
-        "rvalue": "`1` is not a variable with a value, so its value cannot be changed.",
         "normal": "Nonatomic expression expected at position 1 in `1`.",
     }
     summary_text = "add an element at the beginning of an stored list or expression"
@@ -1537,7 +1533,7 @@ def cond(element):
         return items.filter(items.head, cond, evaluation)
 
 
-class Span(BinaryOperator):
+class Span(InfixOperator):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/Span.html</url>
 
diff --git a/mathics/builtin/messages.py b/mathics/builtin/messages.py
index e524b16e5..725a15897 100644
--- a/mathics/builtin/messages.py
+++ b/mathics/builtin/messages.py
@@ -8,7 +8,7 @@
 
 from mathics.core.atoms import String
 from mathics.core.attributes import A_HOLD_ALL, A_HOLD_FIRST, A_LOCKED, A_PROTECTED
-from mathics.core.builtin import BinaryOperator, Builtin, Predefined
+from mathics.core.builtin import Builtin, InfixOperator, Predefined
 from mathics.core.evaluation import Evaluation, Message as EvaluationMessage
 from mathics.core.expression import Expression
 from mathics.core.list import ListExpression
@@ -224,6 +224,7 @@ class General(Builtin):
         "pspec": (
             "Part specification `1` is neither an integer nor " "a list of integer."
         ),
+        "rvalue": "`1` is not a variable with a value, so its value cannot be changed.",
         "seqs": "Sequence specification expected, but got `1`.",
         "setp": "Part assignment to `1` could not be made",
         "setps": "`1` in the part assignment is not a symbol.",
@@ -299,7 +300,7 @@ def check_message(expr) -> bool:
     return False
 
 
-class MessageName(BinaryOperator):
+class MessageName(InfixOperator):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/MessageName.html</url>
 
@@ -322,7 +323,6 @@ class MessageName(BinaryOperator):
     default_formats = False
     formats: typing.Dict[str, Any] = {}
     messages = {"messg": "Message cannot be set to `1`. It must be set to a string."}
-    summary_text = "message identifyier"
     operator = "::"
     rules = {
         "MakeBoxes[MessageName[symbol_Symbol, tag_String], "
@@ -333,6 +333,7 @@ class MessageName(BinaryOperator):
             'RowBox[{MakeBoxes[symbol, InputForm], "::", tag}]'
         ),
     }
+    summary_text = "associate a message name with a tag"
 
     def eval(self, symbol: Symbol, tag: String, evaluation: Evaluation):
         "MessageName[symbol_Symbol, tag_String]"
diff --git a/mathics/builtin/no_meaning/__init__.py b/mathics/builtin/no_meaning/__init__.py
new file mode 100644
index 000000000..4edf3f31d
--- /dev/null
+++ b/mathics/builtin/no_meaning/__init__.py
@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+"""
+Operators without Built-in Meanings
+
+Not all operators recognized by the Mathics3 are associated with functions that have built‐in meanings.
+You can use these operators as a way to build up your own notation within Mathics3.
+"""
+
+# This tells documentation how to sort this module
+sort_order = "mathics.builtin.operators-without-built-in-meanings"
diff --git a/mathics/builtin/no_meaning/infix.py b/mathics/builtin/no_meaning/infix.py
new file mode 100644
index 000000000..ed5cb5bb7
--- /dev/null
+++ b/mathics/builtin/no_meaning/infix.py
@@ -0,0 +1,50 @@
+"""
+Infix Operators without Built-in Meanings
+"""
+
+from sys import modules
+
+from mathics.core.builtin import NoMeaningInfixOperator, add_no_meaning_builtin_classes
+
+
+# Note: this function has to exist inside this module, for the created modules
+# to be put under module `mathics.builtin.no_meaning.infix`. This seems to be
+# a limitation on the Python class-creation function type().
+def create_class_function(
+    operator_name: str,
+    operator_base_class,
+    operator_string: str,
+    mathics3_format_function_name: str,
+) -> type:
+    """
+    Returns a Mathics3 Builtin function associated with this module
+    (mathics.builtin.no_meaning.infix) that implements a Mathics infix operator
+    with no pre-existing meaning.
+    """
+    return type(
+        operator_name,
+        (operator_base_class,),
+        {
+            "__doc__": operator_base_class.__doc_pattern__.format(
+                operator_name=operator_name, operator_string=operator_string
+            ),
+            "operator": operator_string,
+            "summary_text": f"""{operator_name} postfix operator "{operator_string}" (no pre-set meaning attached)""",
+            "formats": {
+                (
+                    ("InputForm", "OutputForm", "StandardForm"),
+                    f"{operator_name}[args__]",
+                ): (
+                    (
+                        '%s[{args}, "%s"]'
+                        % (mathics3_format_function_name, operator_string)
+                    )
+                )
+            },
+        },
+    )
+
+
+add_no_meaning_builtin_classes(
+    create_class_function, "infix", "Infix", NoMeaningInfixOperator, modules[__name__]
+)
diff --git a/mathics/builtin/no_meaning/infix_extra.py b/mathics/builtin/no_meaning/infix_extra.py
new file mode 100644
index 000000000..2f29318d1
--- /dev/null
+++ b/mathics/builtin/no_meaning/infix_extra.py
@@ -0,0 +1,87 @@
+"""
+Infix Operators that require Additional Mathics3 Modules
+
+Some Infix operators require loading Mathics3 Modules before the operators is used in a special way.
+
+Right now, this happens for directed and undirected edges of a network graph. Before issuing 'LoadModule["pymathics.graph"]', \
+the operators here have no meaning and can be user defined like other operators that have no pre-set meaning.
+"""
+
+from mathics.core.attributes import A_NO_ATTRIBUTES
+from mathics.core.builtin import InfixOperator
+
+
+class DirectedEdge(InfixOperator):
+    """
+    <url>
+    :WML link:
+    https://reference.wolfram.com/language/ref/DirectedEdge.html</url>
+
+    <dl>
+      <dt>'DirectedEdge[$x$, $y$, ...]'
+      <dd>displays $x$ → $y$ → ...
+
+      Directed edges are typically used in network graphs. In Mathics3, \
+      network graphs are supported through a Mathics3 module.
+
+      Issue 'LoadModule["pymathics.graph"]' after 'pip' installing Python package \
+     'pymathics-graph'.
+    </dl>
+
+    >> DirectedEdge[x, y, z]
+     = x → y → z
+
+    >> a \\[DirectedEdge] b
+     = a → b
+
+    """
+
+    formats = {
+        (("InputForm", "OutputForm", "StandardForm"), "DirectedEdge[args__]"): (
+            'Infix[{args}, "→"]'
+        ),
+    }
+
+    attributes = A_NO_ATTRIBUTES
+    default_formats = False  # Don't use any default format rules. Instead, see belo.
+
+    operator = "→"
+    summary_text = 'DirectedEdge infix operator "→"'
+
+
+class UndirectedEdge(InfixOperator):
+    """
+    <url>
+    :WML link:
+    https://reference.wolfram.com/language/ref/UndirectedEdge.html</url>
+
+    <dl>
+      <dt>'UndrectedEdge[$x$, $y$, ...]'
+      <dd>displays $x$ ↔ $y$ ↔ ...
+
+      Undirected edges are typically used in network graphs. In Mathics3, \
+      network graphs are supported through a Mathics3 module.
+
+      Issue 'LoadModule["pymathics.graph"]' after 'pip' installing Python package \
+     'pymathics-graph'.
+    </dl>
+
+    >> UndirectedEdge[x, y, z]
+     = x ↔ y ↔ z
+
+    >> a \\[UndirectedEdge] b
+     = a ↔ b
+
+    """
+
+    formats = {
+        (("InputForm", "OutputForm", "StandardForm"), "UndirectedEdge[args__]"): (
+            'Infix[{args}, "↔"]'
+        ),
+    }
+
+    attributes = A_NO_ATTRIBUTES
+    default_formats = False  # Don't use any default format rules. Instead, see belo.
+
+    operator = "↔"
+    summary_text = 'UndirectedEdge infix operator "↔"'
diff --git a/mathics/builtin/no_meaning/postfix.py b/mathics/builtin/no_meaning/postfix.py
new file mode 100644
index 000000000..08ba4ea59
--- /dev/null
+++ b/mathics/builtin/no_meaning/postfix.py
@@ -0,0 +1,57 @@
+"""
+Postfix Operators without Built-in Meanings
+"""
+
+from sys import modules
+
+from mathics.core.builtin import (
+    NoMeaningPostfixOperator,
+    add_no_meaning_builtin_classes,
+)
+
+
+# Note: this function has to exist inside this module, for the created modules
+# to be put under module `mathics.builtin.no_meaning.postfix`. This seems to be
+# a limitation on the Python class-creation function type().
+def create_class_function(
+    operator_name: str,
+    operator_base_class,
+    operator_string: str,
+    mathics3_format_function_name: str,
+) -> type:
+    """
+    Returns a Mathics3 Builtin function associated with this module
+    (mathics.builtin.no_meaning.postfix) that implements a Mathics postfix operator
+    with no pre-existing meaning.
+    """
+    return type(
+        operator_name,
+        (operator_base_class,),
+        {
+            "__doc__": operator_base_class.__doc_pattern__.format(
+                operator_name=operator_name, operator_string=operator_string
+            ),
+            "operator": operator_string,
+            "summary_text": f"""{operator_name} postfix operator "{operator_string}" (no pre-set meaning attached)""",
+            "formats": {
+                (
+                    ("InputForm", "OutputForm", "StandardForm"),
+                    f"{operator_name}[args__]",
+                ): (
+                    (
+                        '%s[{args}, "%s"]'
+                        % (mathics3_format_function_name, operator_string)
+                    )
+                )
+            },
+        },
+    )
+
+
+add_no_meaning_builtin_classes(
+    create_class_function,
+    "postfix",
+    "Postfix",
+    NoMeaningPostfixOperator,
+    modules[__name__],
+)
diff --git a/mathics/builtin/no_meaning/prefix.py b/mathics/builtin/no_meaning/prefix.py
new file mode 100644
index 000000000..6f48a908e
--- /dev/null
+++ b/mathics/builtin/no_meaning/prefix.py
@@ -0,0 +1,54 @@
+"""
+Prefix Operators without Built-in Meanings
+"""
+
+from sys import modules
+
+from mathics.core.builtin import NoMeaningPrefixOperator, add_no_meaning_builtin_classes
+
+
+# Note: this function has to exist inside this module, for the created modules
+# to be put under `module mathics.builtin.no_meaning.prefix`. This seems to be
+# a limitation on the Python class-creation function type().
+def create_builtin_class_function(
+    operator_name: str,
+    operator_base_class,
+    operator_string: str,
+    mathics3_format_function_name: str,
+) -> type:
+    """
+    Returns a Mathics3 Builtin function associated with this module
+    (mathics.builtin.no_meaning.prefix) that implements a Mathics prefix operator
+    with no pre-existing meaning.
+    """
+    return type(
+        operator_name,
+        (operator_base_class,),
+        {
+            "__doc__": operator_base_class.__doc_pattern__.format(
+                operator_name=operator_name, operator_string=operator_string
+            ),
+            "operator": operator_string,
+            "summary_text": f"""{operator_name} prefix operator "{operator_string}" (no pre-set meaning attached)""",
+            "formats": {
+                (
+                    ("InputForm", "OutputForm", "StandardForm"),
+                    f"{operator_name}[args__]",
+                ): (
+                    (
+                        '%s[{args}, "%s"]'
+                        % (mathics3_format_function_name, operator_string)
+                    )
+                )
+            },
+        },
+    )
+
+
+add_no_meaning_builtin_classes(
+    create_builtin_class_function,
+    "prefix",
+    "Prefix",
+    NoMeaningPrefixOperator,
+    modules[__name__],
+)
diff --git a/mathics/builtin/numeric.py b/mathics/builtin/numeric.py
index cdc497f77..1703b000c 100644
--- a/mathics/builtin/numeric.py
+++ b/mathics/builtin/numeric.py
@@ -32,7 +32,6 @@
 )
 from mathics.core.builtin import Builtin, MPMathFunction, SympyFunction
 from mathics.core.convert.sympy import from_sympy
-from mathics.core.element import BaseElement
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
 from mathics.core.number import MACHINE_EPSILON
diff --git a/mathics/builtin/patterns/composite.py b/mathics/builtin/patterns/composite.py
index 38fc3474c..7eec49e3d 100644
--- a/mathics/builtin/patterns/composite.py
+++ b/mathics/builtin/patterns/composite.py
@@ -7,7 +7,7 @@
 from typing import Optional as OptionalType, Tuple, Union
 
 from mathics.core.attributes import A_HOLD_ALL, A_HOLD_FIRST, A_PROTECTED
-from mathics.core.builtin import BinaryOperator, Builtin, PatternObject, PostfixOperator
+from mathics.core.builtin import Builtin, InfixOperator, PatternObject, PostfixOperator
 from mathics.core.element import BaseElement, EvalMixin
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression, SymbolVerbatim
@@ -23,7 +23,7 @@ class _StopGeneratorExcept(StopGenerator):
     pass
 
 
-class Alternatives(BinaryOperator, PatternObject):
+class Alternatives(InfixOperator, PatternObject):
     """
     <url>
     :WMA link:
diff --git a/mathics/builtin/patterns/defaults.py b/mathics/builtin/patterns/defaults.py
index 07e4bea20..b0ea9974e 100644
--- a/mathics/builtin/patterns/defaults.py
+++ b/mathics/builtin/patterns/defaults.py
@@ -7,7 +7,7 @@
 
 from typing import Optional as OptionalType
 
-from mathics.core.builtin import BinaryOperator, PatternObject
+from mathics.core.builtin import InfixOperator, PatternObject
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
 from mathics.core.pattern import BasePattern
@@ -17,7 +17,7 @@
 sort_order = "mathics.builtin.rules-and-patterns.patttern-defaults"
 
 
-class Optional(BinaryOperator, PatternObject):
+class Optional(InfixOperator, PatternObject):
     """
 
     <url>:WMA link:https://reference.wolfram.com/language/ref/Optional.html</url>
diff --git a/mathics/builtin/patterns/restrictions.py b/mathics/builtin/patterns/restrictions.py
index ea2c7cec4..9da65cb87 100644
--- a/mathics/builtin/patterns/restrictions.py
+++ b/mathics/builtin/patterns/restrictions.py
@@ -8,7 +8,7 @@
 
 from mathics.core.atoms import Integer, Number, Rational, Real, String
 from mathics.core.attributes import A_HOLD_REST, A_PROTECTED
-from mathics.core.builtin import BinaryOperator, PatternObject, Test
+from mathics.core.builtin import InfixOperator, PatternObject, Test
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
 from mathics.core.pattern import BasePattern
@@ -18,7 +18,7 @@
 sort_order = "mathics.builtin.rules-and-patterns.restrictions"
 
 
-class Condition(BinaryOperator, PatternObject):
+class Condition(InfixOperator, PatternObject):
     """
     <url>
     :WMA link:
@@ -82,7 +82,7 @@ def yield_match(new_vars_dict, rest):
         self.pattern.match(expression, pattern_context)
 
 
-class PatternTest(BinaryOperator, PatternObject):
+class PatternTest(InfixOperator, PatternObject):
     """
 
     <url>
diff --git a/mathics/builtin/patterns/rules.py b/mathics/builtin/patterns/rules.py
index 4571b51bc..2055f305a 100644
--- a/mathics/builtin/patterns/rules.py
+++ b/mathics/builtin/patterns/rules.py
@@ -71,7 +71,7 @@
 
 from mathics.core.atoms import Integer, Integer0, Integer2, Number
 from mathics.core.attributes import A_HOLD_REST, A_PROTECTED, A_SEQUENCE_HOLD
-from mathics.core.builtin import AtomBuiltin, BinaryOperator, Builtin, PatternError
+from mathics.core.builtin import AtomBuiltin, Builtin, InfixOperator, PatternError
 from mathics.core.element import BaseElement
 from mathics.core.evaluation import Evaluation
 from mathics.core.exceptions import InvalidLevelspecError
@@ -242,7 +242,7 @@ def eval_levelspec(self, expr, rules, ls, evaluation, options):
         return None
 
 
-class ReplaceAll(BinaryOperator):
+class ReplaceAll(InfixOperator):
     """
     <url>
     :WMA link:
@@ -395,7 +395,7 @@ def eval(
         return ListExpression(*list_result)
 
 
-class ReplaceRepeated(BinaryOperator):
+class ReplaceRepeated(InfixOperator):
     """
 
     <url>
@@ -483,7 +483,7 @@ def eval_list(
         return result
 
 
-class Rule_(BinaryOperator):
+class Rule_(InfixOperator):
     """
 
     <url>:WMA link:https://reference.wolfram.com/language/ref/Rule_.html</url>
@@ -518,7 +518,7 @@ def eval_rule(self, elems, evaluation):
         return None
 
 
-class RuleDelayed(BinaryOperator):
+class RuleDelayed(InfixOperator):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/RuleDelayed.html</url>
 
diff --git a/mathics/builtin/procedural.py b/mathics/builtin/procedural.py
index d033ad90d..a7dac7865 100644
--- a/mathics/builtin/procedural.py
+++ b/mathics/builtin/procedural.py
@@ -16,6 +16,7 @@
 environment.
 """
 
+import time
 
 from mathics.core.attributes import (
     A_HOLD_ALL,
@@ -23,7 +24,8 @@
     A_PROTECTED,
     A_READ_PROTECTED,
 )
-from mathics.core.builtin import BinaryOperator, Builtin, IterationFunction
+from mathics.core.builtin import Builtin, InfixOperator, IterationFunction
+from mathics.core.convert.python import from_python
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
 from mathics.core.interrupt import (
@@ -34,7 +36,7 @@
     WLThrowInterrupt,
 )
 from mathics.core.symbols import Symbol, SymbolFalse, SymbolNull, SymbolTrue
-from mathics.core.systemsymbols import SymbolMatchQ
+from mathics.core.systemsymbols import SymbolMatchQ, SymbolPause
 from mathics.eval.patterns import match
 
 SymbolWhich = Symbol("Which")
@@ -182,7 +184,7 @@ def eval(self, expr, failexpr, evaluation):
             return failexpr
 
 
-class CompoundExpression(BinaryOperator):
+class CompoundExpression(InfixOperator):
     """
     <url>:WMA link:
     https://reference.wolfram.com/language/ref/CompoundExpression.html</url>
@@ -438,6 +440,48 @@ def eval(self, evaluation: Evaluation):
         raise AbortInterrupt
 
 
+class Pause(Builtin):
+    """
+    <url>:WMA link:https://reference.wolfram.com/language/ref/Pause.html</url>
+
+    <dl>
+    <dt>'Pause[n]'
+      <dd>pauses for at least $n$ seconds.
+    </dl>
+
+    >> Pause[0.5]
+    """
+
+    messages = {
+        "numnm": (
+            "Non-negative machine-sized number expected at " "position 1 in `1`."
+        ),
+    }
+
+    summary_text = "pause for a number of seconds"
+
+    # Number of timeout polls per second that we perform in looking
+    # for a timeout.
+    PAUSE_TICKS_PER_SECOND = 1000
+
+    def eval(self, n, evaluation: Evaluation):
+        "Pause[n_]"
+        sleeptime = n.to_python()
+        if not isinstance(sleeptime, (int, float)) or sleeptime < 0:
+            evaluation.message(
+                "Pause", "numnm", Expression(SymbolPause, from_python(n))
+            )
+            return
+
+        steps = int(self.PAUSE_TICKS_PER_SECOND * sleeptime)
+        for _ in range(steps):
+            time.sleep(1 / self.PAUSE_TICKS_PER_SECOND)
+            if evaluation.timeout:
+                return SymbolNull
+
+        return SymbolNull
+
+
 class Return(Builtin):
     """
     <url>:WMA link:
diff --git a/mathics/builtin/scoping.py b/mathics/builtin/scoping.py
index 2333dcedd..d8ccc8deb 100644
--- a/mathics/builtin/scoping.py
+++ b/mathics/builtin/scoping.py
@@ -3,7 +3,7 @@
 Scoping Constructs
 """
 
-from mathics_scanner import is_symbol_name
+from mathics_scanner.tokeniser import is_symbol_name
 
 from mathics.core.assignment import get_symbol_list
 from mathics.core.atoms import Integer, String
@@ -712,5 +712,4 @@ def eval(self, vars, expr, evaluation: Evaluation):
 
         vars = dict(get_scoping_vars(vars, "With", evaluation))
         result = expr.replace_vars(vars)
-        result.evaluate(evaluation)
-        return result
+        return result.evaluate(evaluation)
diff --git a/mathics/builtin/string/operations.py b/mathics/builtin/string/operations.py
index 7784dc8cc..99aeff2ca 100644
--- a/mathics/builtin/string/operations.py
+++ b/mathics/builtin/string/operations.py
@@ -21,7 +21,7 @@
     A_PROTECTED,
     A_READ_PROTECTED,
 )
-from mathics.core.builtin import BinaryOperator, Builtin
+from mathics.core.builtin import Builtin, InfixOperator
 from mathics.core.convert.python import from_python
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import BoxError, Expression, string_list
@@ -299,7 +299,7 @@ def eval(self, strsource, strnew, pos, evaluation):
             return String(self._insert(py_strsource, py_strnew, listpos, evaluation))
 
 
-class StringJoin(BinaryOperator):
+class StringJoin(InfixOperator):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/StringJoin.html</url>
 
@@ -321,7 +321,6 @@ class StringJoin(BinaryOperator):
     """
 
     attributes = A_FLAT | A_ONE_IDENTITY | A_PROTECTED
-    operator = "<>"
     summary_text = "join strings together"
 
     def eval(self, items, evaluation):
diff --git a/mathics/builtin/string/patterns.py b/mathics/builtin/string/patterns.py
index 570ff4f4f..3ebb4e5a5 100644
--- a/mathics/builtin/string/patterns.py
+++ b/mathics/builtin/string/patterns.py
@@ -15,7 +15,7 @@
 )
 from mathics.core.atoms import Integer1, String
 from mathics.core.attributes import A_FLAT, A_LISTABLE, A_ONE_IDENTITY, A_PROTECTED
-from mathics.core.builtin import BinaryOperator, Builtin
+from mathics.core.builtin import Builtin, InfixOperator
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
 from mathics.core.list import ListExpression
@@ -234,7 +234,7 @@ def eval(self, string, rule, n, evaluation: Evaluation, options: dict):
         return eval_StringFind(self, string, rule, n, evaluation, options, True)
 
 
-class StringExpression(BinaryOperator):
+class StringExpression(InfixOperator):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/StringExpression.html</url>
 
@@ -248,7 +248,6 @@ class StringExpression(BinaryOperator):
     """
 
     attributes = A_FLAT | A_ONE_IDENTITY | A_PROTECTED
-    operator = "~~"
 
     messages = {
         "invld": "Element `1` is not a valid string or pattern element in `2`.",
diff --git a/mathics/builtin/system.py b/mathics/builtin/system.py
index a0d81c6d9..555c617af 100644
--- a/mathics/builtin/system.py
+++ b/mathics/builtin/system.py
@@ -36,99 +36,47 @@
 sort_order = "mathics.builtin.global-system-information"
 
 
-class MaxLengthIntStringConversion(Predefined):
-    """
-    <url>:Python 3.11 Integer string conversion length limitation:
-    https://docs.python.org/3.11/library/stdtypes.html#int-max-str-digits</url>
+class Breakpoint(Builtin):
+    """<url>:Python breakpoint():https://docs.python.org/3/library/functions.html#breakpoint</url>
+
     <dl>
-      <dt>'$MaxLengthIntStringConversion'
-      <dd>A positive system integer that fixes the largest size of the string that \
-          can appear when converting an 'Integer' value into a 'String'. When the \
-          string value is too large, then the middle of the integer contains \
-          an indication of the number of digits elided inside << >>.
+      <dt>'Breakpoint[]'
+      <dd> Invoke a Python breakpoint.
 
-          If '$MaxLengthIntStringConversion' is set to 0, there is no \
-          bound. Aside from 0, 640 is the smallest value allowed.
+      This can be used for debugging the Mathics3 implementation, but \
+      if you are familiar with Python, it might assist in debugging a Mathics3 programs \
+      as well.
 
-          The initial value can be set via environment variable \
-          'DEFAULT_MAX_STR_DIGITS'. If that is not set, \
-          the default value is 7000.
+      By default, the Python debugger ('pdb') is loaded. For loading other debuggers, \
+      change the environment variable 'PYTHONBREAKPOINT'.
     </dl>
 
-    Although Mathics3 can represent integers of arbitrary size, when it formats \
-    the value for display, there can be nonlinear behavior in printing the decimal string \
-    or converting it to a 'String'.
-
-    Python, in version 3.11 and up, puts a default limit on the size of \
-    the number of digits allows when converting a large integer into \
-    a string.
-
-    Show the default value of '$MaxLengthIntStringConversion':
-    >> $MaxLengthIntStringConversion
-     = ...
-
-    500! is a 1135-digit number:
-    >> 500! //ToString//StringLength
-     = ...
 
-    We first set '$MaxLengthIntStringConversion' to the smallest value allowed, \
-    so that we can see the truncation of digits in the middle:
-    >> $MaxLengthIntStringConversion = 640
-    ## Pyston 2.3.5 returns 0 while CPython returns 640
-    ## Therefore output testing below is generic.
-     = ...
+    Mathics3 also provides "breakpoint" handler, 'mathics.disabled_breakpoint', which \
+    notes that a ether 'Breakpoint[]' was encountered in Mathics3, or 'breakpoint()' was encountered \
+    in the Mathics3 source code. Either way, this breakpoint handler does not stop inside Python \
+    as you might do for debugging.
 
-    Note that setting '$MaxLengthIntStringConversion' has an effect only on Python 3.11 and later;
-    Pyston 2.x however ignores this.
+    Here is how to use 'mathics.disabled_breakpoint':
 
-    Now when we print the string value of 500! and Pyston 2.x is not used, \
-    the middle digits are removed:
-    >> 500!
-     = ...
-
-    To see this easier, manipulate the result as 'String':
+    >> SetEnvironment["PYTHONBREAKPOINT" -> "mathics.disabled_breakpoint"];
 
-    >> bigFactorial = ToString[500!]; StringTake[bigFactorial, {310, 330}]
-     = ...
+    >> Breakpoint[]
+    = Hit disabled breakpoint.
+    = Breakpoint[]
 
-    The <<501>> indicates that 501 digits have been omitted in the string conversion.
+    The environment variable 'PYTHONBREAKPOINT' can be changed as \
+    often as you want at runtime to switch 'breakpoint()' and \
+    'Breakpoint[]' behavior.
 
-    Other than 0, an 'Integer' value less than 640 is not accepted:
-    >> $MaxLengthIntStringConversion = 10
-     : 10 is not 0 or an Integer value greater than 640.
-     = ...
     """
 
-    attributes = A_CONSTANT
-    messages = {"inv": "`1` is not 0 or an Integer value greater than 640."}
-    name = "$MaxLengthIntStringConversion"
-    summary_text = "the maximum length for which an integer is converted to a String"
+    summary_text = "invoke Python breakpoint()"
 
-    def evaluate(self, evaluation: Evaluation) -> Integer:
-        try:
-            return Integer(sys.get_int_max_str_digits())
-        except AttributeError:
-            return Integer0
-
-    def eval_set(self, expr, evaluation):
-        """Set[$MaxLengthIntStringConversion, expr_]"""
-        if isinstance(expr, Integer):
-            try:
-                sys.set_int_max_str_digits(expr.value)
-                return self.evaluate(evaluation)
-            except AttributeError:
-                if expr.value != 0 and expr.value < 640:
-                    evaluation.message("$MaxLengthIntStringConversion", "inv", expr)
-                return Integer0
-            except ValueError:
-                pass
-
-        evaluation.message("$MaxLengthIntStringConversion", "inv", expr)
-        return self.evaluate(evaluation)
+    def eval(self, evaluation: Evaluation):
+        "Breakpoint[]"
 
-    def eval_setdelayed(self, expr, evaluation: Evaluation):
-        """SetDelayed[$MaxLengthIntStringConversion, expr_]"""
-        return self.eval_set(expr)
+        breakpoint()
 
 
 class CommandLine(Predefined):
@@ -327,6 +275,151 @@ def evaluate(self, evaluation: Evaluation) -> String:
         return String(__version__)
 
 
+class MaxLengthIntStringConversion(Predefined):
+    """
+    <url>:Python 3.11 Integer string conversion length limitation:
+    https://docs.python.org/3.11/library/stdtypes.html#int-max-str-digits</url>
+    <dl>
+      <dt>'$MaxLengthIntStringConversion'
+      <dd>A positive system integer that fixes the largest size of the string that \
+          can appear when converting an 'Integer' value into a 'String'. When the \
+          string value is too large, then the middle of the integer contains \
+          an indication of the number of digits elided inside << >>.
+
+          If '$MaxLengthIntStringConversion' is set to 0, there is no \
+          bound. Aside from 0, 640 is the smallest value allowed.
+
+          The initial value can be set via environment variable \
+          'DEFAULT_MAX_STR_DIGITS'. If that is not set, \
+          the default value is 7000.
+    </dl>
+
+    Although Mathics3 can represent integers of arbitrary size, when it formats \
+    the value for display, there can be nonlinear behavior in printing the decimal string \
+    or converting it to a 'String'.
+
+    Python, in version 3.11 and up, puts a default limit on the size of \
+    the number of digits allows when converting a large integer into \
+    a string.
+
+    Show the default value of '$MaxLengthIntStringConversion':
+    >> $MaxLengthIntStringConversion
+     = ...
+
+    500! is a 1135-digit number:
+    >> 500! //ToString//StringLength
+     = ...
+
+    We first set '$MaxLengthIntStringConversion' to the smallest value allowed, \
+    so that we can see the truncation of digits in the middle:
+    >> $MaxLengthIntStringConversion = 640
+    ## Pyston 2.3.5 returns 0 while CPython returns 640
+    ## Therefore output testing below is generic.
+     = ...
+
+    Note that setting '$MaxLengthIntStringConversion' has an effect only on Python 3.11 and later;
+    Pyston 2.x however ignores this.
+
+    Now when we print the string value of 500! and Pyston 2.x is not used, \
+    the middle digits are removed:
+    >> 500!
+     = ...
+
+    To see this easier, manipulate the result as 'String':
+
+    >> bigFactorial = ToString[500!]; StringTake[bigFactorial, {310, 330}]
+     = ...
+
+    The <<501>> indicates that 501 digits have been omitted in the string conversion.
+
+    Other than 0, an 'Integer' value less than 640 is not accepted:
+    >> $MaxLengthIntStringConversion = 10
+     : 10 is not 0 or an Integer value greater than 640.
+     = ...
+    """
+
+    attributes = A_CONSTANT
+    messages = {"inv": "`1` is not 0 or an Integer value greater than 640."}
+    name = "$MaxLengthIntStringConversion"
+    summary_text = "the maximum length for which an integer is converted to a String"
+
+    def evaluate(self, evaluation: Evaluation) -> Integer:
+        try:
+            return Integer(sys.get_int_max_str_digits())
+        except AttributeError:
+            return Integer0
+
+    def eval_set(self, expr, evaluation):
+        """Set[$MaxLengthIntStringConversion, expr_]"""
+        if isinstance(expr, Integer):
+            try:
+                sys.set_int_max_str_digits(expr.value)
+                return self.evaluate(evaluation)
+            except AttributeError:
+                if expr.value != 0 and expr.value < 640:
+                    evaluation.message("$MaxLengthIntStringConversion", "inv", expr)
+                return Integer0
+            except ValueError:
+                pass
+
+        evaluation.message("$MaxLengthIntStringConversion", "inv", expr)
+        return self.evaluate(evaluation)
+
+    def eval_setdelayed(self, expr, evaluation: Evaluation):
+        """SetDelayed[$MaxLengthIntStringConversion, expr_]"""
+        return self.eval_set(expr)
+
+
+class MemoryInUse(Builtin):
+    """
+    <url>:WMA link:https://reference.wolfram.com/language/ref/MemoryInUse.html</url>
+
+    <dl>
+      <dt>'MemoryInUse[]'
+      <dd>Returns the amount of memory used by all of the definitions objects if we can determine that; -1 otherwise.
+    </dl>
+
+    >> MemoryInUse[]
+     = ...
+    """
+
+    summary_text = "number of bytes of memory currently being used by Mathics"
+
+    def eval_0(self, evaluation) -> Integer:
+        """MemoryInUse[]"""
+        # Partially borrowed from https://code.activestate.com/recipes/577504/
+        from itertools import chain
+        from sys import getsizeof
+
+        definitions = evaluation.definitions
+        seen = set()
+        try:
+            default_size = getsizeof(0)
+        except TypeError:
+            return IntegerM1
+
+        handlers = {
+            tuple: iter,
+            list: iter,
+            dict: (lambda d: chain.from_iterable(d.items())),
+            set: iter,
+            frozenset: iter,
+        }
+
+        def sizeof(obj):
+            if id(obj) in seen:
+                return 0
+            seen.add(id(obj))
+            s = getsizeof(obj, default_size)
+            for typ, handler in handlers.items():
+                if isinstance(obj, typ):
+                    s += sum(map(sizeof, handler(obj)))
+                    break
+            return s
+
+        return Integer(sizeof(definitions))
+
+
 class Packages(Predefined):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/Packages.html</url>
@@ -440,6 +533,28 @@ def evaluate(self, evaluation: Evaluation):
         return String(python_implementation())
 
 
+class Run(Builtin):
+    """
+    <url>:WMA link:https://reference.wolfram.com/language/ref/Run.html</url>
+
+    <dl>
+      <dt>'Run[$command$]'
+      <dd>runs command as an external operating system command, returning the exit \
+         code returned from running the system command.
+    </dl>
+
+    X> Run["date"]
+     = ...
+    """
+
+    summary_text = "run a system command"
+
+    def eval(self, command, evaluation: Evaluation):
+        "Run[command_String]"
+        command_str = command.to_python()
+        return Integer(subprocess.call(command_str, shell=True))
+
+
 class ScriptCommandLine(Predefined):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/ScriptCommandLine.html</url>
@@ -543,26 +658,56 @@ def eval_list(self, rules: Expression, evaluation: Evaluation):
         return None
 
 
-class Run(Builtin):
+class Share(Builtin):
     """
-    <url>:WMA link:https://reference.wolfram.com/language/ref/Run.html</url>
+    <url>:WMA link:https://reference.wolfram.com/language/ref/Share.html</url>
 
     <dl>
-      <dt>'Run[$command$]'
-      <dd>runs command as an external operating system command, returning the exit \
-         code returned from running the system command.
+      <dt>'Share[]'
+      <dd>release memory forcing Python to do garbage collection. If Python package \
+          'psutil' installed is the amount of released memoryis returned. Otherwise \
+          returns $0$. This function differs from WMA which tries to reduce the amount \
+          of memory required to store definitions, by reducing duplicated definitions.
+      <dt>'Share[Symbol]'
+      <dd>Does the same thing as 'Share[]'; Note: this function differs from WMA which \
+          tries to reduce the amount of memory required to store definitions associated \
+          to $Symbol$.
+
     </dl>
 
-    X> Run["date"]
+    >> Share[]
      = ...
     """
 
-    summary_text = "run a system command"
+    summary_text = "force Python garbage collection"
 
-    def eval(self, command, evaluation: Evaluation):
-        "Run[command_String]"
-        command_str = command.to_python()
-        return Integer(subprocess.call(command_str, shell=True))
+    def eval(self, evaluation: Evaluation) -> Integer:
+        """Share[]"""
+        # TODO: implement a routine that swap all the definitions,
+        # collecting repeated symbols and expressions, and then
+        # replace them by references.
+        # Return the amount of memory recovered.
+        if have_psutil:
+            totalmem = psutil.virtual_memory().available
+            gc.collect()
+            return Integer(totalmem - psutil.virtual_memory().available)
+        else:
+            gc.collect()
+            return Integer0
+
+    def eval_with_symbol(self, symbol, evaluation: Evaluation) -> Integer:
+        """Share[symbol_Symbol]"""
+        # TODO: implement a routine that swap all the definitions,
+        # collecting repeated symbols and expressions, and then
+        # replace them by references.
+        # Return the amount of memory recovered.
+        if have_psutil:
+            totalmem = psutil.virtual_memory().available
+            gc.collect()
+            return Integer(totalmem - psutil.virtual_memory().available)
+        else:
+            gc.collect()
+            return Integer0
 
 
 class SystemID(Predefined):
@@ -769,105 +914,3 @@ class MemoryAvailable(Builtin):
         def eval(self, evaluation: Evaluation) -> Integer:
             """MemoryAvailable[]"""
             return IntegerM1
-
-
-class MemoryInUse(Builtin):
-    """
-    <url>:WMA link:https://reference.wolfram.com/language/ref/MemoryInUse.html</url>
-
-    <dl>
-      <dt>'MemoryInUse[]'
-      <dd>Returns the amount of memory used by all of the definitions objects if we can determine that; -1 otherwise.
-    </dl>
-
-    >> MemoryInUse[]
-     = ...
-    """
-
-    summary_text = "number of bytes of memory currently being used by Mathics"
-
-    def eval_0(self, evaluation) -> Integer:
-        """MemoryInUse[]"""
-        # Partially borrowed from https://code.activestate.com/recipes/577504/
-        from itertools import chain
-        from sys import getsizeof
-
-        definitions = evaluation.definitions
-        seen = set()
-        try:
-            default_size = getsizeof(0)
-        except TypeError:
-            return IntegerM1
-
-        handlers = {
-            tuple: iter,
-            list: iter,
-            dict: (lambda d: chain.from_iterable(d.items())),
-            set: iter,
-            frozenset: iter,
-        }
-
-        def sizeof(obj):
-            if id(obj) in seen:
-                return 0
-            seen.add(id(obj))
-            s = getsizeof(obj, default_size)
-            for typ, handler in handlers.items():
-                if isinstance(obj, typ):
-                    s += sum(map(sizeof, handler(obj)))
-                    break
-            return s
-
-        return Integer(sizeof(definitions))
-
-
-class Share(Builtin):
-    """
-    <url>:WMA link:https://reference.wolfram.com/language/ref/Share.html</url>
-
-    <dl>
-      <dt>'Share[]'
-      <dd>release memory forcing Python to do garbage collection. If Python package \
-          'psutil' installed is the amount of released memoryis returned. Otherwise \
-          returns $0$. This function differs from WMA which tries to reduce the amount \
-          of memory required to store definitions, by reducing duplicated definitions.
-      <dt>'Share[Symbol]'
-      <dd>Does the same thing as 'Share[]'; Note: this function differs from WMA which \
-          tries to reduce the amount of memory required to store definitions associated \
-          to $Symbol$.
-
-    </dl>
-
-    >> Share[]
-     = ...
-    """
-
-    summary_text = "force Python garbage collection"
-
-    def eval(self, evaluation: Evaluation) -> Integer:
-        """Share[]"""
-        # TODO: implement a routine that swap all the definitions,
-        # collecting repeated symbols and expressions, and then
-        # replace them by references.
-        # Return the amount of memory recovered.
-        if have_psutil:
-            totalmem = psutil.virtual_memory().available
-            gc.collect()
-            return Integer(totalmem - psutil.virtual_memory().available)
-        else:
-            gc.collect()
-            return Integer0
-
-    def eval_with_symbol(self, symbol, evaluation: Evaluation) -> Integer:
-        """Share[symbol_Symbol]"""
-        # TODO: implement a routine that swap all the definitions,
-        # collecting repeated symbols and expressions, and then
-        # replace them by references.
-        # Return the amount of memory recovered.
-        if have_psutil:
-            totalmem = psutil.virtual_memory().available
-            gc.collect()
-            return Integer(totalmem - psutil.virtual_memory().available)
-        else:
-            gc.collect()
-            return Integer0
diff --git a/mathics/builtin/tensors.py b/mathics/builtin/tensors.py
index f85a3e9ce..523717e73 100644
--- a/mathics/builtin/tensors.py
+++ b/mathics/builtin/tensors.py
@@ -21,7 +21,7 @@
 
 from mathics.core.atoms import Integer
 from mathics.core.attributes import A_FLAT, A_ONE_IDENTITY, A_PROTECTED
-from mathics.core.builtin import BinaryOperator, Builtin
+from mathics.core.builtin import Builtin, InfixOperator
 from mathics.core.evaluation import Evaluation
 from mathics.core.list import ListExpression
 from mathics.eval.tensors import (
@@ -90,7 +90,7 @@ def eval(self, expr, evaluation: Evaluation):
         return ListExpression(*[Integer(dim) for dim in get_dimensions(expr)])
 
 
-class Dot(BinaryOperator):
+class Dot(InfixOperator):
     """
     <url>:Dot product:https://en.wikipedia.org/wiki/Dot_product</url> \
     (<url>:WMA link: https://reference.wolfram.com/language/ref/Dot.html</url>)
@@ -114,7 +114,6 @@ class Dot(BinaryOperator):
      = a . b
     """
 
-    operator = "."
     attributes = A_FLAT | A_ONE_IDENTITY | A_PROTECTED
 
     rules = {
diff --git a/mathics/builtin/testing_expressions/equality_inequality.py b/mathics/builtin/testing_expressions/equality_inequality.py
index 1e27e866a..a5b614cf2 100644
--- a/mathics/builtin/testing_expressions/equality_inequality.py
+++ b/mathics/builtin/testing_expressions/equality_inequality.py
@@ -16,7 +16,7 @@
     A_ORDERLESS,
     A_PROTECTED,
 )
-from mathics.core.builtin import BinaryOperator, Builtin, SympyFunction
+from mathics.core.builtin import Builtin, InfixOperator, SympyFunction
 from mathics.core.convert.expression import to_expression, to_numeric_args
 from mathics.core.expression import Expression
 from mathics.core.expression_predefined import (
@@ -50,7 +50,7 @@
 }
 
 
-class _InequalityOperator(BinaryOperator):
+class _InequalityOperator(InfixOperator):
     grouping = "NonAssociative"
 
     @staticmethod
@@ -468,7 +468,6 @@ class Equal(_EqualityOperator, _SympyComparison):
     """
 
     grouping = "None"
-    operator = "=="
     summary_text = "numerical equality"
     sympy_name = "Eq"
 
@@ -503,7 +502,6 @@ class Greater(_ComparisonOperator, _SympyComparison):
      = True
     """
 
-    operator = ">"
     summary_text = "greater than"
     sympy_name = "StrictGreaterThan"
 
@@ -522,7 +520,6 @@ class GreaterEqual(_ComparisonOperator, _SympyComparison):
     </dl>
     """
 
-    operator = ">="
     summary_text = "greater than or equal to"
     sympy_name = "GreaterThan"
 
@@ -600,7 +597,6 @@ class Less(_ComparisonOperator, _SympyComparison):
      = 1 < 3 < x < 2
     """
 
-    operator = "<"
     summary_text = "less than"
     sympy_name = "StrictLessThan"
 
@@ -623,7 +619,6 @@ class LessEqual(_ComparisonOperator, _SympyComparison):
 
     """
 
-    operator = "<="
     summary_text = "less than or equal to"
     sympy_name = "LessThan"  # in contrast to StrictLessThan
 
@@ -748,7 +743,6 @@ class SameQ(_ComparisonOperator):
     """
 
     grouping = "None"  # Indeterminate grouping: Neither left nor right
-    operator = "==="
 
     summary_text = "literal symbolic identity"
 
@@ -842,7 +836,6 @@ class Unequal(_EqualityOperator, _SympyComparison):
      = {True, True, True}
     """
 
-    operator = "!="
     summary_text = "numerical inequality"
     sympy_name = "Ne"
 
@@ -884,7 +877,6 @@ class UnsameQ(_ComparisonOperator):
     """
 
     grouping = "None"  # Indeterminate grouping: Neither left nor right
-    operator = "=!="
 
     summary_text = "not literal symbolic identity"
 
diff --git a/mathics/builtin/testing_expressions/list_oriented.py b/mathics/builtin/testing_expressions/list_oriented.py
index b2f819331..1de7f15ad 100644
--- a/mathics/builtin/testing_expressions/list_oriented.py
+++ b/mathics/builtin/testing_expressions/list_oriented.py
@@ -2,15 +2,17 @@
 List-Oriented Tests
 """
 
+from typing import Optional
+
 from mathics.core.atoms import Integer, Integer1, Integer2
 from mathics.core.builtin import Builtin, Test
 from mathics.core.evaluation import Evaluation
 from mathics.core.exceptions import InvalidLevelspecError
 from mathics.core.expression import Expression
-from mathics.core.symbols import Atom, SymbolFalse, SymbolTrue
+from mathics.core.symbols import Atom, BooleanType, SymbolFalse, SymbolTrue
 from mathics.core.systemsymbols import SymbolSubsetQ  # , SymbolSparseArray
 from mathics.eval.parts import python_levelspec
-from mathics.eval.testing_expressions import check_ArrayQ  # , check_SparseArrayQ
+from mathics.eval.testing_expressions import eval_ArrayQ  # , check_SparseArrayQ
 
 
 class ArrayQ(Builtin):
@@ -43,18 +45,25 @@ class ArrayQ(Builtin):
 
     rules = {
         "ArrayQ[expr_]": "ArrayQ[expr, _, True&]",
-        "ArrayQ[expr_, pattern_]": "ArrayQ[expr, pattern, True&]",
     }
 
     summary_text = "test whether an object is a tensor of a given rank"
 
-    def eval(self, expr, pattern, test, evaluation: Evaluation):
+    def eval_with_pattern(self, expr, pattern, evaluation: Evaluation):
+        "ArrayQ[expr_, pattern_]"
+
+        # if not isinstance(expr, Atom) and expr.head.sameQ(SymbolSparseArray):
+        #    return check_SparseArrayQ(expr, pattern, test, evaluation)
+
+        return eval_ArrayQ(expr, pattern, None, evaluation)
+
+    def eval_with_pattern_and_test(self, expr, pattern, test, evaluation: Evaluation):
         "ArrayQ[expr_, pattern_, test_]"
 
         # if not isinstance(expr, Atom) and expr.head.sameQ(SymbolSparseArray):
         #    return check_SparseArrayQ(expr, pattern, test, evaluation)
 
-        return check_ArrayQ(expr, pattern, test, evaluation)
+        return eval_ArrayQ(expr, pattern, test, evaluation)
 
 
 class DisjointQ(Test):
@@ -134,9 +143,9 @@ class LevelQ(Test):
 
     summary_text = "test whether is a valid level specification"
 
-    def test(self, ls) -> bool:
+    def test(self, expr) -> bool:
         try:
-            start, stop = python_levelspec(ls)
+            python_levelspec(expr)
             return True
         except InvalidLevelspecError:
             return False
@@ -283,7 +292,7 @@ class SubsetQ(Builtin):
     }
     summary_text = "test if a list is a subset of another list"
 
-    def eval(self, expr, subset, evaluation: Evaluation):
+    def eval(self, expr, subset, evaluation: Evaluation) -> Optional[BooleanType]:
         "SubsetQ[expr_, subset___]"
 
         if isinstance(expr, Atom):
diff --git a/mathics/builtin/testing_expressions/logic.py b/mathics/builtin/testing_expressions/logic.py
index 020bb90e3..f29b11263 100644
--- a/mathics/builtin/testing_expressions/logic.py
+++ b/mathics/builtin/testing_expressions/logic.py
@@ -10,7 +10,7 @@
     A_ORDERLESS,
     A_PROTECTED,
 )
-from mathics.core.builtin import BinaryOperator, Builtin, Predefined, PrefixOperator
+from mathics.core.builtin import Builtin, InfixOperator, Predefined, PrefixOperator
 from mathics.core.evaluation import Evaluation
 from mathics.core.exceptions import InvalidLevelspecError
 from mathics.core.expression import Expression
@@ -66,7 +66,7 @@ def callback(node):
         return self._no_short_circuit()
 
 
-class And(BinaryOperator):
+class And(InfixOperator):
     """
     <url>:WMA link:
     https://reference.wolfram.com/language/ref/And.html</url>
@@ -89,7 +89,6 @@ class And(BinaryOperator):
     """
 
     attributes = A_FLAT | A_HOLD_ALL | A_ONE_IDENTITY | A_PROTECTED
-    operator = "&&"
     summary_text = "logic conjunction"
     #    rules = {
     #        "And[a_]": "a",
@@ -183,7 +182,7 @@ def _no_short_circuit(self):
         return SymbolTrue
 
 
-class Equivalent(BinaryOperator):
+class Equivalent(InfixOperator):
     """
     <url>
     :WMA link:
@@ -210,7 +209,6 @@ class Equivalent(BinaryOperator):
     """
 
     attributes = A_ORDERLESS | A_PROTECTED
-    operator = "\u29E6"
     summary_text = "logic equivalence"
 
     def eval(self, args, evaluation: Evaluation):
@@ -253,7 +251,7 @@ class False_(Predefined):
     summary_text = "boolean constant for False"
 
 
-class Implies(BinaryOperator):
+class Implies(InfixOperator):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/Implies.html</url>
 
@@ -277,7 +275,6 @@ class Implies(BinaryOperator):
      = a Implies b Implies c
     """
 
-    operator = "\u21D2"
     grouping = "Right"
     summary_text = "logic implication"
 
@@ -329,7 +326,7 @@ def _no_short_circuit(self):
         return SymbolTrue
 
 
-class Or(BinaryOperator):
+class Or(InfixOperator):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/Or.html</url>
 
@@ -379,7 +376,7 @@ def eval(self, args, evaluation: Evaluation):
             return SymbolFalse
 
 
-class Nand(Builtin):
+class Nand(InfixOperator):
     """
     <url>:WMA link:
     https://reference.wolfram.com/language/ref/Nand.html</url>
@@ -395,14 +392,13 @@ class Nand(Builtin):
      = True
     """
 
-    operator = "\u22BC"
     rules = {
         "Nand[expr___]": "Not[And[expr]]",
     }
     summary_text = "negation of logic conjunction"
 
 
-class Nor(Builtin):
+class Nor(InfixOperator):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/Nor.html</url>
 
@@ -417,7 +413,6 @@ class Nor(Builtin):
      = False
     """
 
-    operator = "\u22BD"
     rules = {
         "Nor[expr___]": "Not[Or[expr]]",
     }
@@ -467,7 +462,7 @@ class True_(Predefined):
     summary_text = "boolean constant for True"
 
 
-class Xor(BinaryOperator):
+class Xor(InfixOperator):
     """
     <url>:WMA link:https://reference.wolfram.com/language/ref/Xor.html</url>
 
@@ -492,7 +487,6 @@ class Xor(BinaryOperator):
     """
 
     attributes = A_FLAT | A_ONE_IDENTITY | A_ORDERLESS | A_PROTECTED
-    operator = "\u22BB"
     summary_text = "logic (exclusive) disjunction"
 
     def eval(self, args, evaluation: Evaluation):
diff --git a/mathics/builtin/trace.py b/mathics/builtin/trace.py
index 517e7ba03..8a2233bbc 100644
--- a/mathics/builtin/trace.py
+++ b/mathics/builtin/trace.py
@@ -22,6 +22,7 @@
 from time import time
 from typing import Callable
 
+import mathics.eval.tracing
 from mathics.core.attributes import A_HOLD_ALL, A_HOLD_ALL_COMPLETE, A_PROTECTED
 from mathics.core.builtin import Builtin
 from mathics.core.convert.python import from_bool, from_python
@@ -354,6 +355,8 @@ class TraceEvaluation(Builtin):
       <dd>Evaluate $expr$ and print each step of the evaluation.
     </dl>
 
+    The 'ShowTimeBySteps' option prints the elapsed time before an evaluation occurs.
+
     >> TraceEvaluation[(x + x)^2]
      | ...
      = ...
@@ -367,20 +370,34 @@ class TraceEvaluation(Builtin):
     options = {
         "System`ShowTimeBySteps": "False",
     }
-    summary_text = "trace the successive evaluations"
+    summary_text = "trace expression evaluation"
 
     def eval(self, expr, evaluation: Evaluation, options: dict):
         "TraceEvaluation[expr_, OptionsPattern[]]"
+
         curr_trace_evaluation = evaluation.definitions.trace_evaluation
         curr_time_by_steps = evaluation.definitions.timing_trace_evaluation
+
+        old_evaluation_hook = mathics.eval.tracing.trace_evaluate_on_call
+
+        mathics.eval.tracing.trace_evaluate_on_call = (
+            mathics.eval.tracing.print_evaluate
+        )
+
         evaluation.definitions.trace_evaluation = True
         evaluation.definitions.timing_trace_evaluation = (
             options["System`ShowTimeBySteps"] is SymbolTrue
         )
-        result = expr.evaluate(evaluation)
-        evaluation.definitions.trace_evaluation = curr_trace_evaluation
-        evaluation.definitions.timing_trace_evaluation = curr_time_by_steps
-        return result
+        try:
+            result = expr.evaluate(evaluation)
+            return result
+        except Exception:
+            raise
+        finally:
+            evaluation.definitions.trace_evaluation = curr_trace_evaluation
+            evaluation.definitions.timing_trace_evaluation = curr_time_by_steps
+
+            mathics.eval.tracing.trace_evaluate_on_call = old_evaluation_hook
 
 
 class TraceEvaluationVariable(Builtin):
diff --git a/mathics/core/builtin.py b/mathics/core/builtin.py
index 37d2e752a..62ceccc79 100644
--- a/mathics/core/builtin.py
+++ b/mathics/core/builtin.py
@@ -2,17 +2,17 @@
 """
 Class definitions used in mathics.builtin modules that define the
 base Mathics3's classes: Predefined, Builtin, Test, Operator (and from that
-UnaryOperator, BinaryOperator, PrefixOperator, PostfixOperator, etc.),
+UnaryOperator, InfixOperator, PrefixOperator, PostfixOperator, etc.),
 SympyFunction, MPMathFunction, etc.
 """
 
 import importlib
 import importlib.util
-import os.path as osp
 import re
 from abc import ABC
 from functools import total_ordering
 from itertools import chain
+from types import ModuleType
 from typing import (
     Any,
     Callable,
@@ -27,9 +27,10 @@
 )
 
 import mpmath
-import pkg_resources
 import sympy
 
+import mathics.core.parser.operators
+
 # Note: it is important *not* to use:
 #   from mathics.eval.tracing import run_sympy
 # but, instead, import the module, as below, and then
@@ -58,7 +59,7 @@
 from mathics.core.convert.expression import to_expression
 from mathics.core.convert.op import ascii_operator_to_symbol
 from mathics.core.convert.python import from_bool
-from mathics.core.convert.sympy import from_sympy, to_numeric_sympy_args
+from mathics.core.convert.sympy import from_sympy
 from mathics.core.definitions import Definition, Definitions
 from mathics.core.evaluation import Evaluation
 from mathics.core.exceptions import MessageException
@@ -66,6 +67,7 @@
 from mathics.core.interrupt import BreakInterrupt, ContinueInterrupt, ReturnInterrupt
 from mathics.core.list import ListExpression
 from mathics.core.number import PrecisionValueError, dps, get_precision, min_prec
+from mathics.core.parser.operators import OPERATOR_DATA
 from mathics.core.parser.util import PyMathicsDefinitions, SystemDefinitions
 from mathics.core.pattern import BasePattern
 from mathics.core.rules import BaseRule, FunctionApplyRule, Rule
@@ -91,21 +93,26 @@
 from mathics.eval.numbers.numbers import cancel
 from mathics.eval.numerify import numerify
 from mathics.eval.scoping import dynamic_scoping
+from mathics.eval.sympy import eval_sympy
+
 
-try:
-    import ujson
-except ImportError:
-    import json as ujson  # type: ignore[no-redef]
+# Exceptions...
+class NegativeIntegerException(Exception):
+    pass
 
-ROOT_DIR = pkg_resources.resource_filename("mathics", "")
 
-# Load the conversion tables from disk
-operator_tables_path = osp.join(ROOT_DIR, "data", "operator-tables.json")
-assert osp.exists(
-    operator_tables_path
-), f"Internal error: Operator precedence tables are missing; expected to be in {operator_tables_path}"
-with open(operator_tables_path, "r") as f:
-    OPERATOR_DATA = ujson.load(f)
+# Has to come before PatternArgumentError
+class PatternError(Exception):
+    def __init__(self, name, tag, *args):
+        super().__init__()
+        self.name = name
+        self.tag = tag
+        self.args = args
+
+
+class PatternArgumentError(PatternError):
+    def __init__(self, name, count, expected):
+        super().__init__(name, "argr", count, expected)
 
 
 class Builtin:
@@ -582,14 +589,7 @@ def eval(self, z, evaluation: Evaluation):
         # converted to python and the result is converted from sympy
         #
         # "%(name)s[z__]"
-        sympy_args = to_numeric_sympy_args(z, evaluation)
-        if self.sympy_name is None:
-            return
-        sympy_fn = getattr(sympy, self.sympy_name)
-        try:
-            return from_sympy(tracing.run_sympy(sympy_fn, *sympy_args))
-        except Exception:
-            return
+        return eval_sympy(self, z, evaluation)
 
     def get_constant(self, precision, evaluation, have_mpmath=False):
         try:
@@ -813,6 +813,102 @@ def has_option(options, name, evaluation):
 mathics_to_python: Dict[str, Any] = {}  # here we have: name -> string
 
 
+@total_ordering
+class CountableInteger:
+    """
+    CountableInteger is an integer specifying a countable amount (including
+    zero) that can optionally be specified as an upper bound through UpTo[].
+    """
+
+    # currently MMA does not support UpTo[Infinity], but Infinity already shows
+    # up in UpTo's parameter error messages as supported option; it would make
+    # perfect sense. currently, we stick with MMA's current behaviour and set
+    # _support_infinity to False.
+    _finite: bool
+    _upper_limit: bool
+    _integer: Union[str, int, None]
+    _support_infinity = False
+
+    def __init__(self, value: Union[int, str] = "Infinity", upper_limit=True):
+        self._finite = value != "Infinity"
+        if self._finite:
+            assert isinstance(value, int) and value >= 0
+            self._integer = value
+        else:
+            assert upper_limit
+            self._integer = None
+        self._upper_limit = upper_limit
+
+    def is_upper_limit(self) -> bool:
+        return self._upper_limit
+
+    def get_int_value(self) -> int:
+        assert self._finite
+        return cast(int, self._integer)
+
+    def __eq__(self, other) -> bool:
+        if isinstance(other, CountableInteger):
+            if self._finite:
+                return other._finite and cast(int, self._integer) == other._integer
+            else:
+                return not other._finite
+        elif isinstance(other, int):
+            return self._finite and cast(int, self._integer) == other
+        else:
+            return False
+
+    def __lt__(self, other) -> bool:
+        if isinstance(other, CountableInteger):
+            if self._finite:
+                return other._finite and cast(int, self._integer) < cast(
+                    int, other._integer
+                )
+            else:
+                return False
+        elif isinstance(other, int):
+            return self._finite and cast(int, self._integer) < other
+        else:
+            return False
+
+    @staticmethod
+    def from_expression(expr):
+        """
+        :param expr: expression from which to build a CountableInteger
+        :return: an instance of CountableInteger or None, if the whole
+        original expression should remain unevaluated.
+        :raises: MessageException, NegativeIntegerException
+        """
+
+        if isinstance(expr, Integer):
+            py_n = expr.value
+            if py_n >= 0:
+                return CountableInteger(py_n, upper_limit=False)
+            else:
+                raise NegativeIntegerException()
+        elif expr.get_head_name() == "System`UpTo":
+            if len(expr.elements) != 1:
+                raise MessageException("UpTo", "argx", len(expr.elements))
+            else:
+                n = expr.elements[0]
+                if isinstance(n, Integer):
+                    py_n = n.value
+                    if py_n < 0:
+                        raise MessageException("UpTo", "innf", expr)
+                    else:
+                        return CountableInteger(py_n, upper_limit=True)
+                elif CountableInteger._support_infinity:
+                    if (
+                        n.get_head_name() == "System`DirectedInfinity"
+                        and len(n.elements) == 1
+                    ):
+                        if n.elements[0].get_int_value() > 0:
+                            return CountableInteger("Infinity", upper_limit=True)
+                        else:
+                            return CountableInteger(0, upper_limit=True)
+
+        return None  # leave original expression unevaluated
+
+
 class AtomBuiltin(Builtin):
     """
     This class is used to define Atoms other than those ones in core, but also
@@ -1050,7 +1146,7 @@ def eval_multi(self, expr, first, sequ, evaluation):
         return to_expression(name, to_expression(name, expr, *sequ), first)
 
 
-class Operator(Builtin, ABC):
+class Operator(Builtin):
     """
     Base Class for operators: binary, unary, nullary, prefix postfix, ...
     """
@@ -1083,7 +1179,108 @@ def get_operator_display(self) -> Optional[str]:
             return self.operator
 
 
-class Predefined(Builtin):
+# Note: Metaprogramming in mathics.builtin.no_meaning fails if
+# we inherit from ABC
+class InfixOperator(Operator):
+    """
+    Class for Mathics3 built-in Infix Operators. Infix operators are
+    represented with an operator in between each argument. A common
+    and special case is when the number of operands is two. This is
+    called a binary operator.
+
+    In Mathics3, many operators that are conventionally thought of as
+    binary operators, like Plus (+) allow an accept more than two
+    arguments.
+
+    """
+
+    # Note: grouping must be Python string, not a Symbol.
+    grouping = "System`None"  # NonAssociative, None, Left, Right
+
+    def __init__(self, *args, **kwargs):
+        super(InfixOperator, self).__init__(*args, **kwargs)
+        name = self.get_name(short=True)
+        self.precedence = self.get_precedence(name)
+
+        # Prevent pattern matching symbols from gaining meaning here using
+        # Verbatim
+        verbatim_name = f"Verbatim[{name}]"
+
+        # For compatibility, allow grouping symbols in builtins to be
+        # specified without System`.
+        self.grouping = ensure_context(self.grouping)
+
+        if self.grouping in ("System`None", "System`NonAssociative"):
+            op_pattern = f"{verbatim_name}[items__]"
+            replace_items = "items"
+        else:
+            op_pattern = f"{verbatim_name}[x_, y_]"
+            replace_items = "x, y"
+
+        operator = ascii_operator_to_symbol.get(self.operator, self.__class__.__name__)
+
+        if self.default_formats:
+            if name not in ("Rule", "RuleDelayed"):
+                formats = {
+                    op_pattern: "HoldForm[Infix[{%s}, %s, %d, %s]]"
+                    % (replace_items, operator, self.precedence, self.grouping)
+                }
+                formats.update(self.formats)
+                self.formats = formats
+            formatted = "MakeBoxes[Infix[{%s}, %s, %d,%s], form]" % (
+                replace_items,
+                operator,
+                self.precedence,
+                self.grouping,
+            )
+            default_rules = {
+                "MakeBoxes[{0}, form:StandardForm|TraditionalForm]".format(
+                    op_pattern
+                ): formatted,
+                f"MakeBoxes[{op_pattern}, form:InputForm|OutputForm]": formatted,
+            }
+            default_rules.update(self.rules)
+            self.rules = default_rules
+
+
+class NoMeaningInfixOperator(InfixOperator):
+    """
+    Operators that have no pre-defined meaning are derived from this class.
+    """
+
+    # This will be used to create a docstring
+    __doc_pattern__ = r"""
+    <url>
+    :WML link:
+    https://reference.wolfram.com/language/ref/{operator_name}.html</url>
+
+    <dl>
+      <dt>'{operator_name}[$x$, $y$, ...]'
+      <dd>displays $x$ {operator_string} $y$ {operator_string} ...
+    </dl>
+
+    >> {operator_name}[x, y, z]
+     = x {operator_string} y {operator_string} z
+
+    >> a \[{operator_name}] b
+     = a {operator_string} b
+
+    """
+    __formats_pattern__ = r"""{lbrace}
+                    (
+                           ("InputForm", "OutputForm", "StandardForm"),
+                        f"{operator_name}[args__]",
+                    ): (('Infix[{lbrace}args{rbrace}, {operator_string}"]'))
+                {rbrace}"""
+
+    attributes = A_NO_ATTRIBUTES
+    default_formats = False  # Don't use any default format rules. Instead, see below.
+
+    operator = "This should be overwritten"
+    summary_text = "This should be overwritten"
+
+
+class Predefined(Builtin, ABC):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.symbol = Symbol(self.get_name())
@@ -1095,6 +1292,9 @@ def get_functions(self, prefix="eval", is_pymodule=False) -> List[Callable]:
         return functions
 
 
+# Has to come before PostfixOperator and PrefixOperator
+# Note: Metaprogramming in mathics.builtin.no_meaning fails if
+# we inherit from ABC
 class UnaryOperator(Operator):
     """
     Class for Unary Operators, (e.g. Not, Factorial)
@@ -1119,102 +1319,125 @@ def __init__(self, format_function, *args, **kwargs):
                     self.formats[op_pattern] = form
 
 
-class PrefixOperator(UnaryOperator):
+# Note: Metaprogramming in mathics.builtin.no_meaning fails if
+# we inherit from ABC
+class PostfixOperator(UnaryOperator):
     """
-    Class for Bultin Prefix Unary Operators, e.g. Not ("¬")
+    Class for Builtin Postfix Unary Operators, e.g. Factorial (!)
     """
 
     def __init__(self, *args, **kwargs):
-        super().__init__("Prefix", *args, **kwargs)
+        super().__init__("Postfix", *args, **kwargs)
 
 
-class PostfixOperator(UnaryOperator):
+# Has to be after PostfixOperator
+class NoMeaningPostfixOperator(PostfixOperator):
     """
-    Class for Bultin Postfix Unary Operators, e.g. Factorial (!)
+    Postfix Operators that have no pre-defined meaning are derived from this class.
     """
 
-    def __init__(self, *args, **kwargs):
-        super().__init__("Postfix", *args, **kwargs)
+    # This will be used to create a docstring
+    __doc_pattern__ = r"""
+    <url>
+    :WML link:
+    https://reference.wolfram.com/language/ref/{operator_name}.html</url>
 
+    <dl>
+      <dt>'{operator_name}[$x$]'
+      <dd>displays $x$ {operator_string}
+    </dl>
 
-class BinaryOperator(Operator):
-    """
-    Class for Builtin Binary Operators, e.g. Plus (+)
-    """
+    >> {operator_name}[x]
+     = x {operator_string}
 
-    grouping = "System`None"  # NonAssociative, None, Left, Right
+    >> x \[{operator_name}]
+     = x {operator_string}
 
-    def __init__(self, *args, **kwargs):
-        super(BinaryOperator, self).__init__(*args, **kwargs)
-        name = self.get_name(short=True)
-        self.precedence = self.get_precedence(name)
+    """
+    attributes = A_NO_ATTRIBUTES
+    default_formats = False  # Don't use any default format rules. Instead, see below.
 
-        # Prevent pattern matching symbols from gaining meaning here using
-        # Verbatim
-        verbatim_name = f"Verbatim[{name}]"
+    operator = "This should be overwritten"
+    summary_text = "This should be overwritten"
 
-        # For compatibility, allow grouping symbols in builtins to be
-        # specified without System`.
-        self.grouping = ensure_context(self.grouping)
 
-        if self.grouping in ("System`None", "System`NonAssociative"):
-            op_pattern = f"{verbatim_name}[items__]"
-            replace_items = "items"
-        else:
-            op_pattern = f"{verbatim_name}[x_, y_]"
-            replace_items = "x, y"
+# Note: Metaprogramming in mathics.builtin.no_meaning fails if
+# we inherit from ABC
+class PrefixOperator(UnaryOperator):
+    """
+    Class for Builtin Prefix Unary Operators, e.g. Not ("¬")
+    """
 
-        operator = ascii_operator_to_symbol.get(self.operator, self.__class__.__name__)
+    def __init__(self, *args, **kwargs):
+        super().__init__("Prefix", *args, **kwargs)
 
-        if self.default_formats:
-            if name not in ("Rule", "RuleDelayed"):
-                formats = {
-                    op_pattern: "HoldForm[Infix[{%s}, %s, %d, %s]]"
-                    % (replace_items, operator, self.precedence, self.grouping)
-                }
-                formats.update(self.formats)
-                self.formats = formats
-            formatted = "MakeBoxes[Infix[{%s}, %s, %d,%s], form]" % (
-                replace_items,
-                operator,
-                self.precedence,
-                self.grouping,
-            )
-            default_rules = {
-                "MakeBoxes[{0}, form:StandardForm|TraditionalForm]".format(
-                    op_pattern
-                ): formatted,
-                f"MakeBoxes[{op_pattern}, form:InputForm|OutputForm]": formatted,
-            }
-            default_rules.update(self.rules)
-            self.rules = default_rules
 
+# Has to be after PrefixOperator
+class NoMeaningPrefixOperator(PrefixOperator):
+    """
+    Prefix Operators that have no pre-defined meaning are derived from this class.
+    """
 
-class Test(Builtin):
-    def eval(self, expr, evaluation) -> Optional[BooleanType]:
-        # Note: in the docstring below, we need to use %(name)s for
-        # subclasses like ExactNumberQ to work with function-application
-        # pattern matching.
-        """%(name)s[expr_]"""
-        test_expr = self.test(expr)
-        return None if test_expr is None else from_bool(bool(test_expr))
+    # This will be used to create a docstring
+    __doc_pattern__ = r"""
+    <url>
+    :WML link:
+    https://reference.wolfram.com/language/ref/{operator_name}.html</url>
 
-    def test(self, expr) -> bool:
-        """Subclasses of test must implement a boolean test function"""
-        raise NotImplementedError
+    <dl>
+      <dt>'{operator_name}[$x$]'
+      <dd>displays {operator_string} $x$
+    </dl>
 
+    >> {operator_name}[x]
+     = {operator_string}x
 
-class PatternError(Exception):
-    def __init__(self, name, tag, *args):
-        super().__init__()
-        self.name = name
-        self.tag = tag
-        self.args = args
+    >> \[{operator_name}]x
+     = {operator_string}x
 
+    """
+    attributes = A_NO_ATTRIBUTES
+    default_formats = False  # Don't use any default format rules. Instead, see below.
+
+    operator = "This should be overwritten"
+    summary_text = "This should be overwritten"
+
+
+def add_no_meaning_builtin_classes(
+    create_operator_class: Callable,
+    affix: str,
+    mathics3_format_function_name: str,
+    operator_base_class: Union[
+        NoMeaningInfixOperator, NoMeaningPostfixOperator, NoMeaningPrefixOperator
+    ],
+    builtin_module: ModuleType,
+):
+    """
+    Creates all of the operators (infix, postfix, prefix) that
+    have no pre-set builtin meaning.
+    """
+    operator_key = f"no-meaning-{affix}-operators"
+    for operator_name, operator_tuple in OPERATOR_DATA[operator_key].items():
+        operator_string = operator_tuple[0]
+        generated_operator_class = create_operator_class(
+            operator_name,
+            operator_base_class,
+            operator_string,
+            mathics3_format_function_name,
+        )
 
-class PatternArgumentError(PatternError):
-    def __init__(self, name, count, expected):
-        super().__init__(name, "argr", count, expected)
+        if affix == "infix":
+            mathics.core.parser.operators.flat_binary_ops[
+                operator_name
+            ] = operator_tuple[1]
+        elif affix == "postfix":
+            mathics.core.parser.operators.postfix_ops[operator_name] = operator_tuple[1]
+        elif affix == "prefix":
+            mathics.core.parser.operators.prefix_ops[operator_name] = operator_tuple[1]
+
+        # Put the newly-created Builtin class inside the module under
+        # mathics.builtin.no_meaning.xxx.
+        setattr(builtin_module, operator_name, generated_operator_class)
 
 
 class PatternObject(BuiltinElement, BasePattern):
@@ -1273,101 +1496,15 @@ def get_sort_key(self, pattern_sort=False) -> tuple:
         return self.expr.get_sort_key(pattern_sort=pattern_sort)
 
 
-class NegativeIntegerException(Exception):
-    pass
-
-
-@total_ordering
-class CountableInteger:
-    """
-    CountableInteger is an integer specifying a countable amount (including
-    zero) that can optionally be specified as an upper bound through UpTo[].
-    """
-
-    # currently MMA does not support UpTo[Infinity], but Infinity already shows
-    # up in UpTo's parameter error messages as supported option; it would make
-    # perfect sense. currently, we stick with MMA's current behaviour and set
-    # _support_infinity to False.
-    _finite: bool
-    _upper_limit: bool
-    _integer: Union[str, int, None]
-    _support_infinity = False
-
-    def __init__(self, value: Union[int, str] = "Infinity", upper_limit=True):
-        self._finite = value != "Infinity"
-        if self._finite:
-            assert isinstance(value, int) and value >= 0
-            self._integer = value
-        else:
-            assert upper_limit
-            self._integer = None
-        self._upper_limit = upper_limit
-
-    def is_upper_limit(self) -> bool:
-        return self._upper_limit
-
-    def get_int_value(self) -> int:
-        assert self._finite
-        return cast(int, self._integer)
-
-    def __eq__(self, other) -> bool:
-        if isinstance(other, CountableInteger):
-            if self._finite:
-                return other._finite and cast(int, self._integer) == other._integer
-            else:
-                return not other._finite
-        elif isinstance(other, int):
-            return self._finite and cast(int, self._integer) == other
-        else:
-            return False
-
-    def __lt__(self, other) -> bool:
-        if isinstance(other, CountableInteger):
-            if self._finite:
-                return other._finite and cast(int, self._integer) < cast(
-                    int, other._integer
-                )
-            else:
-                return False
-        elif isinstance(other, int):
-            return self._finite and cast(int, self._integer) < other
-        else:
-            return False
-
-    @staticmethod
-    def from_expression(expr):
-        """
-        :param expr: expression from which to build a CountableInteger
-        :return: an instance of CountableInteger or None, if the whole
-        original expression should remain unevaluated.
-        :raises: MessageException, NegativeIntegerException
-        """
-
-        if isinstance(expr, Integer):
-            py_n = expr.value
-            if py_n >= 0:
-                return CountableInteger(py_n, upper_limit=False)
-            else:
-                raise NegativeIntegerException()
-        elif expr.get_head_name() == "System`UpTo":
-            if len(expr.elements) != 1:
-                raise MessageException("UpTo", "argx", len(expr.elements))
-            else:
-                n = expr.elements[0]
-                if isinstance(n, Integer):
-                    py_n = n.value
-                    if py_n < 0:
-                        raise MessageException("UpTo", "innf", expr)
-                    else:
-                        return CountableInteger(py_n, upper_limit=True)
-                elif CountableInteger._support_infinity:
-                    if (
-                        n.get_head_name() == "System`DirectedInfinity"
-                        and len(n.elements) == 1
-                    ):
-                        if n.elements[0].get_int_value() > 0:
-                            return CountableInteger("Infinity", upper_limit=True)
-                        else:
-                            return CountableInteger(0, upper_limit=True)
+class Test(Builtin, ABC):
+    def eval(self, expr, evaluation: Evaluation) -> Optional[BooleanType]:
+        # Note: in the docstring below, we need to use %(name)s for
+        # subclasses like ExactNumberQ to work with function-application
+        # pattern matching.
+        """%(name)s[expr_]"""
+        test_expr = self.test(expr)
+        return None if test_expr is None else from_bool(bool(test_expr))
 
-        return None  # leave original expression unevaluated
+    def test(self, expr) -> bool:
+        """Subclasses of test must implement a boolean test function"""
+        raise NotImplementedError
diff --git a/mathics/core/convert/op.py b/mathics/core/convert/op.py
index 9befa33c4..f682ac118 100644
--- a/mathics/core/convert/op.py
+++ b/mathics/core/convert/op.py
@@ -5,14 +5,13 @@
 import os.path as osp
 from functools import lru_cache
 
-import pkg_resources
+from mathics.settings import ROOT_DIR
 
 try:
     import ujson
 except ImportError:
     import json as ujson  # type: ignore[no-redef]
 
-ROOT_DIR = pkg_resources.resource_filename("mathics", "")
 
 # Load the conversion tables from disk
 characters_path = osp.join(ROOT_DIR, "data", "op-tables.json")
diff --git a/mathics/core/convert/python.py b/mathics/core/convert/python.py
index 35863424f..5408c540f 100644
--- a/mathics/core/convert/python.py
+++ b/mathics/core/convert/python.py
@@ -24,12 +24,26 @@ def from_bool(arg: bool) -> BooleanType:
     return SymbolTrue if arg else SymbolFalse
 
 
+def from_complex(arg: complex) -> Complex:
+    """
+    Conversion from a Python complex to Complex.
+    Care is taken to preserve integer-ness of the
+    reall and imaginary parts
+    """
+    convert_fn = Integer if isinstance(arg.real, int) else Real
+    real_value = convert_fn(arg.real)
+    convert_fn = Integer if isinstance(arg.imag, int) else Real
+    imag_value = convert_fn(arg.imag)
+    return Complex(real_value, imag_value)
+
+
 # Historically, from_python() was identified as a bottleneck.
 
 # A large part of this was due to the inefficient monolithic
 # non-specialized interpreter that forced everything into an single
 # Expression class which tried to handle anything given it using
 # conversions.
+
 # Also, through vague or lazy coding this cause a lot of
 # unnecessary conversions.
 
@@ -39,19 +53,20 @@ def from_bool(arg: bool) -> BooleanType:
 # sure from_python() isn't too slow.
 
 
-def from_python(arg: Any) -> BaseElement:
-    """Converts a Python expression into a Mathics expression.
+# TODO:
+#  I think there are number of subtleties to be explained here.
+#  In particular, the expression might been the result of evaluation
+#  a SymPy expression which contains SymPy symbols.
+#
+#  If the end result is to go back into Mathics3 for further
+#  evaluation, then probably no problem.  However if the end result
+#  is produce say a Python string, then at a minimum we may want to
+#  convert backtick (context) symbols into some Python identifier
+#  symbol like underscore.
 
-    TODO: I think there are number of subtleties to be explained here.
-    In particular, the expression might been the result of evaluation
-    a sympy expression which contains sympy symbols.
 
-    If the end result is to go back into Mathics for further
-    evaluation, then probably no problem.  However if the end result
-    is produce say a Python string, then at a minimum we may want to
-    convert backtick (context) symbols into some Python identifier
-    symbol like underscore.
-    """
+def from_python(arg: Any) -> BaseElement:
+    """Converts a Python expression into a Mathics expression."""
     from mathics.core.convert.expression import to_mathics_list
     from mathics.core.expression import Expression
     from mathics.core.list import ListExpression
@@ -73,10 +88,8 @@ def from_python(arg: Any) -> BaseElement:
         return Real(arg)
     elif number_type == "q":
         return Rational(arg)
-    elif isinstance(arg, complex):
-        return Complex(Real(arg.real), Real(arg.imag))
-    elif number_type == "c":
-        return Complex(arg.real, arg.imag)
+    elif isinstance(arg, complex) or number_type == "c":
+        return from_complex(arg)
     elif isinstance(arg, str):
         return String(arg)
         # if arg[0] == arg[-1] == '"':
diff --git a/mathics/core/evaluation.py b/mathics/core/evaluation.py
index c6747e6a7..9d7d75a11 100644
--- a/mathics/core/evaluation.py
+++ b/mathics/core/evaluation.py
@@ -4,8 +4,6 @@
 import sys
 import time
 from abc import ABC
-from queue import Queue
-from threading import Thread, stack_size as set_thread_stack_size
 from typing import Any, Callable, Dict, List, Optional, Tuple, Union, overload
 
 from mathics_scanner import TranslateError
@@ -57,16 +55,6 @@
 SymbolPrePrint = Symbol("System`$PrePrint")
 SymbolPost = Symbol("System`$Post")
 
-
-def _thread_target(request, queue) -> None:
-    try:
-        result = request()
-        queue.put((True, result))
-    except BaseException:
-        exc_info = sys.exc_info()
-        queue.put((False, exc_info))
-
-
 # MAX_RECURSION_DEPTH gives the maximum value allowed for $RecursionLimit. it's usually set to its
 # default settings.DEFAULT_MAX_RECURSION_DEPTH.
 
@@ -96,53 +84,6 @@ def set_python_recursion_limit(n) -> None:
         raise OverflowError
 
 
-def run_with_timeout_and_stack(request, timeout, evaluation):
-    """
-    interrupts evaluation after a given time period. Provides a suitable stack environment.
-    """
-
-    # only use set_thread_stack_size if max recursion depth was changed via the environment variable
-    # MATHICS_MAX_RECURSION_DEPTH. if it is set, we always use a thread, even if timeout is None, in
-    # order to be able to set the thread stack size.
-
-    if MAX_RECURSION_DEPTH > settings.DEFAULT_MAX_RECURSION_DEPTH:
-        set_thread_stack_size(python_stack_size(MAX_RECURSION_DEPTH))
-    elif timeout is None:
-        return request()
-
-    queue = Queue(maxsize=1)  # stores the result or exception
-    thread = Thread(target=_thread_target, args=(request, queue))
-    thread.start()
-
-    # Thead join(timeout) can leave zombie threads (we are the parent)
-    # when a time out occurs, but the thread hasn't terminated.  See
-    # https://docs.python.org/3/library/multiprocessing.shared_memory.html
-    # for a detailed discussion of this.
-    #
-    # To reduce this problem, we make use of specific properties of
-    # the Mathics3 evaluator: if we set "evaluation.timeout", the
-    # next call to "Expression.evaluate" in the thread will finish it
-    # immediately.
-    #
-    # However this still will not terminate long-running processes
-    # in Sympy or or libraries called by Mathics3 that might hang or run
-    # for a long time.
-    thread.join(timeout)
-    if thread.is_alive():
-        evaluation.timeout = True
-        while thread.is_alive():
-            pass
-        evaluation.timeout = False
-        evaluation.stopped = False
-        raise TimeoutInterrupt()
-
-    success, result = queue.get()
-    if success:
-        return result
-    else:
-        raise result[0].with_traceback(result[1], result[2])
-
-
 class _Out(KeyComparable):
     def __init__(self) -> None:
         self.is_message = False
@@ -187,6 +128,8 @@ def __init__(
         # ``mathics.builtin.numeric.N``.
         self._preferred_n_method: List[str] = []
 
+        self.is_boxing = False
+
     def parse(self, query, src_name: str = ""):
         "Parse a single expression and print the messages."
         from mathics.core.parser import MathicsSingleLineFeeder
@@ -295,7 +238,7 @@ def evaluate():
 
         try:
             try:
-                result = run_with_timeout_and_stack(evaluate, timeout, self)
+                result = evaluate()
             except KeyboardInterrupt:
                 if self.catch_interrupt:
                     self.exc_result = SymbolAborted
@@ -509,6 +452,7 @@ def print_out(self, text) -> None:
         if self.definitions.trace_evaluation:
             self.definitions.trace_evaluation = False
             text = self.format_output(from_python(text), "text")
+            self.is_boxing = False
             self.definitions.trace_evaluation = True
         else:
             text = self.format_output(from_python(text), "text")
diff --git a/mathics/core/expression.py b/mathics/core/expression.py
index 693b14bc2..b68a9a64c 100644
--- a/mathics/core/expression.py
+++ b/mathics/core/expression.py
@@ -2,7 +2,6 @@
 # -*- coding: utf-8 -*-
 
 import math
-import time
 from bisect import bisect_left
 from itertools import chain
 from typing import (
@@ -78,6 +77,7 @@
     SymbolSubtract,
     SymbolUnevaluated,
 )
+from mathics.eval.tracing import trace_evaluate
 
 # from mathics.timing import timeit
 
@@ -521,6 +521,7 @@ def equal2(self, rhs: Any) -> Optional[bool]:
     # Note that the return type is some subclass of BaseElement, it could be
     # a Real, an Expression, etc. It probably will *not* be a BaseElement since
     # the point of evaluation when there is not an error is to produce a concrete result.
+    @trace_evaluate
     def evaluate(
         self,
         evaluation: Evaluation,
@@ -544,12 +545,6 @@ def evaluate(
 
         old_options = evaluation.options
         evaluation.inc_recursion_depth()
-        if evaluation.definitions.trace_evaluation:
-            if evaluation.definitions.timing_trace_evaluation:
-                evaluation.print_out(time.time() - evaluation.start_time)
-            evaluation.print_out(
-                "  " * evaluation.recursion_depth + "Evaluating: %s" % expr
-            )
         try:
             # Evaluation loop:
             while reevaluate:
diff --git a/mathics/core/load_builtin.py b/mathics/core/load_builtin.py
index 5e255e2ab..41d5f1aec 100644
--- a/mathics/core/load_builtin.py
+++ b/mathics/core/load_builtin.py
@@ -17,6 +17,7 @@
 from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple
 
 from mathics.core.convert.sympy import mathics_to_sympy, sympy_to_mathics
+from mathics.core.parser.operators import calculate_operator_information
 from mathics.core.pattern import pattern_objects
 from mathics.core.symbols import Symbol
 from mathics.eval.makeboxes import builtins_precedence
@@ -133,6 +134,8 @@ def definition_contribute(definitions):
     # All builtins are loaded. Create dummy builtin definitions for
     # any remaining operators that don't have them. This allows
     # operators like \[Cup] to behave correctly.
+
+    calculate_operator_information()
     for operator in all_operator_names:
         if not definitions.have_definition(ensure_context(operator)):
             op = ensure_context(operator)
diff --git a/mathics/core/parser/__init__.py b/mathics/core/parser/__init__.py
index 8ad4654db..cdc9ffc6f 100644
--- a/mathics/core/parser/__init__.py
+++ b/mathics/core/parser/__init__.py
@@ -10,7 +10,7 @@
 """
 
 
-from mathics_scanner import is_symbol_name
+from mathics_scanner.tokeniser import is_symbol_name
 
 from mathics.core.parser.feed import (
     MathicsFileLineFeeder,
diff --git a/mathics/core/parser/operators.py b/mathics/core/parser/operators.py
index 2489abfd8..238f1c25c 100644
--- a/mathics/core/parser/operators.py
+++ b/mathics/core/parser/operators.py
@@ -1,190 +1,91 @@
-#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
+"""Mathics3 Operator tables.
 
+This information is controlled by data from the MathicsScanner Project,
+from YAML tables which are converted to JSON.
 
+The dictionary from these which are read in here, are used by the
+Mathics3 parser.
+"""
+
+
+import os.path as osp
 from collections import defaultdict
 
-prefix_ops = {
-    "Get": 720,
-    "PreIncrement": 660,
-    "PreDecrement": 660,
-    "Del": 550,
-    "Minus": 480,
-    "Square": 540,
-    "ForAll": 240,
-    "Exists": 240,
-    "NotExists": 240,
-    "Not": 230,
-    "Information": 5001,
-    "Definition": 5000,
-    "InterpretedBox": 670,
-}
-
-postfix_ops = {
-    "Unset": 670,
-    "Conjugate": 670,
-    "Transpose": 670,
-    "ConjugateTranspose": 670,
-    "Derivative": 670,
-    "Increment": 660,
-    "Decrement": 660,
-    "Factorial": 610,
-    "Factorial2": 610,
-    "Repeated": 170,
-    "RepeatedNull": 170,
-    "Function": 90,
-}
-
-left_binary_ops = {
-    "Divide": 470,
-    "PlusMinus": 310,
-    "MinusPlus": 310,
-    "Subtract": 310,
-    "LeftTee": 190,
-    "DoubleLeftTee": 190,
-    "Condition": 130,
-    "ReplaceAll": 110,
-    "ReplaceRepeated": 110,
-    "Because": 50,
-    "PutAppend": 30,
-    "Put": 30,
-    "Postfix": 70,
-}
-
-right_binary_ops = {
-    "Apply": 620,
-    "Map": 620,
-    "MapAll": 620,
-    "Power": 590,
-    "Implies": 200,
-    "RightTee": 190,
-    "DoubleRightTee": 190,
-    "SuchThat": 180,
-    "Rule": 120,
-    "RuleDelayed": 120,
-    "AddTo": 100,
-    "SubtractFrom": 100,
-    "TimesBy": 100,
-    "DivideBy": 100,
-    "Therefore": 50,
-    "UpSet": 40,
-    "Set": 40,
-    "SetDelayed": 40,
-    "UpSetDelayed": 40,
-}
-
-flat_binary_ops = {
-    "MessageName": 750,
-    "Composition": 625,
-    "StringJoin": 600,
-    "SmallCircle": 530,
-    "CircleDot": 520,
-    "NonCommutativeMultiply": 510,
-    "Cross": 500,
-    "Union": 300,
-    "Dot": 490,
-    "Backslash": 460,
-    "Diamond": 450,
-    "Wedge": 440,
-    "Vee": 430,
-    "CircleTimes": 420,
-    "CenterDot": 410,
-    "Times": 400,
-    "VerticalTilde": 370,
-    "Coproduct": 360,
-    "Cap": 350,
-    "Cup": 340,
-    "Star": 390,
-    "CirclePlus": 330,
-    "CircleMinus": 330,
-    "Plus": 310,
-    "Intersection": 305,
-    "VerticalBar": 280,
-    "NotVerticalBar": 280,
-    "DoubleVerticalBar": 280,
-    "NotDoubleVerticalBar": 280,
-    "SameQ": 290,
-    "UnsameQ": 290,
-    "Equal": 290,
-    "Unequal": 290,
-    "Greater": 290,
-    "Less": 290,
-    "GreaterEqual": 290,
-    "LessEqual": 290,
-    "Element": 250,
-    "NotElement": 250,
-    "Subset": 250,
-    "Superset": 250,
-    # HACK: although the should be 215 for all boolean_ops we adjust slightly
-    # to get the subprecedences correct
-    "And": 225,
-    "Nand": 225,
-    "Xor": 220,
-    "Xnor": 220,
-    "Or": 215,
-    "Nor": 215,
-    "Equivalent": 205,
-    "Alternatives": 160,
-    "StringExpression": 135,
-    "Colon": 80,
-    "VerticalSeparator": 60,
-    "CompoundExpression": 10,
-}
-
-nonassoc_binary_ops = {
-    "UndirectedEdge": 120,
-    "DirectedEdge": 128,
-    "PatternTest": 680,
-}
-
-ternary_ops = {
-    "Span": 305,
-    "Infix": 630,
-}
-
-misc_ops = {
-    "DifferentialD": 550,
-    "Sum": 320,
-    "Pattern": 150,
-    "Optional": 140,
-    "SqrtBox": 670,
-    "RadicalBox": 670,
-    "FractionBox": 670,
-    "OverscriptBox": 710,
-    "UnderscriptBox": 710,
-    "SubscriptBox": 695,
-    "FormBox": 670,
-    "SuperscriptBox": 590,
-    "UnderoverscriptBox": 700,
-    "SubsuperscriptBox": 690,
-}
+from mathics.settings import ROOT_DIR
+
+try:
+    import ujson
+except ImportError:
+    import json as ujson  # type: ignore[no-redef]
+
+# Load Mathics3 operator information from JSON. This file is derived from a
+# Mathics3 Operator Data YAML file in MathicsScanner.
+operator_tables_path = osp.join(ROOT_DIR, "data", "operator-tables.json")
+assert osp.exists(
+    operator_tables_path
+), f"Internal error: Mathics3 Operator information are missing; expected to be in {operator_tables_path}"
+with open(operator_tables_path, "r") as f:
+    OPERATOR_DATA = ujson.load(f)
+
+flat_binary_ops = OPERATOR_DATA["flat-binary-operators"]
+left_binary_ops = OPERATOR_DATA["left-binary-operators"]
+misc_ops = OPERATOR_DATA["miscellaneous-operators"]
+nonassoc_binary_ops = OPERATOR_DATA["non-associative-binary-operators"]
+postfix_ops = OPERATOR_DATA["postfix-operators"]
+prefix_ops = OPERATOR_DATA["prefix-operators"]
+right_binary_ops = OPERATOR_DATA["right-binary-operators"]
+ternary_ops = OPERATOR_DATA["ternary-operators"]
 
 inequality_ops = ["Less", "LessEqual", "Greater", "GreaterEqual", "Equal", "Unequal"]
 
 # binary_ops = left_binary_ops V right_binary_ops V flat_binary_ops V nonassoc_binary_ops
 binary_ops = {}
-for ops in (left_binary_ops, right_binary_ops, flat_binary_ops, nonassoc_binary_ops):
-    for op, prec in ops.items():
-        binary_ops[op] = prec
-
-all_op_collections = (
-    prefix_ops,
-    postfix_ops,
-    left_binary_ops,
-    right_binary_ops,
-    flat_binary_ops,
-    ternary_ops,
-    nonassoc_binary_ops,
-    misc_ops,
-)
 
 # all ops - check they're disjoint
 all_ops = defaultdict(lambda: 670)
 
-for ops in all_op_collections:
-    for op, prec in ops.items():
-        if op in all_ops:
-            raise AssertionError
-        all_ops[op] = prec
+# Set below
+all_operator_names = []
+
+
+def calculate_operator_information():
+    global binary_ops
+    global all_ops
+    global all_operator_names
+
+    all_operator_names = []
+
+    for ops in (
+        left_binary_ops,
+        right_binary_ops,
+        flat_binary_ops,
+        nonassoc_binary_ops,
+    ):
+        for op, prec in ops.items():
+            binary_ops[op] = prec
+
+    all_op_collections = (
+        prefix_ops,
+        postfix_ops,
+        left_binary_ops,
+        right_binary_ops,
+        flat_binary_ops,
+        ternary_ops,
+        nonassoc_binary_ops,
+        misc_ops,
+    )
+
+    for ops in all_op_collections:
+        for op, prec in ops.items():
+            all_ops[op] = prec
+
+    all_operator_names = list(all_ops.keys())
+
+
+# Calculating operator information is also done
+# after loading in Builtin operators with no-meaning.
+# However we also need to do this before reading that module in.
+# This is a mess!
 
-all_operator_names = list(all_ops.keys())
+calculate_operator_information()
diff --git a/mathics/core/parser/parser.py b/mathics/core/parser/parser.py
index 6dce91f88..9c0029954 100644
--- a/mathics/core/parser/parser.py
+++ b/mathics/core/parser/parser.py
@@ -10,13 +10,8 @@
 import string
 from typing import Optional, Union
 
-from mathics_scanner import (
-    InvalidSyntaxError,
-    Tokeniser,
-    TranslateError,
-    is_symbol_name,
-)
-from mathics_scanner.tokeniser import Token
+from mathics_scanner import InvalidSyntaxError, TranslateError
+from mathics_scanner.tokeniser import Token, Tokeniser, is_symbol_name
 
 from mathics.core.parser.ast import (
     Filename,
@@ -35,7 +30,6 @@
     flat_binary_ops,
     inequality_ops,
     left_binary_ops,
-    misc_ops,
     nonassoc_binary_ops,
     postfix_ops,
     prefix_ops,
@@ -795,7 +789,7 @@ def b_SqrtBox(self, box0, token: Token, p: int) -> Optional[Node]:
         if box0 is not None:
             return None
         self.consume()
-        q = misc_ops["SqrtBox"]
+        q = all_ops["SqrtBox"]
         box1 = self.parse_box(q)
         if self.next().tag == "OtherscriptBox":
             self.consume()
@@ -805,7 +799,7 @@ def b_SqrtBox(self, box0, token: Token, p: int) -> Optional[Node]:
             return Node("SqrtBox", box1)
 
     def b_SuperscriptBox(self, box1, token: Token, p: int) -> Optional[Node]:
-        q = misc_ops["SuperscriptBox"]
+        q = all_ops["SuperscriptBox"]
         if q < p:
             return None
         if box1 is None:
@@ -814,13 +808,13 @@ def b_SuperscriptBox(self, box1, token: Token, p: int) -> Optional[Node]:
         box2 = self.parse_box(q)
         if self.next().tag == "OtherscriptBox":
             self.consume()
-            box3 = self.parse_box(misc_ops["SubsuperscriptBox"])
+            box3 = self.parse_box(all_ops["SubsuperscriptBox"])
             return Node("SubsuperscriptBox", box1, box3, box2)
         else:
             return Node("SuperscriptBox", box1, box2)
 
     def b_SubscriptBox(self, box1, token: Token, p: int) -> Optional[Node]:
-        q = misc_ops["SubscriptBox"]
+        q = all_ops["SubscriptBox"]
         if q < p:
             return None
         if box1 is None:
@@ -829,13 +823,13 @@ def b_SubscriptBox(self, box1, token: Token, p: int) -> Optional[Node]:
         box2 = self.parse_box(q)
         if self.next().tag == "OtherscriptBox":
             self.consume()
-            box3 = self.parse_box(misc_ops["SubsuperscriptBox"])
+            box3 = self.parse_box(all_ops["SubsuperscriptBox"])
             return Node("SubsuperscriptBox", box1, box2, box3)
         else:
             return Node("SubscriptBox", box1, box2)
 
     def b_UnderscriptBox(self, box1, token: Token, p: int) -> Optional[Node]:
-        q = misc_ops["UnderscriptBox"]
+        q = all_ops["UnderscriptBox"]
         if q < p:
             return None
         if box1 is None:
@@ -844,13 +838,13 @@ def b_UnderscriptBox(self, box1, token: Token, p: int) -> Optional[Node]:
         box2 = self.parse_box(q)
         if self.next().tag == "OtherscriptBox":
             self.consume()
-            box3 = self.parse_box(misc_ops["UnderoverscriptBox"])
+            box3 = self.parse_box(all_ops["UnderoverscriptBox"])
             return Node("UnderoverscriptBox", box1, box2, box3)
         else:
             return Node("UnderscriptBox", box1, box2)
 
     def b_FractionBox(self, box1, token: Token, p: int) -> Optional[Node]:
-        q = misc_ops["FractionBox"]
+        q = all_ops["FractionBox"]
         if q < p:
             return None
         if box1 is None:
@@ -860,7 +854,7 @@ def b_FractionBox(self, box1, token: Token, p: int) -> Optional[Node]:
         return Node("FractionBox", box1, box2)
 
     def b_FormBox(self, box1, token: Token, p: int) -> Optional[Node]:
-        q = misc_ops["FormBox"]
+        q = all_ops["FormBox"]
         if q < p:
             return None
         if box1 is None:
@@ -874,7 +868,7 @@ def b_FormBox(self, box1, token: Token, p: int) -> Optional[Node]:
         return Node("FormBox", box2, box1)
 
     def b_OverscriptBox(self, box1, token: Token, p: int) -> Optional[Node]:
-        q = misc_ops["OverscriptBox"]
+        q = all_ops["OverscriptBox"]
         if q < p:
             return None
         if box1 is None:
@@ -883,7 +877,7 @@ def b_OverscriptBox(self, box1, token: Token, p: int) -> Optional[Node]:
         box2 = self.parse_box(q)
         if self.next().tag == "OtherscriptBox":
             self.consume()
-            box3 = self.parse_box(misc_ops["UnderoverscriptBox"])
+            box3 = self.parse_box(all_ops["UnderoverscriptBox"])
             return Node("UnderoverscriptBox", box1, box3, box2)
         else:
             return Node("OverscriptBox", box1, box2)
diff --git a/mathics/core/pattern.py b/mathics/core/pattern.py
index d16847440..2fa2ce80c 100644
--- a/mathics/core/pattern.py
+++ b/mathics/core/pattern.py
@@ -701,7 +701,12 @@ def match_expression_with_one_identity(
             isinstance(pat_elem, PatternObject)
             and pat_elem.get_head() == SymbolOptional
         ):
-            if len(pat_elem.elements) == 2:
+            if optionals:
+                # A default pattern already exists
+                # Do not use the second one
+                if new_pattern is None:
+                    new_pattern = pat_elem
+            elif len(pat_elem.elements) == 2:
                 pat, value = pat_elem.elements
                 if isinstance(pat, Pattern):
                     key = pat.elements[0].atom.name  # type: ignore[attr-defined]
@@ -724,8 +729,12 @@ def match_expression_with_one_identity(
                 result = defaultvalue_expr.evaluate(evaluation)
                 assert result is not None
                 if result.sameQ(defaultvalue_expr):
-                    return
-                optionals[key] = result
+                    if new_pattern is None:
+                        # The optional pattern has no default value
+                        # for the given position
+                        new_pattern = pat_elem
+                else:
+                    optionals[key] = result
             else:
                 return
         elif new_pattern is not None:
@@ -757,6 +766,8 @@ def match_expression_with_one_identity(
     del parms["attributes"]
     assert new_pattern is not None
     new_pattern.match(expression=expression, pattern_context=parms)
+    for optional in optionals:
+        vars_dict.pop(optional)
 
 
 def basic_match_expression(
diff --git a/mathics/core/streams.py b/mathics/core/streams.py
index 1fe46a7aa..e2c48c356 100644
--- a/mathics/core/streams.py
+++ b/mathics/core/streams.py
@@ -115,6 +115,7 @@ def __init__(
         self,
         name: str,
         mode="r",
+        path: Optional[str] = None,
         encoding=None,
         io=None,
         channel_num=None,
@@ -124,7 +125,10 @@ def __init__(
             channel_num = stream_manager.next
         if mode is None:
             mode = "r"
-        self.name = name
+        if path is None:
+            path = name
+        self.name = name  # name provided by user
+        self.path = path  # resolved path name
         self.mode = mode
         self.encoding = encoding
         self.io = io
@@ -151,8 +155,9 @@ def __enter__(self):
         # open the stream
         fp = io_open(path, self.mode, encoding=encoding)
         stream_manager.add(
-            name=path,
+            name=self.name,
             mode=self.mode,
+            path=path,
             encoding=encoding,
             io=fp,
             is_temporary_file=is_temporary_file,
@@ -188,6 +193,7 @@ def add(
         self,
         name: str,
         mode: Optional[str] = None,
+        path: Optional[str] = None,
         encoding=None,
         io=None,
         num: Optional[int] = None,
@@ -195,12 +201,17 @@ def add(
     ) -> Optional["Stream"]:
         if num is None:
             num = self.next
+            assert isinstance(num, int)
             # In theory in this branch we won't find num.
+        if path is None:
+            path = name
+        if mode is None:
+            mode = "r"
         # sanity check num
         found = self.lookup_stream(num)
         if found and found is not None:
             raise Exception(f"Stream {num} already open")
-        stream = Stream(name, mode, encoding, io, num, is_temporary_file)
+        stream = Stream(name, mode, path, encoding, io, num, is_temporary_file)
         self.STREAMS[num] = stream
         return stream
 
@@ -218,9 +229,19 @@ def delete_stream(self, stream: Stream):
         """
         is_temporary_file = stream.is_temporary_file
         if is_temporary_file:
-            os.unlink(stream.name)
+            os.unlink(stream.path)
         del self.STREAMS[stream.n]
 
+    def get_stream_by_name(self, name: str) -> Optional[Stream]:
+        """
+        Find and return a stream given its stream name.
+        Return None if not stream is found.
+        """
+        for i in self.STREAMS:
+            if self.STREAMS[i].name == name:
+                return self.STREAMS[i]
+        return None
+
     def lookup_stream(self, n: int) -> Optional[Stream]:
         """
         Find and return a stream given is stream number `n`.
diff --git a/mathics/core/symbols.py b/mathics/core/symbols.py
index 536b759f6..f603d38a4 100644
--- a/mathics/core/symbols.py
+++ b/mathics/core/symbols.py
@@ -1,7 +1,6 @@
 # cython: language_level=3
 # -*- coding: utf-8 -*-
 
-import time
 from typing import TYPE_CHECKING, Any, Dict, FrozenSet, List, Optional, Sequence, Union
 
 from mathics.core.element import (
@@ -14,6 +13,8 @@
 if TYPE_CHECKING:
     from mathics.core.atoms import String
 
+from mathics.eval.tracing import trace_evaluate
+
 # I put this constants here instead of inside `mathics.core.convert.sympy`
 # to avoid a circular reference. Maybe they should be in its own module.
 
@@ -483,18 +484,12 @@ def equal2(self, rhs: Any) -> Optional[bool]:
             return self == rhs
         return None
 
+    @trace_evaluate
     def evaluate(self, evaluation):
         """
         Evaluates the symbol by applying the rules (ownvalues) in its definition,
         recursively.
         """
-        if evaluation.definitions.trace_evaluation:
-            if evaluation.definitions.timing_trace_evaluation:
-                evaluation.print_out(time.time() - evaluation.start_time)
-            evaluation.print_out(
-                "  " * evaluation.recursion_depth + "  Evaluating: %s" % self
-            )
-
         rules = evaluation.definitions.get_ownvalues(self.name)
         for rule in rules:
             result = rule.apply(self, evaluation, fully=True)
@@ -575,7 +570,17 @@ def get_attributes(self, definitions):
         return definitions.get_attributes(self.name)
 
     def get_name(self, short=False) -> str:
-        return self.name
+        """
+        Returns symbol's name field. If short=True
+        we strip off the context parts.
+
+        Note however that many places in the code we do not need the
+        "short" parameter becasue of Definitions.shorten_name() which
+        keeps track of the current $Context and $ContextPath to decide
+        whether the name of a symbol should or should not be
+        shortened.
+        """
+        return self.name.split("`")[-1] if short else self.name
 
     def get_sort_key(self, pattern_sort=False) -> tuple:
         if pattern_sort:
@@ -735,9 +740,12 @@ def value(self):
         return self._value
 
 
-# A BooleanType is a special form of SymbolConstant where the value
-# of the constant is either SymbolTrue or SymbolFalse.
-BooleanType = SymbolConstant
+class BooleanType(SymbolConstant):
+    """A Special form of SymbolConstant where the value
+    the constant is either SymbolTrue or SymbolFalse.
+    """
+
+    pass
 
 
 def symbol_set(*symbols: Symbol) -> FrozenSet[Symbol]:
@@ -766,9 +774,9 @@ def symbol_set(*symbols: Symbol) -> FrozenSet[Symbol]:
 # more of the below and in systemsymbols
 # PredefineSymbol.
 
-SymbolFalse = SymbolConstant("System`False", value=False)
+SymbolFalse = BooleanType("System`False", value=False)
 SymbolList = SymbolConstant("System`List", value=list)
-SymbolTrue = SymbolConstant("System`True", value=True)
+SymbolTrue = BooleanType("System`True", value=True)
 
 SymbolAbs = Symbol("Abs")
 SymbolDivide = Symbol("Divide")
diff --git a/mathics/core/systemsymbols.py b/mathics/core/systemsymbols.py
index fa58e546b..892763bd0 100644
--- a/mathics/core/systemsymbols.py
+++ b/mathics/core/systemsymbols.py
@@ -191,6 +191,7 @@
 SymbolPath = Symbol("System`$Path")
 SymbolPattern = Symbol("System`Pattern")
 SymbolPatternTest = Symbol("System`PatternTest")
+SymbolPause = Symbol("System`Pause")
 SymbolPi = Symbol("System`Pi")
 SymbolPiecewise = Symbol("System`Piecewise")
 SymbolPlot = Symbol("System`Plot")
diff --git a/mathics/docpipeline.py b/mathics/docpipeline.py
index dc53cff31..11cb6b779 100644
--- a/mathics/docpipeline.py
+++ b/mathics/docpipeline.py
@@ -938,6 +938,9 @@ def main():
         test_pipeline.print_and_log(
             f"Test evaluation took {datetime.now() - start_time} seconds"
         )
+        test_pipeline.print_and_log(
+            f"Test finished at {datetime.now().strftime('%d/%m/%Y %H:%M:%S')}"
+        )
 
     if args.show_statistics:
         show_lru_cache_statistics()
diff --git a/mathics/eval/assignments/__init__.py b/mathics/eval/assignments/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/mathics/eval/assignments/assign_binaryop.py b/mathics/eval/assignments/assign_binaryop.py
new file mode 100644
index 000000000..318e187c7
--- /dev/null
+++ b/mathics/eval/assignments/assign_binaryop.py
@@ -0,0 +1,30 @@
+"""
+evaluation functions associated with the mathics.builtin.assign_binary_op
+module.
+"""
+from mathics.core.evaluation import Evaluation
+from mathics.core.expression import Expression
+from mathics.core.systemsymbols import SymbolSet
+
+
+def eval_inplace_op(
+    self, x, operator, increment, returns_updated_value: bool, evaluation: Evaluation
+):
+    """
+    Perform: Set[x, operator[x, increment]]
+
+    For example if operator is + and increment is 1, perform x += 1
+
+    If returns_updated_value is True, return the value after performing
+    the update operation. Otherwise return the value before it was
+    modified.
+    """
+    value_before_update = x.evaluate(evaluation)
+    if x == value_before_update:
+        evaluation.message(self.__class__.__name__, "rvalue", x)
+        return
+
+    updated_value = Expression(
+        SymbolSet, x, Expression(operator, x, increment).evaluate(evaluation)
+    ).evaluate(evaluation)
+    return updated_value if returns_updated_value else value_before_update
diff --git a/mathics/eval/distance.py b/mathics/eval/distance/clusters.py
similarity index 94%
rename from mathics/eval/distance.py
rename to mathics/eval/distance/clusters.py
index 9eacc55ad..ad4c0ec15 100644
--- a/mathics/eval/distance.py
+++ b/mathics/eval/distance/clusters.py
@@ -1,5 +1,5 @@
 """
-Distance-related evaluation functions and exception classes
+mathics.distance.clusters evaluation functions and exception classes
 """
 
 from mathics.core.atoms import Integer, Real
diff --git a/mathics/eval/distance/numeric.py b/mathics/eval/distance/numeric.py
new file mode 100644
index 000000000..f6e423245
--- /dev/null
+++ b/mathics/eval/distance/numeric.py
@@ -0,0 +1,49 @@
+from sympy.core.power import Mul, Pow
+
+from mathics.core.atoms import Complex, Integer, Integer0, Real
+from mathics.core.convert.sympy import from_sympy, to_sympy_matrix
+from mathics.eval.arithmetic import eval_Abs
+
+
+def eval_CosineDistance(u, v):
+    "CosineDistance[u_, v_]"
+
+    # We follow pretty much what is done in Symja in ClusteringFunctions.java for this:
+    # https://github.com/axkr/symja_android_library/blob/master/symja_android_library/matheclipse-core/src/main/java/org/matheclipse/core/builtin/ClusteringFunctions.java#L377-L386
+    # Some extensions for degenerate cases have been added.
+
+    # Handle some degenerate cases
+    if isinstance(u, (Complex, Integer, Real)) and isinstance(
+        v, (Complex, Integer, Real)
+    ):
+        u_abs = eval_Abs(u)
+        if u_abs is None:
+            return
+        v_abs = eval_Abs(v)
+        if v_abs is None:
+            return
+
+        # Do the following, but using SymPy expressions:
+        #   distance = 1 - (u * v.conjugate()) / (abs(u) * abs(v))
+        numerator = Mul(u.to_sympy(), v.to_sympy().conjugate())
+        divisor_product = Mul(u_abs.to_sympy(), v_abs.to_sympy())
+        distance = 1 - numerator * Pow(divisor_product, -1)
+        result = from_sympy(distance)
+        if (isinstance(u, Real) or isinstance(v, Real)) and isinstance(result, Integer):
+            result = Real(result.value)
+        return result
+
+    sym_u = to_sympy_matrix(u)
+    if sym_u is None:
+        return
+    sym_v = to_sympy_matrix(v)
+    if sym_v is None:
+        return
+    u_norm = sym_u.norm()
+    if u_norm == 0:
+        return Integer0
+    v_norm = sym_v.norm()
+    if v_norm == 0:
+        return Integer0
+
+    return from_sympy(1 - sym_u.dot(sym_v.conjugate()) / (u_norm * v_norm))
diff --git a/mathics/eval/files_io/files.py b/mathics/eval/files_io/files.py
index 0a1578c3f..14b0980c1 100644
--- a/mathics/eval/files_io/files.py
+++ b/mathics/eval/files_io/files.py
@@ -200,7 +200,9 @@ def eval_Read(
                     except Exception as e:
                         print(e)
 
-                if expr is SymbolEndOfFile:
+                if expr is None:
+                    result.append(None)
+                elif expr is SymbolEndOfFile:
                     evaluation.message(name, "readt", tmp, String(stream.name))
                     return SymbolFailed
                 elif isinstance(expr, BaseElement):
@@ -275,5 +277,10 @@ def eval_Read(
             return [from_python(part) for part in result]
         elif result_len == 1:
             result = result[0]
+            if SymbolHoldExpression in types:
+                if hasattr(result, "head") and result.head is SymbolHold:
+                    return from_python(result)
+                else:
+                    return Expression(SymbolHold, from_python(result))
 
     return from_python(result)
diff --git a/mathics/eval/files_io/read.py b/mathics/eval/files_io/read.py
index 4a75756a9..bee7f2b92 100644
--- a/mathics/eval/files_io/read.py
+++ b/mathics/eval/files_io/read.py
@@ -54,7 +54,12 @@ class MathicsOpen(Stream):
     """
 
     def __init__(
-        self, file: str, mode: str = "r", encoding=None, is_temporary_file: bool = False
+        self,
+        path: str,
+        mode: str = "r",
+        name=None,
+        encoding=None,
+        is_temporary_file: bool = False,
     ):
         if encoding is not None:
             encoding = to_python_encoding(encoding)
@@ -64,7 +69,9 @@ def __init__(
             elif encoding is None:
                 raise MessageException("General", "charcode", self.encoding)
         self.encoding = encoding
-        super().__init__(file, mode, self.encoding)
+        if name is None:
+            name = path
+        super().__init__(name, mode=mode, path=path, encoding=self.encoding)
         self.is_temporary_file = is_temporary_file
 
         # The following are set in __enter__ and __exit__
@@ -85,8 +92,9 @@ def __enter__(self, is_temporary_file=False):
 
         # Add to our internal list of streams
         self.stream = stream_manager.add(
-            name=path,
+            name=self.name,
             mode=self.mode,
+            path=path,
             encoding=self.encoding,
             io=self.fp,
             num=stream_manager.next,
diff --git a/mathics/eval/makeboxes.py b/mathics/eval/makeboxes.py
index 80e484f66..dde648044 100644
--- a/mathics/eval/makeboxes.py
+++ b/mathics/eval/makeboxes.py
@@ -257,6 +257,7 @@ def format_element(
     """
     Applies formats associated to the expression, and then calls Makeboxes
     """
+
     # Strip repeated form
     while element.get_head() is form:
         element = element.elements[0]
@@ -275,6 +276,7 @@ def format_element(
     if element.has_form("OutputForm", 1):
         return makeboxes_outputform(element.elements[0], evaluation, form)
 
+    evaluation.is_boxing = True
     expr = do_format(element, evaluation, form)
     if expr is None:
         return None
diff --git a/mathics/eval/sympy.py b/mathics/eval/sympy.py
new file mode 100644
index 000000000..4547ee785
--- /dev/null
+++ b/mathics/eval/sympy.py
@@ -0,0 +1,30 @@
+"""
+Evaluation of SymPy functions
+"""
+
+from typing import Optional
+
+import sympy
+
+import mathics.eval.tracing as tracing
+from mathics.core.convert.sympy import from_sympy, to_numeric_sympy_args
+from mathics.core.element import BaseElement
+from mathics.core.evaluation import Evaluation
+
+
+def eval_sympy(self, z: BaseElement, evaluation: Evaluation) -> Optional[BaseElement]:
+    """
+    Evaluate element `z` converting it to SymPy and back to Mathics3.
+    If an exception is raised we return None.
+
+    This version is called not-wrapped in a thread on systems like
+    emscripten that do not support Python-style threading.
+    """
+    sympy_args = to_numeric_sympy_args(z, evaluation)
+    if self.sympy_name is None:
+        return
+    sympy_fn = getattr(sympy, self.sympy_name)
+    try:
+        return from_sympy(tracing.run_sympy(sympy_fn, *sympy_args))
+    except Exception:
+        return
diff --git a/mathics/eval/testing_expressions.py b/mathics/eval/testing_expressions.py
index e0b8a6f28..419acccca 100644
--- a/mathics/eval/testing_expressions.py
+++ b/mathics/eval/testing_expressions.py
@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, Union
 
 import sympy
 
@@ -6,7 +6,7 @@
 from mathics.core.evaluation import Evaluation
 from mathics.core.expression import Expression
 from mathics.core.rules import BasePattern
-from mathics.core.symbols import SymbolFalse, SymbolTimes, SymbolTrue
+from mathics.core.symbols import BooleanType, SymbolFalse, SymbolTimes, SymbolTrue
 from mathics.core.systemsymbols import SymbolDirectedInfinity, SymbolSparseArray
 
 
@@ -87,20 +87,20 @@ def do_cplx_equal(x, y) -> Optional[int]:
     return c == 0
 
 
-def expr_max(elements):
+def expr_max(elements) -> Union[Expression, int]:
     result = Expression(SymbolDirectedInfinity, IntegerM1)
     for element in elements:
         c = do_cmp(element, result)
-        if c > 0:
+        if c is not None and c > 0:
             result = element
     return result
 
 
-def expr_min(elements):
+def expr_min(elements) -> Union[Expression, int]:
     result = Expression(SymbolDirectedInfinity, Integer1)
     for element in elements:
         c = do_cmp(element, result)
-        if c < 0:
+        if c is not None and c < 0:
             result = element
     return result
 
@@ -109,7 +109,7 @@ def is_number(sympy_value) -> bool:
     return hasattr(sympy_value, "is_number") or isinstance(sympy_value, sympy.Float)
 
 
-def check_ArrayQ(expr, pattern, test, evaluation: Evaluation):
+def eval_ArrayQ(expr, pattern, test_condition, evaluation: Evaluation) -> BooleanType:
     "Check if expr is an Array which test yields true for each of its elements."
 
     pattern = BasePattern.create(pattern, evaluation=evaluation)
@@ -118,9 +118,10 @@ def check_ArrayQ(expr, pattern, test, evaluation: Evaluation):
 
     def check(level, expr):
         if not expr.has_form("List", None):
-            test_expr = Expression(test, expr)
-            if test_expr.evaluate(evaluation) != SymbolTrue:
-                return False
+            if test_condition is not None:
+                test_expr = Expression(test_condition, expr)
+                if test_expr.evaluate(evaluation) != SymbolTrue:
+                    return False
             level_dim = None
         else:
             level_dim = len(expr.elements)
@@ -146,7 +147,7 @@ def check(level, expr):
     return SymbolTrue
 
 
-def check_SparseArrayQ(expr, pattern, test, evaluation: Evaluation):
+def eval_SparseArrayQ(expr, pattern, test, evaluation: Evaluation) -> BooleanType:
     "Check if expr is a SparseArray which test yields true for each of its elements."
 
     if not expr.head.sameQ(SymbolSparseArray):
diff --git a/mathics/eval/tracing.py b/mathics/eval/tracing.py
index 7dc2d6907..f911c4169 100644
--- a/mathics/eval/tracing.py
+++ b/mathics/eval/tracing.py
@@ -5,10 +5,11 @@
 """
 
 import inspect
+import time
 from enum import Enum
 from typing import Any, Callable, Optional
 
-TraceEventNames = ("SymPy", "Numpy", "mpmath", "apply", "debugger")
+TraceEventNames = ("SymPy", "Numpy", "mpmath", "apply", "evaluate", "debugger")
 TraceEvent = Enum("TraceEvent", TraceEventNames)
 
 
@@ -16,6 +17,56 @@
 hook_exit_fn: Optional[Callable] = None
 
 
+def print_evaluate(expr, evaluation, status: str, orig_expr=None) -> bool:
+    """
+    Called from a decorated Python @trace_evaluate .evaluate()
+    method when TraceActivate["evaluate" -> True]
+    """
+    if evaluation.definitions.timing_trace_evaluation:
+        evaluation.print_out(time.time() - evaluation.start_time)
+    indents = "  " * evaluation.recursion_depth
+    evaluation.print_out(f"{indents}{status}: {expr}")
+    return False
+
+
+# When not None, evaluate() methods call this
+# to show the status of evaluation on entry and return.
+trace_evaluate_on_call: Optional[Callable] = None
+trace_evaluate_on_return: Optional[Callable] = None
+
+
+def trace_evaluate(func: Callable) -> Callable:
+    """
+    Wrap a method evaluate() call event with trace_evaluate_on_call()
+    and trace_evaluate_on_return() callback so we can trace the
+    progress in evaluation.
+    """
+
+    def wrapper(expr, evaluation) -> Any:
+        from mathics.core.symbols import SymbolConstant
+
+        skip_call = False
+        result = None
+        if (
+            trace_evaluate_on_call is not None
+            and not evaluation.is_boxing
+            and not isinstance(expr, SymbolConstant)
+        ):
+            # We may use boxing in print_evaluate_fn(). So turn off
+            # boxing temporarily.
+            was_boxing = evaluation.is_boxing
+            evaluation.is_boxing = True
+            skip_call = trace_evaluate_on_call(expr, evaluation, "Evaluating")
+            evaluation.is_boxing = was_boxing
+        if not skip_call:
+            result = func(expr, evaluation)
+            if trace_evaluate_on_return is not None and not evaluation.is_boxing:
+                trace_evaluate_on_return(result, evaluation, "Returning", expr)
+        return result
+
+    return wrapper
+
+
 def trace_fn_call_event(func: Callable) -> Callable:
     """
     Wrap a call event with callbacks,
diff --git a/mathics/format/mathml.py b/mathics/format/mathml.py
index dddea2e59..d8ac94922 100644
--- a/mathics/format/mathml.py
+++ b/mathics/format/mathml.py
@@ -8,7 +8,7 @@
 import base64
 import html
 
-from mathics_scanner import is_symbol_name
+from mathics_scanner.tokeniser import is_symbol_name
 
 from mathics.builtin.box.graphics import GraphicsBox
 from mathics.builtin.box.graphics3d import Graphics3DBox
diff --git a/mathics/settings.py b/mathics/settings.py
index afcf14c03..db33887c1 100644
--- a/mathics/settings.py
+++ b/mathics/settings.py
@@ -10,8 +10,6 @@
 from pathlib import Path
 from typing import List
 
-import pkg_resources
-
 from mathics.core.util import canonic_filename
 
 
@@ -21,7 +19,6 @@ def get_srcdir():
 
 
 DEBUG = True
-
 DEBUG_PRINT = False
 
 # Maximum recursion depth is safe for all Python environments
@@ -51,7 +48,7 @@ def get_srcdir():
 # historically 10000 was used on public mathics servers
 MAX_STORED_SIZE = 10000
 
-ROOT_DIR = pkg_resources.resource_filename("mathics", "")
+ROOT_DIR = osp.dirname(__file__)
 if sys.platform.startswith("win"):
     DATA_DIR = canonic_filename(osp.join(os.environ["APPDATA"], "Python", "Mathics"))
 else:
diff --git a/pyproject.toml b/pyproject.toml
index 1f0b28461..083872b99 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -18,6 +18,7 @@ dependencies = [
     # Pillow 9.1.0 supports BigTIFF with big-endian byte order.
     # ExampleData image hedy.tif is in this format.
     # Pillow 9.2 handles sunflowers.jpg
+    "stopit; platform_system != 'Emscripten'",
     "pillow >= 9.2",
     "pint",
     "python-dateutil",
diff --git a/test/builtin/assignments/__init__.py b/test/builtin/assignments/__init__.py
new file mode 100644
index 000000000..71d310e06
--- /dev/null
+++ b/test/builtin/assignments/__init__.py
@@ -0,0 +1 @@
+"""Unit tests for test.builtin.assignments"""
diff --git a/test/builtin/assignments/test_assign_binaryop.py b/test/builtin/assignments/test_assign_binaryop.py
new file mode 100644
index 000000000..a02a5e31a
--- /dev/null
+++ b/test/builtin/assignments/test_assign_binaryop.py
@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+"""
+Unit tests for mathics.builtins.assignments.assign_binaryop
+"""
+
+from test.helper import check_evaluation, session
+
+
+def test_uninitialized():
+    session.evaluate("Clear[a]")
+    for inplace_operator, str_expected in (
+        ("Decrement", "a--"),
+        ("Increment", "a++"),
+        ("PreDecrement", "--a"),
+        ("PreIncrement", "++a"),
+    ):
+        check_evaluation(
+            str_expr=f"{inplace_operator}[a]",
+            str_expected=str_expected,
+            to_string_expr=True,
+            expected_messages=(
+                "a is not a variable with a value, so its value cannot be changed.",
+            ),
+        ),
+
+
+def test_predecrement():
+    check_evaluation(
+        "--5",
+        "--5",
+        failure_message="PreDecrement::rvalue: 5 is not a variable with a value, so its value cannot be changed.",
+    )
diff --git a/test/builtin/calculus/test_integrate.py b/test/builtin/calculus/test_integrate.py
index 053c57dec..135e0f932 100644
--- a/test/builtin/calculus/test_integrate.py
+++ b/test/builtin/calculus/test_integrate.py
@@ -6,7 +6,7 @@
 from test.helper import check_evaluation, session
 
 
-def test_integtrate():
+def test_integrate():
     for str_expr, str_expected, message in (
         ("Integrate[Integrate[1,{y,0,E^x}],{x,0,Log[13]}]", "12", "Issue #153"),
         (
diff --git a/test/builtin/distance/__init__.py b/test/builtin/distance/__init__.py
new file mode 100644
index 000000000..64775c5d7
--- /dev/null
+++ b/test/builtin/distance/__init__.py
@@ -0,0 +1 @@
+"""Unit tests for test.builtin.distance"""
diff --git a/test/builtin/distance/test_numeric.py b/test/builtin/distance/test_numeric.py
new file mode 100644
index 000000000..102328178
--- /dev/null
+++ b/test/builtin/distance/test_numeric.py
@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+"""
+Unit tests for mathics.builtins.distance.numeric
+"""
+
+from test.helper import check_evaluation
+
+
+def test_cosine_distance():
+    for str_expr, str_expected, message, fail_msg in (
+        ("CosineDistance[5, 6]", "0", "CosineDistance of a pair Integers is 0", None),
+        (
+            "CosineDistance[5, 6.0]",
+            "0.0",
+            "CosineDistance of an Integers and a Real is 0.0",
+            None,
+        ),
+        ("CosineDistance[Complex[1, 0], Complex[0, 2]]", "1 + I", None, None),
+        (
+            "CosineDistance[Complex[5.0, 0], Complex[10, 3]]",
+            "0.0421737 + 0.287348 I",
+            "CosineDistance of an two Complex numbers is defined",
+            None,
+        ),
+        (
+            "CosineDistance[{1, 2, 3}, {1, 2, 3, 4}]",
+            "CosineDistance[{1, 2, 3}, {1, 2, 3, 4}]",
+            "Mismatched vector sizes",
+            [
+                "The arguments {1, 2, 3} and {1, 2, 3, 4} do not have compatible dimensions."
+            ],
+        ),
+    ):
+        check_evaluation(str_expr, str_expected, message, expected_messages=fail_msg)
diff --git a/test/builtin/files_io/test_files.py b/test/builtin/files_io/test_files.py
index a66d1d821..c1decd9b3 100644
--- a/test/builtin/files_io/test_files.py
+++ b/test/builtin/files_io/test_files.py
@@ -295,6 +295,18 @@ def test_close():
             "{{a, 1}}",
             "",
         ),
+        (
+            'ReadList[StringToStream["(**)"], Expression]',
+            None,
+            "{Null}",
+            "",
+        ),
+        (
+            'ReadList[StringToStream["Hold[1+2]"], Expression]',
+            None,
+            "{Hold[1 + 2]}",
+            "",
+        ),
         ('stream = StringToStream["Mathics is cool!"];', None, "Null", ""),
         ("SetStreamPosition[stream, -5]", ("Invalid I/O Seek.",), "0", ""),
         (
@@ -443,6 +455,55 @@ def test_streams():
     evaluate("Close[newStream]")
 
 
+def test_write_string():
+    """
+    Check OpenWrite[] and WriteString[] using a path name.
+    """
+    # 1. Create a temporary file name in Python.
+    # 2. Open that for writing in Mathics3 using OpenWrite[].
+    # 3. Write some data to that using WriteString[] and
+    #    close the stream using Close[]
+    # 4. Then back in Python, see that the file was written and
+    #    that it has the data that was written via WriteString[].
+    # 5. Finally, remove the file.
+
+    # 1. Create temporary file name
+    tempfile = NamedTemporaryFile(mode="r", delete=False)
+    tempfile_path = tempfile.name
+
+    # 2. Open that for writing in Mathics3 using OpenWrite[].
+    check_evaluation(
+        str_expr=f'stream = OpenWrite["{tempfile_path}"];',
+        to_string_expr=False,
+        to_string_expected=False,
+    )
+
+    # 3. Write some data to that using WriteString[] and
+    #    close the stream using Close[]
+    text = "testing\n"
+    check_evaluation(
+        str_expr=f'WriteString["{tempfile_path}", "{text}"];',
+        to_string_expr=False,
+        to_string_expected=False,
+    )
+    check_evaluation(
+        str_expr="Close[stream];",
+    )
+
+    # 4. Back in Python, see that the file was written and
+    #    that it has the data that was written via WriteString[].
+
+    assert osp.exists(tempfile_path)
+    assert open(tempfile_path, "r").read() == text
+
+    # 5. Finally, remove the file.
+    try:
+        os.unlink(tempfile_path)
+    except PermissionError:
+        # This can happen in MS Windows
+        pass
+
+
 # rocky: I don't understand what these are supposed to test.
 
 # (
diff --git a/test/builtin/files_io/test_importexport.py b/test/builtin/files_io/test_importexport.py
index cec15a7da..3560e5414 100644
--- a/test/builtin/files_io/test_importexport.py
+++ b/test/builtin/files_io/test_importexport.py
@@ -154,6 +154,31 @@ def test_export():
             "Null",
             None,
         ),
+        ## Import with format
+        (
+            'Import["ExampleData/Testosterone.svg"];',
+            ("SVG is not a supported Import format.",),
+            "Null",
+            None,
+        ),
+        (
+            'Import["ExampleData/Testosterone.svg", "XML"] // Head',
+            None,
+            "XMLObject[Document]",
+            None,
+        ),
+        (
+            'Import["ExampleData/Testosterone.svg", {"XML"}] // Head',
+            None,
+            "XMLObject[Document]",
+            None,
+        ),
+        (
+            'Import["ExampleData/Testosterone.svg", {"XML", "XML"}];',
+            ("The Import element XML is not present when importing as XML.",),
+            "Null",
+            None,
+        ),
         ## XML
         (
             'MatchQ[Import["ExampleData/InventionNo1.xml", "Tags"],{__String}]',
diff --git a/test/builtin/numbers/test_linalg.py b/test/builtin/numbers/test_linalg.py
index 0d1a6dd67..3a39c60a6 100644
--- a/test/builtin/numbers/test_linalg.py
+++ b/test/builtin/numbers/test_linalg.py
@@ -212,17 +212,25 @@ def test_inverse(str_expr, str_expected, fail_msg, warnings):
             None,
         ),
         (
-            "A = Array[a, {2,2}]; eigvals=Eigenvalues[A.ConjugateTranspose[A]][[1]]",
+            "A = Array[a, {2,2}]; eigvals=Eigenvalues[A.ConjugateTranspose[A]]",
             None,
             (
-                "-Sqrt[(a[1, 1] Conjugate[a[1, 1]] + a[1, 2] Conjugate[a[1, 2]] "
-                "+ a[2, 1] Conjugate[a[2, 1]] + a[2, 2] Conjugate[a[2, 2]]) ^ 2 "
-                "- 4 (a[1, 1] Conjugate[a[1, 1]] + a[1, 2] Conjugate[a[1, 2]]) "
+                "{-Sqrt[(a[1, 1] Conjugate[a[1, 1]] + a[1, 2] Conjugate[a[1, 2]] + "
+                "a[2, 1] Conjugate[a[2, 1]] + a[2, 2] Conjugate[a[2, 2]]) ^ 2 - "
+                "4 (a[1, 1] Conjugate[a[1, 1]] + a[1, 2] Conjugate[a[1, 2]]) "
+                "(a[2, 1] Conjugate[a[2, 1]] + a[2, 2] Conjugate[a[2, 2]]) + "
+                "4 (a[1, 1] Conjugate[a[2, 1]] + a[1, 2] Conjugate[a[2, 2]]) "
+                "(a[2, 1] Conjugate[a[1, 1]] + a[2, 2] Conjugate[a[1, 2]])] / 2 "
+                "+ a[1, 1] Conjugate[a[1, 1]] / 2 + a[1, 2] Conjugate[a[1, 2]] / 2 + "
+                "a[2, 1] Conjugate[a[2, 1]] / 2 + a[2, 2] Conjugate[a[2, 2]] / 2, "
+                "Sqrt[(a[1, 1] Conjugate[a[1, 1]] + a[1, 2] Conjugate[a[1, 2]] + "
+                "a[2, 1] Conjugate[a[2, 1]] + a[2, 2] Conjugate[a[2, 2]]) ^ 2 - "
+                "4 (a[1, 1] Conjugate[a[1, 1]] + a[1, 2] Conjugate[a[1, 2]]) "
                 "(a[2, 1] Conjugate[a[2, 1]] + a[2, 2] Conjugate[a[2, 2]]) + 4 "
                 "(a[1, 1] Conjugate[a[2, 1]] + a[1, 2] Conjugate[a[2, 2]]) "
-                "(a[2, 1] Conjugate[a[1, 1]] + a[2, 2] Conjugate[a[1, 2]])] / 2 "
-                "+ a[1, 1] Conjugate[a[1, 1]] / 2 + a[1, 2] Conjugate[a[1, 2]] / 2 "
-                "+ a[2, 1] Conjugate[a[2, 1]] / 2 + a[2, 2] Conjugate[a[2, 2]] / 2"
+                "(a[2, 1] Conjugate[a[1, 1]] + a[2, 2] Conjugate[a[1, 2]])] / 2 + "
+                "a[1, 1] Conjugate[a[1, 1]] / 2 + a[1, 2] Conjugate[a[1, 2]] / 2 + "
+                "a[2, 1] Conjugate[a[2, 1]] / 2 + a[2, 2] Conjugate[a[2, 2]] / 2}"
             ),
             None,  # "Sympy issue #1156",
         ),
@@ -235,9 +243,17 @@ def test_inverse(str_expr, str_expected, fail_msg, warnings):
                 "4 a[1, 1] a[2, 2] Conjugate[a[1, 1]] Conjugate[a[2, 2]] - "
                 "4 a[1, 2] a[2, 1] Conjugate[a[1, 2]] Conjugate[a[2, 1]] + "
                 "4 a[1, 1] a[2, 2] Conjugate[a[1, 2]] Conjugate[a[2, 1]] + "
-                "4 a[1, 2] a[2, 1] Conjugate[a[1, 1]] Conjugate[a[2, 2]]] / 2"
+                "4 a[1, 2] a[2, 1] Conjugate[a[1, 1]] Conjugate[a[2, 2]]] / 2 + "
+                "a[1, 1] Conjugate[a[1, 1]] / 2 + a[1, 2] Conjugate[a[1, 2]] / 2 + "
+                "a[2, 1] Conjugate[a[2, 1]] / 2 + a[2, 2] Conjugate[a[2, 2]] / 2"
             ),
-            None,  #            "Sympy issue #1156",
+            None,  # "Sympy issue #1156",
+        ),
+        (
+            "eigvals /. a[x_, y_] -> x+I*y",
+            None,
+            ("{10 - 3 Sqrt[11], 10 + 3 Sqrt[11]}"),
+            None,  # "Sympy issue #1156",
         ),
     ],
 )
diff --git a/test/builtin/test_assignment.py b/test/builtin/test_assignment.py
index 476180249..acea25312 100644
--- a/test/builtin/test_assignment.py
+++ b/test/builtin/test_assignment.py
@@ -375,12 +375,6 @@ def test_set_and_clear_messages(str_expr, str_expected, message, out_msgs):
     )
 
 
-def test_predecrement():
-    check_evaluation(
-        "--5", "4", failure_message="Set::setraw: Cannot assign to raw object 5."
-    )
-
-
 def test_assign_list():
     check_evaluation("G[x_Real]=x^2; a={G[x]}; {x=1.; a, x=.; a}", "{{1.}, {G[x]}}")
 
diff --git a/test/builtin/test_datentime.py b/test/builtin/test_datentime.py
index 01583ecfd..3766a501f 100644
--- a/test/builtin/test_datentime.py
+++ b/test/builtin/test_datentime.py
@@ -11,8 +11,8 @@
 
 
 @pytest.mark.skipif(
-    sys.platform in ("win32", "emscripten") or hasattr(sys, "pyston_version_info"),
-    reason="TimeConstrained needs to be rewritten",
+    sys.platform in ("emscripten",),
+    reason="TimeConstrained is based in Threads, which are not supported in Piodide",
 )
 def test_timeremaining():
     str_expr = "TimeConstrained[1+2; TimeRemaining[], 0.9]"
@@ -20,16 +20,19 @@ def test_timeremaining():
     assert result is None or 0 < result.to_python() < 9
 
 
-@pytest.mark.skip(reason="TimeConstrained needs to be rewritten")
+@pytest.mark.skipif(
+    sys.platform in ("emscripten",),
+    reason="TimeConstrained is based in Threads, which are not supported in Piodide",
+)
 def test_timeconstrained1():
     #
-    str_expr1 = "a=1.; TimeConstrained[Do[Pause[.1];a=a+1,{1000}],1]"
+    str_expr1 = "a=1.; TimeConstrained[Do[Pause[.01];a=a+1,{1000}],.1]"
     result = evaluate(str_expr1)
     str_expected = "$Aborted"
     expected = evaluate(str_expected)
     assert result == expected
     time.sleep(1)
-    assert evaluate("a").to_python() == 10
+    assert evaluate("a").to_python() <= 10
 
 
 def test_datelist():
@@ -122,3 +125,53 @@ def test_private_doctests_datetime(str_expr, msgs, str_expected, fail_msg):
         failure_message=fail_msg,
         expected_messages=msgs,
     )
+
+
+@pytest.mark.skipif(
+    sys.platform in ("emscripten", "darwin"),
+    reason="TimeConstrained is based in Threads, which are not supported in Piodide and has problems on MacOS",
+)
+@pytest.mark.parametrize(
+    ("str_expr", "msgs", "str_expected", "fail_msg"),
+    [
+        ##
+        (
+            "TimeConstrained[Integrate[Sin[x]^100,x],.001]",
+            None,
+            "$Aborted",
+            "TimeConstrained with two arguments",
+        ),
+        (
+            "TimeConstrained[Integrate[Sin[x]^100,x],.001, Integrate[Cos[x],x]]",
+            None,
+            "Sin[x]",
+            "TimeConstrained with three arguments",
+        ),
+        (
+            "a=.;s=TimeConstrained[Integrate[Sin[x] ^ 3, x], a]",
+            (
+                "Number of seconds a is not a positive machine-sized number or Infinity.",
+            ),
+            "TimeConstrained[Integrate[Sin[x] ^ 3, x], a]",
+            "TimeConstrained unevaluated because the second argument is not numeric",
+        ),
+        (
+            "a=1; s",
+            None,
+            "Cos[x] (-3 + Cos[x] ^ 2) / 3",
+            "s is now evaluated because `a` is a number.",
+        ),
+        ("a=.;s=.;", None, "Null", None),
+    ],
+)
+def test_private_doctests_TimeConstrained(str_expr, msgs, str_expected, fail_msg):
+    """TimeConstrained tests"""
+    check_evaluation(
+        str_expr,
+        str_expected,
+        to_string_expr=True,
+        to_string_expected=True,
+        hold_expected=True,
+        failure_message=fail_msg,
+        expected_messages=msgs,
+    )
diff --git a/test/builtin/test_exp_structure.py b/test/builtin/test_exp_structure.py
index d80594d56..0a2bfff8a 100644
--- a/test/builtin/test_exp_structure.py
+++ b/test/builtin/test_exp_structure.py
@@ -3,9 +3,7 @@
 Unit tests for mathics.builtin.exp_structure
 """
 
-import sys
-import time
-from test.helper import check_evaluation, evaluate
+from test.helper import check_evaluation
 
 import pytest
 
diff --git a/test/builtin/test_scoping.py b/test/builtin/test_scoping.py
index b91bc269d..6bc064810 100644
--- a/test/builtin/test_scoping.py
+++ b/test/builtin/test_scoping.py
@@ -58,3 +58,22 @@ def test_private_doctests_scoping(str_expr, msgs, str_expected, fail_msg):
         failure_message=fail_msg,
         expected_messages=msgs,
     )
+
+
+@pytest.mark.parametrize(
+    ("str_expr", "msgs", "str_expected", "fail_msg"),
+    [
+        ("Block[{i = 0}, With[{}, Module[{j = i}, Set[i, i+1]; j]]]", None, "0", None),
+    ],
+)
+def test_scoping_constructs(str_expr, msgs, str_expected, fail_msg):
+    """ """
+    check_evaluation(
+        str_expr,
+        str_expected,
+        to_string_expr=True,
+        to_string_expected=True,
+        hold_expected=True,
+        failure_message=fail_msg,
+        expected_messages=msgs,
+    )
diff --git a/test/builtin/test_testing_expressions.py b/test/builtin/test_testing_expressions.py
index fa4c1cfa4..8efe40db5 100644
--- a/test/builtin/test_testing_expressions.py
+++ b/test/builtin/test_testing_expressions.py
@@ -135,3 +135,45 @@ def test_private_doctests_numerical_properties(str_expr, msgs, str_expected, fai
         failure_message=fail_msg,
         expected_messages=msgs,
     )
+
+
+@pytest.mark.parametrize(
+    ("str_expr", "msgs", "str_expected", "fail_msg"),
+    [
+        # Two default arguments (linear)
+        ("MatchQ[1, a_.+b_.*x_]", None, "True", None),
+        ("MatchQ[x, a_.+b_.*x_]", None, "True", None),
+        ("MatchQ[2*x, a_.+b_.*x_]", None, "True", None),
+        ("MatchQ[1+x, a_.+b_.*x_]", None, "True", None),
+        ("MatchQ[1+2*x, a_.+b_.*x_]", None, "True", None),
+        # Default argument (power)
+        ("MatchQ[1, x_^m_.]", None, "True", None),
+        ("MatchQ[x, x_^m_.]", None, "True", None),
+        ("MatchQ[x^1, x_^m_.]", None, "True", None),
+        ("MatchQ[x^2, x_^m_.]", None, "True", None),
+        # Two default arguments (power)
+        ("MatchQ[1, x_.^m_.]", None, "True", None),
+        ("MatchQ[x, x_.^m_.]", None, "True", None),
+        ("MatchQ[x^1, x_.^m_.]", None, "True", None),
+        ("MatchQ[x^2, x_.^m_.]", None, "True", None),
+        # Two default arguments (no non-head)
+        ("MatchQ[1, a_.+b_.]", None, "True", None),
+        ("MatchQ[x, a_.+b_.]", None, "True", None),
+        ("MatchQ[1+x, a_.+b_.]", None, "True", None),
+        ("MatchQ[1+2*x, a_.+b_.]", None, "True", None),
+        ("MatchQ[1, a_.*b_.]", None, "True", None),
+        ("MatchQ[x, a_.*b_.]", None, "True", None),
+        ("MatchQ[2*x, a_.*b_.]", None, "True", None),
+    ],
+)
+def test_matchq(str_expr, msgs, str_expected, fail_msg):
+    """text_expressions.matchq"""
+    check_evaluation(
+        str_expr,
+        str_expected,
+        to_string_expr=True,
+        to_string_expected=True,
+        hold_expected=True,
+        failure_message=fail_msg,
+        expected_messages=msgs,
+    )
diff --git a/test/builtin/test_trace.py b/test/builtin/test_trace.py
new file mode 100644
index 000000000..0a1f96122
--- /dev/null
+++ b/test/builtin/test_trace.py
@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+"""
+Unit tests for mathics.builtin.trace
+"""
+
+from test.helper import evaluate
+
+import pytest
+
+import mathics.eval.tracing
+from mathics.core.interrupt import AbortInterrupt
+
+trace_evaluation_calls = 0
+
+
+def test_TraceEvaluation():
+    """
+    Basic test of TraceEvaluate[]
+    """
+    old_recursion_limit = evaluate("$RecursionLimit")
+    old_evaluation_hook = mathics.eval.tracing.print_evaluate
+
+    def counting_print_evaluate(expr, evaluation, status: str, orig_expr=None) -> bool:
+        """
+        A replacement for mathics.eval.tracing.print_evaluate() that counts the
+        number of evaluation calls.
+        """
+        global trace_evaluation_calls
+        trace_evaluation_calls += 1
+        return False
+
+    try:
+        # Set a small recursion limit,
+        # Replace TraceEvaluation's print function something that counts evaluation
+        # calls, and then force a RecursionLimit Error.
+        evaluate("$RecursionLimit = 20")
+        assert mathics.eval.tracing.print_evaluate == old_evaluation_hook
+        evaluate("f[x_] := x + f[x-1]; f[0] = 0")
+        global trace_evaluation_calls
+        trace_evaluation_calls = 0
+        mathics.eval.tracing.print_evaluate = counting_print_evaluate
+        evaluate("f[30] // TraceEvaluation")
+
+    except AbortInterrupt:
+        # We should get an AbortInterrupt from exceeding RecursionLimit in evaluating f[30]
+        assert trace_evaluation_calls != 0, "TraceEvaluate[] should have counted steps"
+
+        # Clear evaluation-call count and then check that TraceEvaluation restored
+        # ts print hook. We do this by running another evaluate and checking
+        # that nothing happened.
+        trace_evaluation_calls = 0
+        evaluate("1+2")
+        assert trace_evaluation_calls == 0
+    else:
+        pytest.xfail("We should have raised an AbortInterrupt in evaluation")
+    finally:
+        # Just in case, restore everything back to what it was before running this test.
+        mathics.eval.tracing.print_evaluate = old_evaluation_hook
+        old_recursion_limit = evaluate(f"$RecursionLimit = {old_recursion_limit.value}")
+    assert mathics.eval.tracing.print_evaluate == old_evaluation_hook
diff --git a/test/core/test_rules.py b/test/core/test_rules.py
index 280b5849d..6a8541561 100644
--- a/test/core/test_rules.py
+++ b/test/core/test_rules.py
@@ -184,3 +184,48 @@ def test_flat_on_rules(str_expr, str_expected, msg):
 @pytest.mark.xfail
 def test_default_optional_on_rules(str_expr, str_expected, msg):
     check_evaluation(str_expr, str_expected, failure_message=msg)
+
+
+@pytest.mark.parametrize(
+    ("str_expr", "msgs", "str_expected", "fail_msg"),
+    [
+        # Two default arguments (linear)
+        ("rule=A[a_.+B[b_.*x_]]->{a,b,x};", None, "Null", None),
+        ("A[B[1]] /. rule", None, "{0, 1, 1}", None),
+        ("A[B[x]] /. rule", None, "{0, 1, x}", None),
+        ("A[B[2*x]] /. rule", None, "{0, x, 2}", None),
+        ("A[1+B[x]] /. rule", None, "{1, 1, x}", None),
+        ("A[1+B[2*x]] /. rule", None, "{1, x, 2}", None),
+        # Default argument (power)
+        ("rule=A[x_^n_.]->{x,n};", None, "Null", None),
+        ("A[1] /. rule", None, "{1, 1}", None),
+        ("A[x] /. rule", None, "{x, 1}", None),
+        ("A[x^1] /. rule", None, "{x, 1}", None),
+        ("A[x^2] /. rule", None, "{x, 2}", None),
+        # Two default arguments (power)
+        ("rule=A[x_.^n_.]->{x,n};", None, "Null", None),
+        ("A[] /. rule", None, "A[]", None),
+        ("A[1] /. rule", None, "{1, 1}", None),
+        ("A[x] /. rule", None, "{x, 1}", None),
+        ("A[x^1] /. rule", None, "{x, 1}", None),
+        ("A[x^2] /. rule", None, "{x, 2}", None),
+        # Two default arguments (no non-head)
+        ("rule=A[a_. + B[b_.*x_.]]->{a,b,x};", None, "Null", None),
+        ("A[B[]] /. rule", None, "A[B[]]", None),
+        ("A[B[1]] /. rule", None, "{0, 1, 1}", None),
+        ("A[B[x]] /. rule", None, "{0, 1, x}", None),
+        ("A[1 + B[x]] /. rule", None, "{1, 1, x}", None),
+        ("A[1 + B[2*x]] /. rule", None, "{1, 2, x}", None),
+    ],
+)
+def test_pattern_rules(str_expr, msgs, str_expected, fail_msg):
+    """pattern_rules"""
+    check_evaluation(
+        str_expr,
+        str_expected,
+        to_string_expr=True,
+        to_string_expected=True,
+        hold_expected=True,
+        failure_message=fail_msg,
+        expected_messages=msgs,
+    )
diff --git a/test/core/test_symbols.py b/test/core/test_symbols.py
new file mode 100644
index 000000000..35264271a
--- /dev/null
+++ b/test/core/test_symbols.py
@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+"""
+Test mathics.core.symbols
+"""
+
+from mathics.core.symbols import Symbol
+
+
+def test_Symbol_get_name():
+    """
+    Test Symbol().get_name()
+    """
+    short_symbol_name = "testSymbol"
+    symbol_with_context_name = f"System`{short_symbol_name}"
+    symbol = Symbol(symbol_with_context_name)
+    assert symbol.get_name() == symbol_with_context_name
+    assert symbol.get_name(short=False) == symbol_with_context_name
+    assert symbol.get_name(short=True) == short_symbol_name
diff --git a/test/eval/test_patterns.py b/test/eval/test_patterns.py
new file mode 100644
index 000000000..bb2ae9efb
--- /dev/null
+++ b/test/eval/test_patterns.py
@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+"""
+Unit tests for mathics.eval.patterns
+"""
+
+from test.helper import session
+
+import pytest
+
+from mathics.core.definitions import Definitions
+from mathics.core.parser import MathicsSingleLineFeeder, parse
+from mathics.core.pattern import ExpressionPattern
+from mathics.eval.patterns import Matcher
+
+# Preload the Mathics definitions
+defintions = Definitions(True)
+
+
+def check_pattern(str_expr, str_pattern):
+    expr = parse(defintions, MathicsSingleLineFeeder(str_expr))
+    pattern = ExpressionPattern(parse(defintions, MathicsSingleLineFeeder(str_pattern)))
+    ret = Matcher(pattern, session.evaluation).match(expr, session.evaluation)
+    assert ret == True
+
+
+@pytest.mark.parametrize(
+    ("str_expr", "str_pattern"),
+    [
+        # Two default arguments (linear)
+        ("1", "a_.+b_.*x_"),
+        ("x", "a_.+b_.*x_"),
+        ("2*x", "a_.+b_.*x_"),
+        ("1+x", "a_.+b_.*x_"),
+        ("1+2*x", "a_.+b_.*x_"),
+        # Default argument (power)
+        ("1", "x_^m_."),
+        ("x", "x_^m_."),
+        ("x^1", "x_^m_."),
+        ("x^2", "x_^m_."),
+        # Two default arguments (power)
+        ("1", "x_.^m_."),
+        ("x", "x_.^m_."),
+        ("x^1", "x_.^m_."),
+        ("x^2", "x_.^m_."),
+        # Two default arguments (no non-head)
+        ("1", "a_.+b_."),
+        ("x", "a_.+b_."),
+        ("1+x", "a_.+b_."),
+        ("1+2*x", "a_.+b_."),
+        ("1", "a_.*b_."),
+        ("x", "a_.*b_."),
+        ("2*x", "a_.*b_."),
+    ],
+)
+def test_eval_patterns(str_expr, str_pattern):
+    """eval_patterns"""
+    check_pattern(str_expr, str_pattern)