The category morphism/diagram, finite Cartan-type and local differential-geometry
interfaces in python/symox/categories, python/symox/liealgebras and
python/symox/diffgeom follow SymPy 1.14 conventions. The curvature formulas,
coordinate atlas examples and Xy-pic arrow descriptions adapt the reference
interfaces to native Symox coefficients, matrices and component arrays.

The Ore-operator, holonomic equation and coordinate-vector interfaces in
python/symox/holonomic and python/symox/vector follow SymPy 1.14 conventions,
including the Euler-operator special-function equations, orientation matrices,
orthogonal-coordinate calculus and geometric integration conventions. The
implementations use native Symox exact coefficients, derivatives and matrices.

The Python-style parser transformations and the DOT, expression-tree, table and
TeX preview helpers in python/symox/parsing and python/symox/printing adapt
SymPy 1.14 algorithms to native expression constructors and printers.

The polar conversion traversal in python/symox/_polar.py follows the SymPy 1.14
polarify/unpolarify conventions, with native polar evaluation in special/polar.rs.

The combinatorial iteration algorithms in python/symox/utilities/_iterable_extensions.py
and _enumerative.py adapt SymPy 1.14 utilities to native Symox containers.

The assumptions predicates, generated facts, query pipeline, handlers and
refinement rules in crates/symox-core/src/ask follow SymPy 1.14.

The arbitrary-constant absorption and Lie-point-symmetry heuristics in
python/symox/solvers/ode/_constants.py and lie_group.py adapt the corresponding
SymPy 1.14 algorithms to native arithmetic, differentiation, integration and
exact linear nullspaces. The PDE method interfaces and characteristic
conventions in python/symox/solvers/pde.py follow the SymPy solver APIs.

The continued-fraction Pade construction in python/symox/series/approximants.py
adapts SymPy's approximants algorithm to native exact cancellation. The public
array-comprehension, sequence and solver-helper conventions follow SymPy 1.14;
their scalar arithmetic and algebraic operations use native symox kernels.

The indexed tensor interfaces and Riemann cyclic-projection conventions in
python/symox/tensor follow SymPy 1.14. Their Einstein index handling, bounded
signed-orbit canonicalization and explicit component evaluation are native
symox implementations, without a SymPy runtime dependency.

