def apply(given, index=0):
from sympy.concrete.limits import limits_dict
function, *limits = given.of(All)
limit = limits.pop(index)
limitsDict = limits_dict([limit])
eqs = []
for var, domain in limitsDict.items():
if isinstance(domain, list):
cond = conditionset.conditionset(var, *domain).simplify()
elif domain.is_set:
cond = Contains(var, domain).simplify()
else:
assert domain.is_boolean
cond = domain
eqs.append(cond.invert().simplify())
if function.is_Or:
eqs += function.args
else:
eqs.append(function)
if limits:
return All(Or(*eqs), *limits)
return Or(*eqs)
def apply(given, old, new):
from sympy.concrete.limits import limits_dict
cond, *limits = given.of(All)
domain_defined = new.domain
domain = limits_dict(limits)[old]
assert domain.is_set
assert domain_defined in domain
return cond._subs(old, new)
def apply(given, old, new):
from sympy.concrete.limits import limits_dict
(function, *limits_f), *limits_e = given.of(Any[All])
limits_f_dict = limits_dict(limits_f)
domain = limits_f_dict[old]
if domain == []:
...
else:
assert new in domain
return Any(All(function._subs(old, new) & function, *limits_f), *limits_e)
def apply(given, old, new):
from sympy.concrete.limits import limits_dict
cond, *limits = given.of(All)
domain = limits_dict(limits)[old]
if domain.is_set:
assert new in domain
elif domain.is_boolean:
assert domain._subs(old, new)
else:
return
return cond._subs(old, new)
def apply(given):
from sympy.concrete.limits import limits_dict
function, *limits = given.of(All)
function.of(Equal)
dic = limits_dict(limits)
assert len(dic) == 1
(x, domain), *_ = dic.items()
assert domain.is_Range
lhs, rhs = function.args
return Equal(Lamda[x:domain](lhs).simplify(),
Lamda[x:domain](rhs).simplify())
def doit(cls, self, simplify=True):
from sympy.concrete.limits import limits_dict
(expr, *limits), limit = self.of(Limit[cls])
x = limit[0]
assert x not in limits_dict(limits)
expr = Limit(expr, limit)
if simplify:
expr = expr.doit()
for i, (x, *ab) in enumerate(limits):
for j, t in enumerate(ab):
t = Limit(t, limit)
if simplify:
t = t.doit()
ab[j] = t
limits[i] = (x, *ab)
return cls(expr, *limits)
def apply(given, excludes=None):
from sympy.concrete.limits import limits_dict
(xi, *limits), (_xi, *_limits) = given.of(Equal[Abs[Cup], Sum[Abs]])
assert xi == _xi
assert limits == _limits
limitsDict = limits_dict(limits)
i, *_ = limitsDict.keys()
kwargs = i._assumptions.copy()
if 'domain' in kwargs:
del kwargs['domain']
j = xi.generate_var(excludes=excludes, **kwargs)
xj = xi.subs(i, j)
i_domain = limitsDict[i] or i.domain
limits = [(j, i_domain - {i})] + [*limits]
return All(Equal(xi & xj, xi.etype.emptySet).simplify(), *limits)