def cyclic_core(f, care, fol):
"""Shallow minimal cover, only up to cyclic core."""
log.info('cyclic core computation')
t0 = time.time()
# assert
assert f in fol.bdd, f
assert care in fol.bdd, care
assert care != fol.false, 'empty care set'
assert f != fol.false, 'nothing to cover'
assert f != fol.true or care != fol.true, (
'no variables involved in problem')
prm = lat.setup_aux_vars(f, care, fol)
lat.setup_lattice(prm, fol)
fcare = ~care | f
bab = _BranchAndBound(prm, fol)
# covering problem
x = lat.embed_as_implicants(f, prm, fol)
y = lat.prime_implicants(fcare, prm, fol)
# assert problem is feasible
assert x != fol.false
assert y != fol.false
assert _covers(y, f, prm, fol)
xcore, ycore, essential = _cyclic_core_fixpoint(x, y, bab, fol)
if xcore == fol.false:
assert _covers(essential, f, prm, fol)
_print_cyclic_core(x, y, xcore, ycore, essential, t0, bab.prm, fol)
return xcore, ycore, essential
def test_cyclic_core_recursion():
"""One cyclic core."""
fol = _fol.Context()
fol.declare(x=(0, 1), y=(0, 1), z=(0, 1))
s = r'''
(
\/ (z = 1 /\ y = 0)
\/ (x = 0 /\ z = 1)
\/ (y = 1 /\ x = 0)
\/ (y = 1 /\ z = 0)
\/ (x = 1 /\ z = 0)
\/ (x = 1 /\ y = 0)
)
'''
f = fol.add_expr(s)
care = fol.true
# setup variables and lattice
prm = lat.setup_aux_vars(f, care, fol)
lat.setup_lattice(prm, fol)
# covering problem
fcare = f | ~care
x = lat.embed_as_implicants(f, prm, fol)
y = lat.prime_implicants(fcare, prm, fol)
# enumerative check
enumerated_covers(x, y, prm, fol)
# symbolically minimize
mincovers = cov_enum.minimize(f, care, fol)
n = len(mincovers)
assert n == 2, (n, mincovers)
for cover in mincovers:
n = fol.count(cover)
primes = list(fol.pick_iter(cover))
assert n == 3, (n, primes)
def cyclic_core(f, care, fol):
"""Shallow minimal cover, only up to cyclic core."""
log.info('cyclic core computation')
t0 = time.time()
# assert
assert f in fol.bdd, f
assert care in fol.bdd, care
assert care != fol.false, 'empty care set'
assert f != fol.false, 'nothing to cover'
assert f != fol.true or care != fol.true, (
'no variables involved in problem')
prm = lat.setup_aux_vars(f, care, fol)
lat.setup_lattice(prm, fol)
fcare = ~ care | f
bab = _BranchAndBound(prm, fol)
# covering problem
x = lat.embed_as_implicants(f, prm, fol)
y = lat.prime_implicants(fcare, prm, fol)
# assert problem is feasible
assert x != fol.false
assert y != fol.false
assert _covers(y, f, prm, fol)
xcore, ycore, essential = _cyclic_core_fixpoint(
x, y, bab, fol)
if xcore == fol.false:
assert _covers(essential, f, prm, fol)
_print_cyclic_core(
x, y, xcore, ycore, essential,
t0, bab.prm, fol)
return xcore, ycore, essential
def minimize(f, care, fol):
"""Compute minimal DNF of predicate `f` over integers.
@param f: predicate over integer-valued variables
@param care: care set as predicate over same variables
@type f, care: BDD node
@type fol: `omega.symbolic.fol.Context`
@return: minimal cover as BDD over parameters
@rtype: BDD node
"""
# reasons for permisiveness here:
#
# - enable inspecting env violations of assumption
# - make errors visible
# - use entire instantiation domain
# - permit computing DNF for care set using same `fol.vars`
# - tests
if not _care_implies_type_hints(f, care, fol):
log.warning('care set should imply type hints')
# could let
# f &= care
# but explicit is better.
# Also, this permits working outside type hints.
if not _f_implies_care(f, care, fol):
log.warning('f should imply care set')
if (f | ~ care) == fol.true:
log.warning('f covers care set, so trivial cover')
log.info('---- branching ----')
path_cost = 0.0
prm = lat.setup_aux_vars(f, care, fol)
lat.setup_lattice(prm, fol)
# covering problem
fcare = f | ~ care
# the slack is introduced by having more primes
# (those for `fcare`) to cover the same minterms (`f`)
x = lat.embed_as_implicants(f, prm, fol)
y = lat.prime_implicants(fcare, prm, fol)
bab = _BranchAndBound(prm, fol)
# initialize upper bound
bab.upper_bound = _upper_bound(
x, y, prm.p_leq_q, prm.p_to_q, fol)
# assert covers(bab.best_cover, f, prm, fol)
cover, _ = _traverse(x, y, path_cost, bab, fol)
if cover is None:
cover, _ = _some_cover(x, y, prm.p_leq_q, p_to_q, fol)
assert cover is not None
cover = unfloors(cover, y, fol, bab)
assert_is_a_cover_from_y(
cover, y, f, prm, fol)
low = care & ~ f
assert _none_covered(cover, low, prm, fol)
log.info('==== branching ==== ')
return cover
def minimize(f, care, fol):
"""Compute minimal DNF of predicate `f` over integers.
@param f: predicate over integer-valued variables
@param care: care set as predicate over same variables
@type f, care: BDD node
@type fol: `omega.symbolic.fol.Context`
@return: minimal cover as BDD over parameters
@rtype: BDD node
"""
# reasons for permisiveness here:
#
# - enable inspecting env violations of assumption
# - make errors visible
# - use entire instantiation domain
# - permit computing DNF for care set using same `fol.vars`
# - tests
if not _care_implies_type_hints(f, care, fol):
log.warning('care set should imply type hints')
# could let
# f &= care
# but explicit is better.
# Also, this permits working outside type hints.
if not _f_implies_care(f, care, fol):
log.warning('f should imply care set')
if (f | ~ care) == fol.true:
log.warning('f covers care set, so trivial cover')
log.info('---- branching ----')
path_cost = 0.0
prm = lat.setup_aux_vars(f, care, fol)
lat.setup_lattice(prm, fol)
# covering problem
fcare = f | ~ care
# the slack is introduced by having more primes
# (those for `fcare`) to cover the same minterms (`f`)
x = lat.embed_as_implicants(f, prm, fol)
y = lat.prime_implicants(fcare, prm, fol)
bab = _BranchAndBound(prm, fol)
# initialize upper bound
bab.upper_bound = _upper_bound(
x, y, prm.p_leq_q, prm.p_to_q, fol)
# assert covers(bab.best_cover, f, prm, fol)
cover, _ = _traverse(x, y, path_cost, bab, fol)
if cover is None:
cover, _ = _some_cover(x, y, prm.p_leq_q, p_to_q, fol)
assert cover is not None
cover = unfloors(cover, y, fol, bab)
assert_is_a_cover_from_y(
cover, y, f, prm, fol)
low = care & ~ f
assert _none_covered(cover, low, prm, fol)
log.info('==== branching ==== ')
return cover
def test_scaling_equality():
aut = _fol.Context()
x_vars = dict(x=(0, 10), y=(0, 15), z=(0, 15))
aut.declare(**x_vars)
params = dict(pa='a', pb='b', qa='u', qb='v')
p_dom = lat._parameter_table(x_vars,
aut.vars,
a_name=params['pa'],
b_name=params['pb'])
q_dom = lat._parameter_table(x_vars,
aut.vars,
a_name=params['qa'],
b_name=params['qb'])
aut.declare(**p_dom)
aut.declare(**q_dom)
px = lat._map_vars_to_parameters(x_vars,
a_name=params['pa'],
b_name=params['pb'])
qx = lat._map_vars_to_parameters(x_vars,
a_name=params['qa'],
b_name=params['qb'])
p_to_q = lat._renaming_between_parameters(px, qx)
x_as_x = {xj: dict(a=xj, b=xj) for xj in px}
varmap = lat.parameter_varmap(px, x_as_x)
log.info('Number of variables: {n}'.format(n=len(varmap)))
u = lat.subseteq(varmap, aut)
#
s = ('( '
'(z = 1 /\ y <= 0) \/ '
'(x = 0 /\ z = 1) \/ '
'(y >= 1 /\ x <= 0) \/ '
'(y >= 1 /\ z <= 0) \/ '
'(x >= 1 /\ z <= 0) \/ '
'(x >= 1 /\ y <= 0) '
') ')
f = aut.add_expr(s)
prm = lat.Parameters()
prm._px = px
lat.embed_as_implicants(f, prm, aut)
def _none_covered(cover_p, f, prm, fol):
"""Return `True` if `cover_p` covers no minterm in `f`.
Arguments similar to `covers`.
"""
fp = lat.embed_as_implicants(f, prm, fol)
fq = fol.let(prm.p_to_q, fp)
# \A p: \/ ~ cover(p)
# \/ ~ \E q: /\ f(q)
# /\ Intersect(p, q)
r = fq & lat.implicants_intersect(prm, fol)
r = ~fol.exist(prm.q_vars, r)
r |= ~cover_p
r = fol.forall(prm.p_vars, r)
return r == fol.true
def test_scaling_equality():
aut = _fol.Context()
x_vars = dict(x=(0, 10), y=(0, 15), z=(0, 15))
aut.declare(**x_vars)
params = dict(pa='a', pb='b', qa='u', qb='v')
p_dom = lat._parameter_table(
x_vars, aut.vars,
a_name=params['pa'], b_name=params['pb'])
q_dom = lat._parameter_table(
x_vars, aut.vars,
a_name=params['qa'], b_name=params['qb'])
aut.declare(**p_dom)
aut.declare(**q_dom)
px = lat._map_vars_to_parameters(
x_vars, a_name=params['pa'], b_name=params['pb'])
qx = lat._map_vars_to_parameters(
x_vars, a_name=params['qa'], b_name=params['qb'])
p_to_q = lat._renaming_between_parameters(px, qx)
x_as_x = {xj: dict(a=xj, b=xj) for xj in px}
varmap = lat.parameter_varmap(px, x_as_x)
log.info('Number of variables: {n}'.format(n=len(varmap)))
u = lat.subseteq(varmap, aut)
#
s = (
'( '
'(z = 1 /\ y <= 0) \/ '
'(x = 0 /\ z = 1) \/ '
'(y >= 1 /\ x <= 0) \/ '
'(y >= 1 /\ z <= 0) \/ '
'(x >= 1 /\ z <= 0) \/ '
'(x >= 1 /\ y <= 0) '
') ')
f = aut.add_expr(s)
prm = lat.Parameters()
prm._px = px
lat.embed_as_implicants(f, prm, aut)
def minimize(f, care, fol):
"""Compute minimal DNF of predicate `f` over integers.
@param f: predicate over integer-valued variables
@param care: care set as predicate over same variables
@type f, care: BDD node
@type fol: `omega.symbolic.fol.Context`
@return: minimal covers as BDDs over parameters
@rtype: set of BDD nodes
"""
# reasons for permisiveness here:
#
# - enable inspecting env violations of assumption
# - make errors visible
# - use entire instantiation domain
# - permit computing DNF for care set using same `fol.vars`
# - tests
if not cov._care_implies_type_hints(f, care, fol):
log.warning('care set should imply type hints')
# could let
# f &= care
# but explicit is better.
# Also, this permits working outside type hints.
if not cov._f_implies_care(f, care, fol):
log.warning('f should imply care set')
if (f | ~care) == fol.true:
log.warning('f covers care set, so trivial cover')
log.info('---- branch and bound search ----')
prm = lat.setup_aux_vars(f, care, fol)
lat.setup_lattice(prm, fol)
# covering problem
fcare = f | ~care
x = lat.embed_as_implicants(f, prm, fol)
y = lat.prime_implicants(fcare, prm, fol)
bab = cov._BranchAndBound(prm, fol)
# initialize upper bound
bab.upper_bound = cov._upper_bound(x, y, prm.p_leq_q, prm.p_to_q, fol)
path_cost = 0.0
mincovers = _cyclic_core_fixpoint_recursive(x, y, path_cost, bab, fol)
# assert
assert mincovers
for cover in mincovers:
cov.assert_is_a_cover_from_y(cover, y, f, prm, fol)
low = care & ~f
assert cov._none_covered(cover, low, prm, fol)
log.info('==== branch and bound search ==== ')
return mincovers
def _none_covered(
cover_p, f, prm, fol):
"""Return `True` if `cover_p` covers no minterm in `f`.
Arguments similar to `covers`.
"""
fp = lat.embed_as_implicants(f, prm, fol)
fq = fol.let(prm.p_to_q, fp)
# \A p: \/ ~ cover(p)
# \/ ~ \E q: /\ f(q)
# /\ Intersect(p, q)
r = fq & lat.implicants_intersect(prm, fol)
r = ~ fol.exist(prm.q_vars, r)
r |= ~ cover_p
r = fol.forall(prm.p_vars, r)
return r == fol.true
def test_embed_as_implicants():
fol, prm = setup_aut()
prm._px = dict(x=prm._px['x']) # restrict keys
u = fol.add_expr('2 <= x /\ x <= 9')
r = lat.embed_as_implicants(u, prm, fol)
r_ = lat._embed_as_implicants_naive(u, prm._px, fol)
assert r == r_, (r, r_)
v = fol.add_expr('(a_x = 2 /\ b_x = 2) \/'
'(a_x = 3 /\ b_x = 3) \/'
'(a_x = 4 /\ b_x = 4) \/'
'(a_x = 5 /\ b_x = 5) \/'
'(a_x = 6 /\ b_x = 6) \/'
'(a_x = 7 /\ b_x = 7) \/'
'(a_x = 8 /\ b_x = 8) \/'
'(a_x = 9 /\ b_x = 9)')
assert r == v
def test_embed_as_implicants():
fol, prm = setup_aut()
prm._px = dict(x=prm._px['x']) # restrict keys
u = fol.add_expr('2 <= x /\ x <= 9')
r = lat.embed_as_implicants(u, prm, fol)
r_ = lat._embed_as_implicants_naive(u, prm._px, fol)
assert r == r_, (r, r_)
v = fol.add_expr(
'(a_x = 2 /\ b_x = 2) \/'
'(a_x = 3 /\ b_x = 3) \/'
'(a_x = 4 /\ b_x = 4) \/'
'(a_x = 5 /\ b_x = 5) \/'
'(a_x = 6 /\ b_x = 6) \/'
'(a_x = 7 /\ b_x = 7) \/'
'(a_x = 8 /\ b_x = 8) \/'
'(a_x = 9 /\ b_x = 9)')
assert r == v
def _covers(cover_p, f, prm, fol):
"""Return `True` if `cover_p` covers `f`.
This is the operator `IsACover` defined in the
module `spec/MinCover.tla`.
@param cover_p: primes, repr as `p`
@param f: elements to cover, repr as `x`
"""
fp = lat.embed_as_implicants(f, prm, fol)
cover_q = fol.let(prm.p_to_q, cover_p)
# \A p: \/ ~ f(p)
# \/ \E q: cover(q) /\ (p <= q)
r = cover_q & prm.p_leq_q
r = fol.exist(prm.q_vars, r)
r |= ~fp
r = fol.forall(prm.p_vars, r)
return r == fol.true
def _covers(
cover_p, f, prm, fol):
"""Return `True` if `cover_p` covers `f`.
This is the operator `IsACover` defined in the
module `spec/MinCover.tla`.
@param cover_p: primes, repr as `p`
@param f: elements to cover, repr as `x`
"""
fp = lat.embed_as_implicants(f, prm, fol)
cover_q = fol.let(prm.p_to_q, cover_p)
# \A p: \/ ~ f(p)
# \/ \E q: cover(q) /\ (p <= q)
r = cover_q & prm.p_leq_q
r = fol.exist(prm.q_vars, r)
r |= ~ fp
r = fol.forall(prm.p_vars, r)
return r == fol.true
def _minimize_two_managers(f, care, fol):
"""Optimized version of `minimize` for large problems."""
if not _care_implies_type_hints(f, care, fol):
log.warning('care set should imply type hints')
if not _f_implies_care(f, care, fol):
log.warning('f should imply care set')
if (f | ~ care) == fol.true:
log.warning('f covers care set, so trivial cover')
log.info('---- branching ----')
path_cost = 0.0
# x_vars, px, qx, p_to_q
prm = lat.setup_aux_vars(f, care, fol)
# manager where optimization happens
fol_2 = type(fol)()
fol_2.add_vars(fol.vars)
# x (to be covered)
log.info('embed implicants')
x = lat.embed_as_implicants(f, prm, fol)
x = fol.copy(x, fol_2)
# covering problem
fcare = f | ~ care
lat.setup_lattice(prm, fol_2)
# y (to use in cover)
log.info('primes')
fcare_2 = fol.copy(fcare, fol_2)
y = lat.prime_implicants(fcare_2, prm, fol_2)
del fcare_2
bab = _BranchAndBound(prm, fol_2)
# initialize upper bound
bab.upper_bound = _upper_bound(
x, y, prm.p_leq_q, prm.p_to_q, fol_2)
# assert _covers(bab.best_cover, f, prm, fol_2)
log.info('traverse')
cover, _ = _traverse(x, y, path_cost, bab, fol_2)
if cover is None:
cover, _ = _some_cover(x, y, prm.p_leq_q, prm.p_to_q, fol_2)
assert cover is not None
cover = unfloors(cover, y, fol_2, bab)
log.info('==== branching ==== ')
del fcare, prm, bab
cover = fol_2.copy(cover, fol)
return cover
def _minimize_two_managers(f, care, fol):
"""Optimized version of `minimize` for large problems."""
if not _care_implies_type_hints(f, care, fol):
log.warning('care set should imply type hints')
if not _f_implies_care(f, care, fol):
log.warning('f should imply care set')
if (f | ~ care) == fol.true:
log.warning('f covers care set, so trivial cover')
log.info('---- branching ----')
path_cost = 0.0
# x_vars, px, qx, p_to_q
prm = lat.setup_aux_vars(f, care, fol)
# manager where optimization happens
fol_2 = type(fol)()
fol_2.add_vars(fol.vars)
# x (to be covered)
log.info('embed implicants')
x = lat.embed_as_implicants(f, prm, fol)
x = fol.copy(x, fol_2)
# covering problem
fcare = f | ~ care
lat.setup_lattice(prm, fol_2)
# y (to use in cover)
log.info('primes')
fcare_2 = fol.copy(fcare, fol_2)
y = lat.prime_implicants(fcare_2, prm, fol_2)
del fcare_2
bab = _BranchAndBound(prm, fol_2)
# initialize upper bound
bab.upper_bound = _upper_bound(
x, y, prm.p_leq_q, prm.p_to_q, fol_2)
# assert _covers(bab.best_cover, f, prm, fol_2)
log.info('traverse')
cover, _ = _traverse(x, y, path_cost, bab, fol_2)
if cover is None:
cover, _ = _some_cover(x, y, prm.p_leq_q, prm.p_to_q, fol_2)
assert cover is not None
cover = unfloors(cover, y, fol_2, bab)
log.info('==== branching ==== ')
del fcare, prm, bab
cover = fol_2.copy(cover, fol)
return cover