The public adapters in python/symox/_expr_methods.py (direction and matching
semantics), python/symox/_matrix_decompositions.py (graph decomposition result
construction) and python/symox/polys/matrices/domainmatrix.py (domain inference
and conversion conventions) follow the corresponding SymPy 1.14 APIs.
The transitive-group representatives in python/symox/combinatorics/galois.py
use the generator conventions of sympy/combinatorics/galois.py.
The adapters in python/symox/_expr_analysis.py (scope normalization, branch
extraction and local meromorphic tests) and python/symox/series/ (series
protocols and Fourier normalization) follow the corresponding SymPy 1.14 APIs.
The structural adapters in python/symox/_matrixexpr_methods.py and
python/symox/_matrixexpr_algebra.py follow the corresponding Basic/Expr APIs.
The operation labels in python/symox/_operation_counts.py follow the counting
conventions and traversal rules in sympy/core/function.py (count_ops).
The AlgebraicNumber adapters in python/symox/_algebraic_number_methods.py
follow the corresponding Basic/Expr and field-generator conventions.
Gaussian Euclidean division and unit conventions in
crates/symox-core/src/poly/domains.rs follow sympy/polys/domains/gaussiandomains.py;
the bounded-denominator real conversion follows SymPy's real-field conventions.
The monogenic quotient interface in python/symox/polys/agca/extensions.py
follows sympy/polys/agca/extensions.py, using native polynomial arithmetic.
The domain matrix protocols in python/symox/polys/matrices/ follow the
corresponding SymPy 1.14 APIs and domain-aware linear algebra conventions.
The row-reduction, LU, determinant and inverse callback interfaces in the native
matrix kernels and Python bindings follow SymPy's matrix reductions,
decomposition and inversion conventions, using fallible native callbacks and
compact symbolic zero tests.
The coefficient callback adapter in python/symox/_matrix_charpoly.py follows
SymPy's characteristic-polynomial transformation and domain conventions,
using native DomainMatrix arithmetic.
The permutation matrix adapters, native constructors, rewrites and entry
conventions follow sympy/matrices/expressions/permutation.py. The textual
parser also supports the cycle notation emitted by SymPy's permutation printer.
The evaluation adapters in python/symox/polys/_evaluation.py follow the
Poly.eval and Poly.as_expr interfaces, retaining native coefficient arithmetic.
The concrete array interfaces in python/symox/tensor/array/ and shape dispatch
in python/symox/tensor/functions.py follow the corresponding SymPy 1.14 APIs.
The finite difference adapters in python/symox/calculus/finite_diff.py follow
the SymPy stencil interfaces and Fornberg's arbitrary-grid weight recurrence.
The helpers in python/symox/utilities/ and generic container sort keys follow
the corresponding SymPy iterator, traversal, sorting and caching interfaces.
The sequence interfaces in python/symox/series/sequences.py follow SymPy's
formula, periodic, termwise arithmetic and fitted recurrence conventions.
The calculus adapters in python/symox/calculus/singularities.py and util.py
follow the corresponding SymPy analysis interfaces and elementary domain rules.
The public signatures of python/symox/calculus/_monotonicity.py follow the
SymPy monotonicity interfaces, with interval proofs using native derivatives,
continuity domains and symbolic sets.
The signatures and endpoint-limit conventions in python/symox/calculus/_extrema.py
follow the SymPy minimum/maximum interfaces, using native critical-point and
continuity calculations.
The function_range signature and image-set conventions in
python/symox/calculus/_range.py follow the SymPy calculus interface, using native
endpoint attainment proofs and continuous interval images.
The finite-set nonemptiness interface in python/symox/calculus/_notempty.py
follows SymPy's not_empty_in API, using native real domains, set membership,
equation solving and inequality solving.
The general functional composition adapters in python/symox/solvers/decompogen.py
follow the corresponding SymPy decompogen/compogen interfaces, with native
expression substitution and polynomial decomposition.
The exact functional polynomial decomposition in the native polynomial kernels
follows the Kozen--Landau normalization and domain conventions of SymPy's
densetools and polytools interfaces, using native coefficient-field arithmetic.
The explicit recursive presentation keys in python/symox/_ordered_keys.py follow
SymPy's sort_key and default_sort_key conventions, retaining native graph sharing.
The structural differential order in python/symox/solvers/deutils.py follows
SymPy's ode_order convention, using iterative traversal and native held counts.
The homogeneous_order interface follows SymPy's positive-scaling convention,
with structural degree proofs preserving native principal-power branches.
The floating conversion interface in python/symox/_numeric_float.py follows
SymPy's nfloat conventions, with native exponent masking and numerical kernels.
The numerical chopping interface follows SymPy's binary-magnitude convention,
using native arbitrary-precision real and imaginary components.
The solution validation and linear isolation adapters in
python/symox/_solver_checks.py follow the corresponding SymPy solver interfaces.
The polynomial, rational and absolute-value inequality interfaces in
python/symox/solvers/inequalities.py follow SymPy's condition and interval
conventions, using native real sign charts, pole exclusions and exact sets.
The structural query adapters in python/symox/_structural_queries.py follow
the SymPy find/count selector and occurrence-counting interfaces.
The replacement traversal in python/symox/_expression_replace.py, expression
coefficient and ordering adapters, and differentiation signatures in
python/symox/_differentiation.py follow the corresponding SymPy Basic/Expr APIs.
The rational conversion modes in python/symox/_numeric_recognition.py follow
the nsimplify rationalization interface, using native field conversion and
Python integer/fraction arithmetic.
The wildcard type, exclusion metadata and conversion protocols follow
the SymPy Wild interface; scalar legacy matching uses native linear isolation.

