feynlag.dirac.DiracGammaLower

class feynlag.dirac.DiracGammaLower(index)

Dirac gamma matrix γ_μ (lower Lorentz index).

__init__()

Methods

__init__()
adjoint()
apart([x])	See the apart function in sympy.polys
args_cnc([cset, warn, split_1])	Return [commutative factors, non-commutative factors] of self.
as_base_exp()
as_coeff_Add([rational])	Efficiently extract the coefficient of a summation.
as_coeff_Mul([rational])	Efficiently extract the coefficient of a product.
as_coeff_add(*deps)	Return the tuple (c, args) where self is written as an Add, a.
as_coeff_exponent(x)	c*x**e -> c,e where x can be any symbolic expression.
as_coeff_mul(*deps, **kwargs)	Return the tuple (c, args) where self is written as a Mul, m.
as_coefficient(expr)	Extracts symbolic coefficient at the given expression.
as_coefficients_dict(*syms)	Return a dictionary mapping terms to their Rational coefficient.
as_content_primitive([radical, clear])	This method should recursively remove a Rational from all arguments and return that (content) and the new self (primitive).
as_dummy()	Return the expression with any objects having structurally bound symbols replaced with unique, canonical symbols within the object in which they appear and having only the default assumption for commutativity being True.
as_expr(*gens)	Convert a polynomial to a SymPy expression.
as_independent(*deps, **hint)	A mostly naive separation of a Mul or Add into arguments that are not are dependent on deps.
as_leading_term(*symbols[, logx, cdir])	Returns the leading (nonzero) term of the series expansion of self.
as_numer_denom()	Return the numerator and the denominator of an expression.
as_ordered_factors([order])	Return list of ordered factors (if Mul) else [self].
as_ordered_terms([order, data])	Transform an expression to an ordered list of terms.
as_poly(*gens, **args)	Converts self to a polynomial or returns None.
as_powers_dict()	Return self as a dictionary of factors with each factor being treated as a power.
as_real_imag([deep])	Performs complex expansion on 'self' and returns a tuple containing collected both real and imaginary parts.
as_terms()	Transform an expression to a list of terms.
aseries([x, n, bound, hir])	Asymptotic Series expansion of self.
atoms(*types)	Returns the atoms that form the current object.
cancel(*gens, **args)	See the cancel function in sympy.polys
class_key()	Nice order of classes.
coeff(x[, n, right, _first])	Returns the coefficient from the term(s) containing x**n.
collect(syms[, func, evaluate, exact, ...])	See the collect function in sympy.simplify
combsimp()	See the combsimp function in sympy.simplify
compare(other)	Return -1, 0, 1 if the object is less than, equal, or greater than other in a canonical sense.
conjugate()	Returns the complex conjugate of 'self'.
copy()
could_extract_minus_sign()	Return True if self has -1 as a leading factor or has more literal negative signs than positive signs in a sum, otherwise False.
count(query)	Count the number of matching subexpressions.
count_ops([visual])	Wrapper for count_ops that returns the operation count.
diff(*symbols, **assumptions)
dir(x, cdir)
doit(**hints)	Evaluate objects that are not evaluated by default like limits, integrals, sums and products.
dummy_eq(other[, symbol])	Compare two expressions and handle dummy symbols.
equals(other[, failing_expression])	Return True if self == other, False if it does not, or None.
evalf([n, subs, maxn, chop, strict, quad, ...])	Evaluate the given formula to an accuracy of n digits.
expand([deep, modulus, power_base, ...])	Expand an expression using hints.
extract_additively(c)	Return self - c if it's possible to subtract c from self and make all matching coefficients move towards zero, else return None.
extract_branch_factor([allow_half])	Try to write self as exp_polar(2*pi*I*n)*z in a nice way.
extract_multiplicatively(c)	Return None if it's not possible to make self in the form c * something in a nice way, i.e. preserving the properties of arguments of self.
factor(*gens, **args)	See the factor() function in sympy.polys.polytools
find(query[, group])	Find all subexpressions matching a query.
fourier_series([limits])	Compute fourier sine/cosine series of self.
fps([x, x0, dir, hyper, order, rational, full])	Compute formal power power series of self.
fromiter(args, **assumptions)	Create a new object from an iterable.
gammasimp()	See the gammasimp function in sympy.simplify
getO()	Returns the additive O(..) symbol if there is one, else None.
getn()	Returns the order of the expression.
has(*patterns)	Test whether any subexpression matches any of the patterns.
has_free(*patterns)	Return True if self has object(s) x as a free expression else False.
has_xfree(s)	Return True if self has any of the patterns in s as a free argument, else False.
integrate(*args, **kwargs)	See the integrate function in sympy.integrals
invert(g, *gens, **args)	Return the multiplicative inverse of self mod g where self (and g) may be symbolic expressions).
is_algebraic_expr(*syms)	This tests whether a given expression is algebraic or not, in the given symbols, syms.
is_constant(*wrt, **flags)	Return True if self is constant, False if not, or None if the constancy could not be determined conclusively.
is_hypergeometric(k)
is_meromorphic(x, a)	This tests whether an expression is meromorphic as a function of the given symbol x at the point a.
is_polynomial(*syms)	Return True if self is a polynomial in syms and False otherwise.
is_rational_function(*syms)	Test whether function is a ratio of two polynomials in the given symbols, syms.
is_same(b[, approx])	Return True if a and b are structurally the same, else False.
leadterm(x[, logx, cdir])	Returns the leading term a*x**b as a tuple (a, b).
limit(x, xlim[, dir])	Compute limit x->xlim.
lseries([x, x0, dir, logx, cdir])	Wrapper for series yielding an iterator of the terms of the series.
match(pattern[, old])	Pattern matching.
matches(expr[, repl_dict, old])	Helper method for match() that looks for a match between Wild symbols in self and expressions in expr.
n([n, subs, maxn, chop, strict, quad, verbose])	Evaluate the given formula to an accuracy of n digits.
normal()	Return the expression as a fraction.
nseries([x, x0, n, dir, logx, cdir])	Wrapper to _eval_nseries if assumptions allow, else to series.
nsimplify([constants, tolerance, full])	See the nsimplify function in sympy.simplify
powsimp(*args, **kwargs)	See the powsimp function in sympy.simplify
primitive()	Return the positive Rational that can be extracted non-recursively from every term of self (i.e., self is treated like an Add).
radsimp(**kwargs)	See the radsimp function in sympy.simplify
ratsimp()	See the ratsimp function in sympy.simplify
rcall(*args)	Apply on the argument recursively through the expression tree.
refine([assumption])	See the refine function in sympy.assumptions
removeO()	Removes the additive O(..) symbol if there is one
replace(query, value[, map, simultaneous, exact])	Replace matching subexpressions of self with value.
rewrite(*args[, deep])	Rewrite self using a defined rule.
round([n])	Return x rounded to the given decimal place.
separate([deep, force])	See the separate function in sympy.simplify
series([x, x0, n, dir, logx, cdir])	Series expansion of "self" around x = x0 yielding either terms of the series one by one (the lazy series given when n=None), else all the terms at once when n != None.
simplify(**kwargs)	See the simplify function in sympy.simplify
sort_key([order])	Return a sort key.
subs(arg1[, arg2])	Substitutes old for new in an expression after sympifying args.
taylor_term(n, x, *previous_terms)	General method for the taylor term.
together(*args, **kwargs)	See the together function in sympy.polys
transpose()
trigsimp(**args)	See the trigsimp function in sympy.simplify
xreplace(rule)	Replace occurrences of objects within the expression.

