basic implementation of ConditionalExpression, Assuming and

Integrate uses now ConditionalExpression

Remove an unused import

Misc Arg tweaks:

* Arg[0] needs to be defined 0 (otherwise it can be indeterminate)
* More complete doc for Arg
* Add Method option

improving the behaviour of Piecewise returns in Integrate

misc

Author: mmatera

CHANGES.rst

@@ -10,6 +10,7 @@ New builtins
 
 * ``Arg``
 * ``Dispatch``
+* ``FullSimplify``
 * ``LetterNumber`` #1298. The ``alphabet`` parameter supports only a minimal number of languages.
 * ``Nand`` and ``Nor`` logical functions.
 * ``Series``,  ``O`` and ``SeriesData``
@@ -21,19 +22,23 @@ New builtins
 Enhancements
 ++++++++++++
 
+* a function `evaluate_predicate` allows for a basic predicate evaluation using `$Assumptions`.
 * ``Attributes`` accepts a string parameter.
 * ``ColorNegate`` for colors is supported.
 * ``D`` and ``Derivative`` improvements.
 * ``FileNames`` returns a sorted list (#1250).
 * ``FindRoot`` now receives several optional parameters like ``Method`` and ``MaxIterations``.
-* ``FixedPoint`` now supports the ``SameTest`` option.
+* ``FixedPoint`` now supports the ``SameTest`` option.  
 * ``Prime`` and ``PrimePi`` now accept a list parameter and have the ``NumericFunction`` attribute.
 * ``ReplaceRepeated`` and ``FixedPoint`` now supports the ``MaxIteration`` option (#1260).
+* ``Simplify`` performs a more sophisticated set of simplifications.
+* ``Simplify`` accepts a second parameter that temporarily overwrites ``$Assumptions``.
 * ``StringTake`` now accepts form containing a list of strings and specification (#1297).
 * ``Table`` [*expr*, *n*] is supported.
 * ``ToString`` accepts an optional *form* parameter.
 * ``ToExpression`` handles multi-line string input
 * The implementation of Streams was redone.
+  
 
 
 Bug fixes

mathics/builtin/algebra.py

@@ -3,6 +3,7 @@
 Algebraic Manipulation
 """
 
+
 from mathics.version import __version__  # noqa used in loading to check consistency.
 
 from mathics.builtin.base import Builtin
@@ -15,10 +16,13 @@
     Number,
     Symbol,
     SymbolFalse,
+    SymbolList,
     SymbolNull,
     SymbolTrue,
 )
 from mathics.core.convert import from_sympy, sympy_symbol_prefix
+from mathics.builtin.scoping import dynamic_scoping
+from mathics.builtin.inference import evaluate_predicate
 
 import sympy
 
@@ -288,6 +292,8 @@ class Simplify(Builtin):
     <dl>
     <dt>'Simplify[$expr$]'
         <dd>simplifies $expr$.
+    <dt>'Simplify[$expr$, $assump$]'
+        <dd>simplifies $expr$ assuming $assump$ instead of $Assumptions$.
     </dl>
 
     >> Simplify[2*Sin[x]^2 + 2*Cos[x]^2]
@@ -297,6 +303,16 @@ class Simplify(Builtin):
     >> Simplify[f[x]]
      = f[x]
 
+    Simplify over conditional expressions uses $Assumptions, or $assump$
+    to evaluate the condition:
+    # TODO: enable this once the logic for conditional expression
+    # be restaured.
+    # >> $Assumptions={a <= 0};
+    # >> Simplify[ConditionalExpression[1, a > 0]]
+    # = Undefined
+    # >> Simplify[ConditionalExpression[1, a > 0], { a > 0 }]
+    # = 1
+
     #> Simplify[a*x^2+b*x^2]
      = x ^ 2 (a + b)
 
@@ -308,11 +324,31 @@ class Simplify(Builtin):
     rules = {
         "Simplify[list_List]": "Simplify /@ list",
         "Simplify[rule_Rule]": "Simplify /@ rule",
-        "Simplify[eq_Equal]": "Simplify /@ eq",
+        "Simplify[list_List, assum_]": "Simplify[#1, assum]& /@ list",
+        "Simplify[rule_Rule, assum_]": "Simplify[#1, assum]& /@ rule",
+        "Simplify[0^a_, assum_]": "ConditionalExpression[0,Simplify[a>0]]",
+        "Simplify[b_^a_, assum_]": "ConditionalExpression[b,Simplify[{Or[a>0, b!=0]}]]",
     }
 
+    def apply_assuming(self, expr, assumptions, evaluation):
+        "%(name)s[expr_, assumptions_]"
+        assumptions = assumptions.evaluate(evaluation)
+        return dynamic_scoping(
+            lambda ev: self.apply(expr, ev),
+            {"System`$Assumptions": assumptions},
+            evaluation,
+        )
+
     def apply(self, expr, evaluation):
-        "Simplify[expr_]"
+        "%(name)s[expr_]"
+        # Check first if we are dealing with a logic expression...
+        expr = evaluate_predicate(expr, evaluation)
+        if expr.is_atom():
+            return expr
+        # else, use sympy:
+        leaves = [self.apply(leaf, evaluation) for leaf in expr._leaves]
+        head = self.apply(expr.get_head(), evaluation)
+        expr = Expression(head, *leaves)
 
         sympy_expr = expr.to_sympy()
         if sympy_expr is None:
@@ -321,6 +357,31 @@ def apply(self, expr, evaluation):
         return from_sympy(sympy_result)
 
 
+class FullSimplify(Simplify):
+    """
+    <dl>
+    <dt>'FullSimplify[$expr$]'
+        <dd>simplifies $expr$ using an extended set of simplification rules.
+    <dt>'FullSimplify[$expr$, $assump$]'
+        <dd>simplifies $expr$ assuming $assump$ instead of $Assumptions$.
+    </dl>
+    TODO: implement the extension. By now, this does the same than Simplify...
+
+    >> FullSimplify[2*Sin[x]^2 + 2*Cos[x]^2]
+     = 2
+
+    """
+
+    rules = {
+        "FullSimplify[list_List]": "FullSimplify /@ list",
+        "FullSimplify[rule_Rule]": "FullSimplify /@ rule",
+        "FullSimplify[eq_Equal]": "FullSimplify /@ eq",
+        "FullSimplify[list_List, assum_]": "FullSimplify[#1, assum]& /@ list",
+        "FullSimplify[rule_Rule, assum_]": "FullSimplify[#1, assum]& /@ rule",
+        "FullSimplify[eq_Equal, assum_]": "FullSimplify[#1, assum]& /@ eq",
+    }
+
+
 class Together(Builtin):
     """
     <dl>
@@ -1264,7 +1325,7 @@ def apply(self, expr, form, evaluation):
         if expr == Integer0:
             return Expression("List")
         elif e_null and f_null:
-            return Expression("List", Integer0)
+            return Expression(SymbolList, Integer0)
         elif e_null and not f_null:
             return Expression("List", SymbolNull)
         elif f_null: