passagemath-standard-no-symbolics 10.6.45__cp313-cp313-macosx_13_0_arm64.whl

sage/logic/logictable.py

@@ -0,0 +1,272 @@
+r"""
+Logic Tables
+
+A logic table is essentially a 2-D array that is created by the statement class
+and stored in the private global variable table, along with a list containing
+the variable names to be used, in order.
+
+The order in which the table is listed essentially amounts to counting in
+binary. For instance, with the variables `A`, `B`, and `C` the truth table
+looks like::
+
+    A      B      C      value
+    False  False  False    ?
+    False  False  True     ?
+    False  True   False    ?
+    False  True   True     ?
+    True   False  False    ?
+    True   False  True     ?
+    True   True   False    ?
+    True   True   True     ?
+
+This is equivalent to counting in binary, where a table would appear thus;
+
+::
+
+    2^2 2^1 2^0 value
+    0   0   0     0
+    0   0   1     1
+    0   1   0     2
+    0   1   1     3
+    1   0   0     4
+    1   0   1     5
+    1   1   0     6
+    1   1   1     7
+
+Given that a table can be created corresponding to any range of acceptable
+values for a given statement, it is easy to find the value of a statement
+for arbitrary values of its variables.
+
+AUTHORS:
+
+- William Stein (2006): initial version
+
+- Chris Gorecki (2006): initial version
+
+- Paul Scurek (2013-08-03): updated docstring formatting
+
+EXAMPLES:
+
+Create a truth table of a boolean formula::
+
+    sage: import sage.logic.propcalc as propcalc
+    sage: s = propcalc.formula("a&b|~(c|a)")
+    sage: s.truthtable()
+    a      b      c      value
+    False  False  False  True
+    False  False  True   False
+    False  True   False  True
+    False  True   True   False
+    True   False  False  False
+    True   False  True   False
+    True   True   False  True
+    True   True   True   True
+
+Get the LaTeX code for a truth table::
+
+    sage: latex(s.truthtable(5,11))
+    \\\begin{tabular}{llll}c & b & a & value \\\hline True & False & True & False \\True & True & False & True \\True & True & True & True\end{tabular}
+
+It is not an error to use nonsensical numeric inputs::
+
+    sage: s = propcalc.formula("a&b|~(c|a)")
+    sage: s.truthtable(5, 9)
+    a      b      c      value
+    True   False  True   False
+    True   True   False  True
+    True   True   True   True
+
+    sage: s.truthtable(9, 5)
+    a      b      c      value
+
+If one argument is provided, truthtable defaults to the end::
+
+    sage: s.truthtable(-1)
+    a      b      c      value
+    False  False  False  True
+    False  False  True   False
+    False  True   False  True
+    False  True   True   False
+    True   False  False  False
+    True   False  True   False
+    True   True   False  True
+    True   True   True   True
+
+If the second argument is negative, truthtable defaults to the end::
+
+    sage: s.truthtable(4, -2)
+    a      b      c      value
+    True   False  False  False
+    True   False  True   False
+    True   True   False  True
+    True   True   True   True
+
+.. NOTE::
+
+    For statements that contain a variable list that when printed is longer
+    than the latex page, the columns of the table will run off the screen.
+"""
+# ****************************************************************************
+#       Copyright (C) 2006 William Stein <wstein@gmail.com>
+#       Copyright (C) 2006 Chris Gorecki <chris.k.gorecki@gmail.com>
+#       Copyright (C) 2013 Paul Scurek <scurek86@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+# Global variables
+__table = []
+__vars_order = []
+
+
+class Truthtable:
+    """
+    A truth table.
+
+    INPUT:
+
+    - ``t`` -- a 2-D array containing the table values
+
+    - ``vo`` -- list of the variables in the expression in order,
+      with each variable occurring only once
+    """
+    def __init__(self, t, vo):
+        r"""
+        Initialize the data fields.
+
+        EXAMPLES:
+
+        This example illustrates the creation of a table
+
+        ::
+
+            sage: import sage.logic.propcalc as propcalc
+            sage: s = propcalc.formula("a&b|~(c|a)")
+            sage: s.truthtable()
+            a      b      c      value
+            False  False  False  True
+            False  False  True   False
+            False  True   False  True
+            False  True   True   False
+            True   False  False  False
+            True   False  True   False
+            True   True   False  True
+            True   True   True   True
+        """
+        self.__table = t
+        self.__vars_order = vo
+
+    def _latex_(self):
+        r"""
+        Return a latex representation of the calling table object.
+
+        OUTPUT: the latex representation of the table
+
+        EXAMPLES:
+
+        This example illustrates how to get the latex representation of
+        the table::
+
+            sage: import sage.logic.propcalc as propcalc
+            sage: s = propcalc.formula("man->monkey&human")
+            sage: latex(s.truthtable())
+            \\\begin{tabular}{llll}human & monkey & man & value \\\hline False & False & False & True \\False & False & True & True \\False & True & False & True \\False & True & True & True \\True & False & False & False \\True & False & True & False \\True & True & False & False \\True & True & True & True\end{tabular}
+
+        Now, we show that strange parameters can lead to a table header
+        with no body::
+
+            sage: latex(s.truthtable(2, 1))
+            \\\begin{tabular}{llll}human & monkey & man & value \\\hli\end{tabular}
+        """
+        rt = s = ""
+        self.__vars_order.reverse()
+        s = r'\\\begin{tabular}{'
+        s += 'l' * (len(self.__vars_order) + 1) + '}'
+        for var in self.__vars_order:
+            s += var + ' & '
+        rt += s + r'value \\' + r'\hline '
+        for row in self.__table:
+            s = ""
+            for i in row:
+                s += str(i) + ' & '
+            rt += s[:-3] + r' \\'
+        rt = rt[:-3] + r'\end{tabular}'
+        self.__vars_order.reverse()
+        return rt
+
+    def __repr__(self):
+        r"""
+        Return a string representation of the calling table object.
+
+        OUTPUT: the table as a 2-D string array
+
+        EXAMPLES:
+
+        This example illustrates how to display the truth table of a
+        boolean formula::
+
+            sage: import sage.logic.propcalc as propcalc
+            sage: s = propcalc.formula("man->monkey&human")
+            sage: s.truthtable()
+            man    monkey  human  value
+            False  False   False  True
+            False  False   True   True
+            False  True    False  True
+            False  True    True   True
+            True   False   False  False
+            True   False   True   False
+            True   True    False  False
+            True   True    True   True
+
+        We now show that strange parameters can lead to the table
+        header with no body::
+
+            sage: s.truthtable(2, 1)
+            man    monkey  human  value
+        """
+        vars_len = []
+        line = rt = s = ""
+        for var in self.__vars_order:
+            vars_len.append(len(var))
+            s = var + ' '
+            while len(s) < len('False '):
+                s += ' '
+            s += ' '
+            line += s
+        rt += line + 'value\n'
+        for row in self.__table:
+            line = s = ""
+            i = 0
+            for e in row:
+                j = 2 if e else 1
+                s = str(e) + ' ' * j
+                if i < len(vars_len):
+                    while len(s) <= vars_len[i]:
+                        s += ' '
+                s += ' '
+                line += s
+                i += 1
+            rt += line + '\n'
+        return rt
+
+    def get_table_list(self):
+        r"""
+        Return a list representation of the calling table object.
+
+        OUTPUT: list representation of the table
+
+        EXAMPLES:
+
+        This example illustrates how to show the table as a list::
+
+            sage: import sage.logic.propcalc as propcalc
+            sage: s = propcalc.formula("man->monkey&human")
+            sage: s.truthtable().get_table_list()
+             [['man', 'monkey', 'human'], [False, False, False, True], [False, False, True, True], [False, True, False, True], [False, True, True, True], [True, False, False, False], [True, False, True, False], [True, True, False, False], [True, True, True, True]]
+        """
+        t = self.__table[:]
+        t.insert(0, self.__vars_order)
+        return t