Attributes

args	Returns a tuple of arguments of 'self'.
assumptions0	Return object type assumptions.
canonical_variables	Return a dictionary mapping any variable defined in self.bound_symbols to Symbols that do not clash with any free symbols in the expression.
default_assumptions
expr_free_symbols	Like free_symbols, but returns the free symbols only if they are contained in an expression node.
free_symbols	Return from the atoms of self those which are free symbols.
func	The top-level function in an expression.
index
is_Add
is_AlgebraicNumber
is_Atom
is_Boolean
is_Derivative
is_Dummy
is_Equality
is_Float
is_Function
is_Indexed
is_Integer
is_MatAdd
is_MatMul
is_Matrix
is_Mul
is_Not
is_Number
is_NumberSymbol
is_Order
is_Piecewise
is_Point
is_Poly
is_Pow
is_Rational
is_Relational
is_Symbol
is_Vector
is_Wild
is_algebraic
is_antihermitian
is_commutative
is_comparable	Return True if self can be computed to a real number (or already is a real number) with precision, else False.
is_complex
is_composite
is_even
is_extended_negative
is_extended_nonnegative
is_extended_nonpositive
is_extended_nonzero
is_extended_positive
is_extended_real
is_finite
is_hermitian
is_imaginary
is_infinite
is_integer
is_irrational
is_negative
is_noninteger
is_nonnegative
is_nonpositive
is_nonzero
is_number	Returns True if self has no free symbols and no undefined functions (AppliedUndef, to be precise).
is_odd
is_polar
is_positive
is_prime
is_rational
is_real
is_scalar
is_symbol
is_transcendental
is_zero
kind