The polynomial helpers in python/symox/polys/polyfuncs.py, specialpolys.py,
orthopolys.py, partfrac.py, dispersion.py, monomials.py, orderings.py and
polytools.py, the Poly method wrappers in python/symox/polys/_poly_methods.py
(revert, sqf_norm, nth_power_roots_poly and related structural methods) and
the sparse exponent transforms and the cyclotomic recognition
(dup_cyclotomic_p) in crates/symox-core/src/poly/structure.rs, the orthogonal
polynomial recurrences in crates/symox-core/src/poly/orthopolys.rs, the
Bronstein full partial fraction decomposition in
crates/symox-core/src/poly/partfrac.rs and the dispersion set in
crates/symox-core/src/poly/dispersion.rs follow the corresponding SymPy
algorithms and recurrences.

The symbolic product evaluation and Product/Sum convergence tests in
crates/symox-core/src/products.rs and the recurrence solvers in
crates/symox-core/src/recurr.rs (Abramov's rsolve_poly and rsolve_ratio,
Petkovsek's rsolve_hyper, casoratian and the rsolve driver) follow the
algorithms and case analysis of SymPy's sympy/concrete/products.py,
sympy/concrete/summations.py and sympy/solvers/recurr.py.

The Mod and Rem canonicalisation (Mod.eval), the special-value tables of
asec, acsc, asech and acsch, the evaluation rules of sinc, frac,
KroneckerDelta and LeviCivita, the Kronecker delta summation rule and
real_root in crates/symox-core/src/special/elementary.rs,
crates/symox-core/src/summation.rs and python/symox/__init__.py are ported
from SymPy (BSD-3-Clause).

The special-value evaluation of the elementary functions in
crates/symox-core/src/special/trig_eval.rs and the Basic.rewrite engine and
_eval_rewrite_as_* rules in crates/symox-core/src/special/rewrite.rs are
ported from SymPy (BSD-3-Clause).

The deterministic LLL update order and float-to-rational conversion in
crates/symox-core/src/matrix/lll.rs follow the corresponding SymPy routines.
The auxiliary matrix kernels in crates/symox-core/src/matrix/auxiliary.rs and
python/symox/_matrix_aux.py (Berkowitz vectors, fraction-free and simple LU,
permanent, inverse_BLOCK, Householder Hessenberg and bidiagonal reductions,
dual, get_diag_blocks, irregular, orthogonalize, casoratian, randMatrix,
banded, liupc and the Expr.equals heuristics used by Matrix.equals) are ports
of the corresponding SymPy routines.

The complex expansion in crates/symox-core/src/complex_parts.rs (as_real_imag,
expand_complex and expand(complex=True)) follows the corresponding SymPy
as_real_imag methods, Expr._expand_hint ordering and the final Abs.eval rule.
The expand_log rule for powers with real exponents in -1 < e <= 1 in
crates/symox-core/src/simp.rs follows SymPy's log._eval_expand_log; the
argument splitting of expand_log (integer perfect powers, rationals, signed
and polar factors of products, powers and exp) is ported from that method,
and logcombine in the same file is a port of logcombine from
sympy/simplify/simplify.py.
The SymPy distribution copyright and license notices are reproduced below.

Copyright (c) 2006-2023 SymPy Development Team

All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

  a. Redistributions of source code must retain the above copyright notice,
     this list of conditions and the following disclaimer.
  b. Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in the
     documentation and/or other materials provided with the distribution.
  c. Neither the name of SymPy nor the names of its contributors
     may be used to endorse or promote products derived from this software
     without specific prior written permission.


THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.

--------------------------------------------------------------------------------

Patches that were taken from the Diofant project (https://github.com/diofant/diofant)
are licensed as:

Copyright (c) 2006-2018 SymPy Development Team,
              2013-2023 Sergey B Kirpichev

All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

  a. Redistributions of source code must retain the above copyright notice,
     this list of conditions and the following disclaimer.
  b. Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in the
     documentation and/or other materials provided with the distribution.
  c. Neither the name of Diofant or SymPy nor the names of its contributors
     may be used to endorse or promote products derived from this software
     without specific prior written permission.


THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.

--------------------------------------------------------------------------------

Submodules taken from the multipledispatch project (https://github.com/mrocklin/multipledispatch)
are licensed as:

Copyright (c) 2014 Matthew Rocklin

All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

  a. Redistributions of source code must retain the above copyright notice,
     this list of conditions and the following disclaimer.
  b. Redistributions in binary form must reproduce the above copyright
     notice, this list of conditions and the following disclaimer in the
     documentation and/or other materials provided with the distribution.
  c. Neither the name of multipledispatch nor the names of its contributors
     may be used to endorse or promote products derived from this software
     without specific prior written permission.


THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
DAMAGE.

--------------------------------------------------------------------------------

The files under the directory sympy/parsing/autolev/tests/pydy-example-repo
are directly copied from PyDy project and are licensed as:

Copyright (c) 2009-2023, PyDy Authors
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright
  notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
  notice, this list of conditions and the following disclaimer in the
  documentation and/or other materials provided with the distribution.
* Neither the name of this project nor the names of its contributors may be
  used to endorse or promote products derived from this software without
  specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL PYDY AUTHORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

--------------------------------------------------------------------------------

The files under the directory sympy/parsing/latex 
are directly copied from latex2sympy project and are licensed as:

Copyright 2016, latex2sympy

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

The hyper-representation analytic continuation formulas and helper interfaces in
python/symox/_special_extensions.py adapt sympy/functions/special/hyper.py
(SymPy 1.14), using symox scalar operations and native expression heads.

The fact-rule engine and pre-generated assumption tables in
python/symox/core/facts.py and python/symox/core/assumptions_generated.py are
copied from sympy/core/facts.py and sympy/core/assumptions_generated.py
(SymPy 1.14). The assumption rule objects, StdFactKB, _ask and class
assumption preparation in python/symox/core/assumptions.py, the Logic classes
in python/symox/core/logic.py, the decorators in python/symox/core/decorators.py,
AssocOp, LatticeOp and ShortCircuit in python/symox/core/operations.py, the
global parameters in python/symox/core/parameters.py, the Registry class in
python/symox/core/core.py, the class ordering and comparison helpers in
python/symox/core/basic.py, the node counting in
python/symox/utilities/sorting.py, the Add/Mul construction helpers in
python/symox/core/add.py and python/symox/core/mul.py and the evalf handler
table in python/symox/core/evalf.py adapt the corresponding SymPy 1.14 code to
native Symox expressions.

The mpmath evaluation adapters in python/symox/_mpmath_special.py follow the
numerical evaluation methods (_eval_evalf) of the SymPy 1.14 special-function
classes, including the Meijer G branch handling of sympy/functions/special/hyper.py.

The ordinary differential equation solvers in python/symox/solvers/ode/ode.py,
single.py, riccati.py, nonhomogeneous.py, hypergeometric.py, systems.py,
subscheck.py, _lie_heuristics.py and _ode_helpers.py, and the partial
differential equation solvers in python/symox/solvers/pde.py, are adapted from
sympy/solvers/ode/*.py, sympy/solvers/pde.py and sympy/solvers/deutils.py of
SymPy 1.14: classification, hint ordering, solution forms, constant handling,
initial conditions and solution checks follow the reference. The structural
pattern matcher in python/symox/_matching.py is adapted from the matches
methods of sympy/core/basic.py, sympy/core/operations.py, sympy/core/mul.py,
sympy/core/add.py, sympy/core/power.py and sympy/core/symbol.py.