sage/logic/propcalc.py

@@ -0,0 +1,311 @@
+r"""
+Propositional Calculus
+
+Formulas consist of the following operators:
+
+* ``&`` -- and
+* ``|`` -- or
+* ``~`` -- not
+* ``^`` -- xor
+* ``->`` -- if-then
+* ``<->`` -- if and only if
+
+Operators can be applied to variables that consist of a leading letter and
+trailing underscores and alphanumerics.  Parentheses may be used to explicitly
+show order of operation.
+
+AUTHORS:
+
+- Chris Gorecki (2006): initial version, propcalc, boolformula,
+  logictable, logicparser, booleval
+
+- Michael Greenberg -- boolopt
+
+- Paul Scurek (2013-08-05): updated docstring formatting
+
+- Paul Scurek (2013-08-12): added :func:`~sage.logic.propcalc.get_formulas()`,
+  :func:`~sage.logic.propcalc.consistent()`,
+  :func:`~sage.logic.propcalc.valid_consequence()`
+
+EXAMPLES:
+
+We can create boolean formulas in different ways::
+
+    sage: f = propcalc.formula("a&((b|c)^a->c)<->b")
+    sage: g = propcalc.formula("boolean<->algebra")
+    sage: (f&~g).ifthen(f)
+    ((a&((b|c)^a->c)<->b)&(~(boolean<->algebra)))->(a&((b|c)^a->c)<->b)
+
+We can create a truth table from a formula::
+
+    sage: f.truthtable()
+    a      b      c      value
+    False  False  False  True
+    False  False  True   True
+    False  True   False  False
+    False  True   True   False
+    True   False  False  True
+    True   False  True   False
+    True   True   False  True
+    True   True   True   True
+    sage: f.truthtable(end=3)
+    a      b      c      value
+    False  False  False  True
+    False  False  True   True
+    False  True   False  False
+    sage: f.truthtable(start=4)
+    a      b      c      value
+    True   False  False  True
+    True   False  True   False
+    True   True   False  True
+    True   True   True   True
+    sage: propcalc.formula("a").truthtable()
+    a      value
+    False  False
+    True   True
+
+Now we can evaluate the formula for a given set of input::
+
+    sage: f.evaluate({'a':True, 'b':False, 'c':True})
+    False
+    sage: f.evaluate({'a':False, 'b':False, 'c':True})
+    True
+
+And we can convert a boolean formula to conjunctive normal form::
+
+    sage: f.convert_cnf_table()
+    sage: f
+    (a|~b|c)&(a|~b|~c)&(~a|b|~c)
+    sage: f.convert_cnf_recur()
+    sage: f
+    (a|~b|c)&(a|~b|~c)&(~a|b|~c)
+
+Or determine if an expression is satisfiable, a contradiction, or a tautology::
+
+    sage: f = propcalc.formula("a|b")
+    sage: f.is_satisfiable()
+    True
+    sage: f = f & ~f
+    sage: f.is_satisfiable()
+    False
+    sage: f.is_contradiction()
+    True
+    sage: f = f | ~f
+    sage: f.is_tautology()
+    True
+
+The equality operator compares semantic equivalence::
+
+    sage: f = propcalc.formula("(a|b)&c")
+    sage: g = propcalc.formula("c&(b|a)")
+    sage: f == g
+    True
+    sage: g = propcalc.formula("a|b&c")
+    sage: f == g
+    False
+
+It is an error to create a formula with bad syntax::
+
+    sage: propcalc.formula("")
+    Traceback (most recent call last):
+    ...
+    SyntaxError: malformed statement
+    sage: propcalc.formula("a&b~(c|(d)")
+    Traceback (most recent call last):
+    ...
+    SyntaxError: malformed statement
+    sage: propcalc.formula("a&&b")
+    Traceback (most recent call last):
+    ...
+    SyntaxError: malformed statement
+    sage: propcalc.formula("a&b a")
+    Traceback (most recent call last):
+    ...
+    SyntaxError: malformed statement
+
+    It is also an error to not abide by the naming conventions.
+    sage: propcalc.formula("~a&9b")
+    Traceback (most recent call last):
+    ...
+    NameError: invalid variable name 9b: identifiers must begin with a letter and contain only alphanumerics and underscores
+"""
+# *****************************************************************************
+#       Copyright (C) 2006 William Stein <wstein@gmail.com>
+#       Copyright (C) 2006 Chris Gorecki <chris.k.gorecki@gmail.com>
+#       Copyright (C) 2013 Paul Scurek <scurek86@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  as published by the Free Software Foundation; either version 2 of
+#  the License, or (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# *****************************************************************************
+
+# TODO:
+# converts (cnf) returns w/o change
+
+from . import boolformula
+from . import logicparser
+from sage.misc.superseded import deprecated_function_alias
+
+
+def formula(s):
+    r"""
+    Return an instance of :class:`BooleanFormula`.
+
+    INPUT:
+
+    - ``s`` -- string that contains a logical expression
+
+    OUTPUT: an instance of :class:`BooleanFormula`
+
+    EXAMPLES:
+
+    This example illustrates ways to create a boolean formula::
+
+        sage: f = propcalc.formula("a&~b|c")
+        sage: g = propcalc.formula("a^c<->b")
+        sage: f&g|f
+        ((a&~b|c)&(a^c<->b))|(a&~b|c)
+
+    We now demonstrate some possible errors::
+
+        sage: propcalc.formula("((a&b)")
+        Traceback (most recent call last):
+        ...
+        SyntaxError: malformed statement
+        sage: propcalc.formula("_a&b")
+        Traceback (most recent call last):
+        ...
+        NameError: invalid variable name _a: identifiers must begin with a letter and contain only alphanumerics and underscores
+    """
+    try:
+        parse_tree, vars_order = logicparser.parse(s)
+        f = boolformula.BooleanFormula(s, parse_tree, vars_order)
+        f.truthtable(0, 1)
+    except (KeyError, RuntimeError, IndexError, SyntaxError):
+        msg = "malformed statement"
+        raise SyntaxError(msg)
+    return f
+
+
+def get_formulas(*statements):
+    r"""
+    Convert statements and parse trees into instances of
+    :class:`BooleanFormula`.
+
+    INPUT:
+
+    - ``*statements`` -- strings or lists; a list must be a
+      full syntax parse tree of a formula, and a string must
+      be a string representation of a formula
+
+    OUTPUT: the converted formulas in a list
+
+    EXAMPLES:
+
+    This example illustrates converting strings into boolean formulas.
+
+    ::
+
+        sage: f = "a&(~c<->d)"
+        sage: g = "d|~~b"
+        sage: h = "~(a->c)<->(d|~c)"
+        sage: propcalc.get_formulas(f, g, h)
+        [a&(~c<->d), d|~~b, ~(a->c)<->(d|~c)]
+
+    ::
+
+        sage: A, B, C = propcalc.get_formulas("(a&b)->~c", "c", "~(a&b)")
+        sage: A
+        (a&b)->~c
+        sage: B
+        c
+        sage: C
+        ~(a&b)
+
+    We can also convert parse trees into formulas.
+
+    ::
+
+        sage: t = ['a']
+        sage: u = ['~', ['|', ['&', 'a', 'b'], ['~', 'c']]]
+        sage: v = "b->(~c<->d)"
+        sage: formulas= propcalc.get_formulas(t, u, v)
+        sage: formulas[0]
+        a
+        sage: formulas[1]
+        ~((a&b)|~c)
+        sage: formulas[2]
+        b->(~c<->d)
+
+    AUTHORS:
+
+    - Paul Scurek (2013-08-12)
+    """
+    formulas = []
+
+    for statement in statements:
+        try:
+            if isinstance(statement, str):
+                formulas.append(formula(statement))
+            elif isinstance(statement, list):
+                formulas.append(formula(logicparser.recover_formula(statement)))
+            else:
+                raise TypeError
+        except (SyntaxError, NameError):
+            raise SyntaxError("malformed statement")
+        except TypeError:
+            raise TypeError
+    return formulas
+
+
+def consistent(*formulas):
+    r"""
+    Determine if the formulas are logically consistent.
+
+    INPUT:
+
+    - ``*formulas`` -- instances of :class:`BooleanFormula`
+
+    OUTPUT: a boolean value to be determined as follows:
+
+    - ``True`` -- if the formulas are logically consistent
+
+    - ``False`` -- if the formulas are not logically consistent
+
+    EXAMPLES:
+
+    This example illustrates determining if formulas are logically consistent.
+
+    ::
+
+        sage: f, g, h, i = propcalc.get_formulas("a<->b", "~b->~c", "d|g", "c&a")
+        sage: propcalc.consistent(f, g, h, i)
+        True
+
+    ::
+
+        sage: j, k, l, m = propcalc.get_formulas("a<->b", "~b->~c", "d|g", "c&~a")
+        sage: propcalc.consistent(j, k ,l, m)
+        False
+
+    AUTHORS:
+
+    - Paul Scurek (2013-08-12)
+    """
+    # make sure only instances of :class:`BooleanFormula` were passed as arguments
+    for formula in formulas[1:]:
+        if not isinstance(formula, boolformula.BooleanFormula):
+            raise TypeError("consistent() takes BooleanFormula() class instances as arguments")
+
+    # conjoin all of the formulas with &
+    conjunction = formulas[0]
+    for formula in formulas[1:]:
+        conjunction = conjunction & formula
+
+    # if conjunction is a contradiction, the formulas are inconsistent
+    return not conjunction.is_contradiction()
+
+
+# define function ``valid_consequence`` for backward compatibility
+valid_consequence = deprecated_function_alias(28052, boolformula.is_consequence)

