def get_coh_hrep_as_coeff_vrep(K, num_type='fraction'): """Compute a minimal H-representation for coherence See Procedure C.4 in my ISIPTA '13 paper “Characterizing coherence, correcting incoherence”. """ k = len(K) lhs, rhs = get_asl_lhs_rhs_as_coeff_vrep(K) for i in xrange(k): S = generate_Sasl_pos_dirs(k, i) minusS = generate_Sasl_neg_dirs(k, i) coeff_one_lhs = transpose(K) + minusS coeff_one_rhs = ([1] * (len(coeff_one_lhs) - k)) + ([0] * k) coeff_one_hrep = make_hrep(coeff_one_lhs, coeff_one_rhs, num_type) coeff_one_vrep = Polyhedron(coeff_one_hrep).get_generators() lhs.extend(list(t[1:]) for t in coeff_one_vrep[:]) rhs.extend(t[0] for t in coeff_one_vrep[:]) coeff_zero_lhs = transpose(K) + minusS + S coeff_zero_rhs = ([0] * (len(coeff_zero_lhs) - k)) + ([1] * k) coeff_zero_hrep = make_hrep(coeff_zero_lhs, coeff_zero_rhs, num_type) coeff_zero_vrep = Polyhedron(coeff_zero_hrep).get_generators() lhs.extend(list(t[1:]) for t in coeff_zero_vrep[:]) rhs.extend([0] * len(coeff_zero_vrep)) pos_lhs = diagonallists([-1] * k) pos_rhs = ([0] * k) hrep = make_hrep(lhs + pos_lhs, rhs + pos_rhs, num_type) hrep.rep_type = RepType.INEQUALITY hrep.canonicalize() return hrep
def generate_asl_vrep(K, num_type='fraction'): """Generate the V-representation of avoiding sure loss See Equation (5) in my ISIPTA '13 paper “Characterizing coherence, correcting incoherence”. """ deg_prevs = transpose(K) neg_dirs = diagonallists([-1] * len(K)) return make_vrep(deg_prevs, neg_dirs, num_type)
def get_asl_hrep_as_coeff_vrep(K, num_type='fraction'): """Compute a minimal H-representation for positive avoiding sure loss See Procedure B.3 in my ISIPTA '13 paper “Characterizing coherence, correcting incoherence”; this function adds positivity costraints and does redundancy removal on the output of `get_asl_lhs_rhs_as_coeff_vrep`. """ k = len(K) lhs, rhs = get_asl_lhs_rhs_as_coeff_vrep(K, num_type) pos_lhs = diagonallists([-1] * k) pos_rhs = ([0] * k) hrep = make_hrep(lhs + pos_lhs, rhs + pos_rhs, num_type) hrep.canonicalize() return hrep
def get_asl_lhs_rhs_as_coeff_vrep(K, num_type='fraction'): """Compute a partial H-representation for positive avoiding sure loss See Procedure B.3 in my ISIPTA '13 paper “Characterizing coherence, correcting incoherence”; this function does not add positivity costraints or do redundancy removal. """ k = len(K) coeff_lhs = transpose(K) + diagonallists([-1] * k) coeff_rhs = ([1] * (len(coeff_lhs) - k)) + ([0] * k) coeff_hrep = make_hrep(coeff_lhs, coeff_rhs, num_type) coeff_vrep = Polyhedron(coeff_hrep).get_generators() lhs = [list(t[1:]) for t in coeff_vrep[:]] rhs = [t[0] for t in coeff_vrep[:]] return lhs, rhs
def generate_Sasl_pos_dirs(k, i): """Generate diagonal list of size `k` with 1s, apart from -1 at `i`""" pre = i post = k - i - 1 return diagonallists([1] * pre + [-1] + [1] * post)