sage/misc/all.py

@@ -0,0 +1,28 @@
+# from sage.misc.all__sagemath_objects import *
+from sage.misc.all__sagemath_environment import *
+from sage.misc.all__sagemath_modules import *
+from sage.misc.all__sagemath_repl import *
+
+from sage.misc.misc import (BackslashOperator,
+                            exists, forall, is_iterator,
+                            random_sublist,
+                            pad_zeros,
+                            newton_method_sizes, compose,
+                            nest)
+
+lazy_import('sage.misc.banner', 'banner', deprecation=34259)
+lazy_import('sage.misc.edit_module', 'set_edit_template', deprecation=34259)
+lazy_import('sage.misc.profiler', 'Profiler', deprecation=34259)
+lazy_import('sage.misc.trace', 'trace', deprecation=34259)
+lazy_import('sage.misc.package', ('installed_packages', 'is_package_installed',
+                                  'package_versions'),
+            deprecation=34259)
+lazy_import('sage.misc.benchmark', 'benchmark', deprecation=34259)
+lazy_import('sage.repl.interpreter', 'logstr', deprecation=34259)
+
+# Following will go to all__sagemath_objects.py in #36566
+from sage.misc.randstate import seed, set_random_seed, initial_seed, current_randstate
+from sage.misc.prandom import *
+from sage.misc.sage_timeit_class import timeit
+from sage.misc.session import load_session, save_session, show_identifiers
+from sage.misc.reset import reset, restore

sage/misc/lazy_attribute.pyi

@@ -0,0 +1,11 @@
+# sage_setup: distribution = sagemath-objects
+
+# This type-stub file helps pyright understand the decorator @lazy_attribute.
+
+# Adapted from https://github.com/python/typeshed/blob/b9640005eb586afdbe0a57bac2b88a7a12465069/stdlib/builtins.pyi#L1237-L1254
+class lazy_attribute:
+    def __init__(
+        self,
+        f: Callable[[Any], Any] | None = ...
+    ) -> None: ...
+    def __get__(self, a: Any, cls: type) -> Any: ...

sage/rings/all.py

@@ -0,0 +1,48 @@
+"""
+Rings
+"""
+# ****************************************************************************
+#       Copyright (C) 2005 William Stein <wstein@gmail.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+from sage.misc.lazy_import import lazy_import
+
+from sage.rings.all__sagemath_categories import *
+
+# Finite fields
+from sage.rings.finite_rings.all import *
+
+from sage.rings.all__sagemath_combinat import *
+from sage.rings.all__sagemath_flint import *
+from sage.rings.all__sagemath_gap import *
+from sage.rings.all__sagemath_modules import *
+
+try:
+    from sage.rings.all__sagemath_symbolics import *
+except ImportError:
+    pass
+
+# Function field
+from sage.rings.function_field.all import *
+
+# Semirings
+from sage.rings.semirings.all import *
+
+# Double precision floating point numbers
+from sage.rings.real_double import RealDoubleField, RDF, RealDoubleElement
+
+# Polynomial Rings and Polynomial Quotient Rings
+from sage.rings.polynomial.all import *
+
+# Following will go to all__sagemath_categories.py in #36566
+
+from sage.rings.fast_arith import prime_range
+
+# Register classes in numbers abc
+from sage.rings import numbers_abc
+del lazy_import