Remove conjunction and disjunction when not well-defined

This commit is contained in:
Brandon Rozek 2024-05-29 14:08:03 -04:00
parent df5b0f5161
commit 667eea0c70
No known key found for this signature in database
GPG key ID: 26E457DA82C9F480

View file

@ -49,28 +49,39 @@ def parse_matrices(infile: TextIO) -> List[Tuple[Model, Dict]]:
for mimplication in results: for mimplication in results:
logical_operations = { logical_operations = {
mnegation, mconjunction, mdisjunction, mnegation, mimplication
mimplication
} }
model = Model(carrier_set, logical_operations, designated_values) model = Model(carrier_set, logical_operations, designated_values, name=str(len(solutions)))
interpretation = { interpretation = {
Negation: mnegation, Negation: mnegation,
Conjunction: mconjunction,
Disjunction: mdisjunction,
Implication: mimplication Implication: mimplication
} }
if mconjunction is not None:
logical_operations.add(mconjunction)
interpretation[Conjunction] = mconjunction
if mdisjunction is not None:
logical_operations.add(mdisjunction)
interpretation[Disjunction] = mdisjunction
solutions.append((model, interpretation)) solutions.append((model, interpretation))
print(f"Parsed Matrix {len(solutions)}") print(f"Parsed Matrix {model.name}")
return solutions return solutions
def carrier_set_from_size(size: int): def carrier_set_from_size(size: int):
"""
Construct a carrier set of model values
based on the desired size.
"""
return { return {
mvalue_from_index(i) for i in range(size + 1) mvalue_from_index(i) for i in range(size + 1)
} }
def parse_size(infile: TextIO) -> Optional[int]: def parse_size(infile: TextIO) -> Optional[int]:
# Elements are represented in hexidecimal """
Parse the line representing the matrix size.
NOTE: Elements are represented in hexidecimal.
"""
size = int(next(infile), 16) size = int(next(infile), 16)
if size == -1: if size == -1:
return None return None
@ -78,6 +89,9 @@ def parse_size(infile: TextIO) -> Optional[int]:
return size return size
def parse_negation(infile: TextIO, size: int) -> Optional[ModelFunction]: def parse_negation(infile: TextIO, size: int) -> Optional[ModelFunction]:
"""
Parse the line representing the negation table.
"""
line = next(infile).strip() line = next(infile).strip()
if line == '-1': if line == '-1':
return None return None
@ -91,16 +105,26 @@ def parse_negation(infile: TextIO, size: int) -> Optional[ModelFunction]:
y = parse_mvalue(j) y = parse_mvalue(j)
mapping[(x, )] = y mapping[(x, )] = y
return ModelFunction(1, mapping, "Negation") return ModelFunction(1, mapping, "¬")
def mvalue_from_index(i: int): def mvalue_from_index(i: int):
"""
Given an index, return the hexidecimal
representation of the model value.
"""
return ModelValue(f"a{hex(i)[-1]}") return ModelValue(f"a{hex(i)[-1]}")
def parse_mvalue(x: str) -> ModelValue: def parse_mvalue(x: str) -> ModelValue:
"""
Parse an element and return the model value.
"""
return mvalue_from_index(int(x, 16)) return mvalue_from_index(int(x, 16))
def determine_cresult(size: int, ordering: Dict[ModelValue, ModelValue], a: ModelValue, b: ModelValue) -> ModelValue: def determine_cresult(size: int, ordering: Dict[ModelValue, ModelValue], a: ModelValue, b: ModelValue) -> ModelValue:
"""
Determine what a b should be given the ordering table.
"""
for i in range(size + 1): for i in range(size + 1):
c = mvalue_from_index(i) c = mvalue_from_index(i)
@ -121,9 +145,10 @@ def determine_cresult(size: int, ordering: Dict[ModelValue, ModelValue], a: Mode
if not invalid: if not invalid:
return c return c
print(a, "&", b, "is not defined")
def determine_dresult(size: int, ordering: Dict[ModelValue, ModelValue], a: ModelValue, b: ModelValue) -> ModelValue: def determine_dresult(size: int, ordering: Dict[ModelValue, ModelValue], a: ModelValue, b: ModelValue) -> ModelValue:
"""
Determine what a b should be given the ordering table.
"""
for i in range(size + 1): for i in range(size + 1):
c = mvalue_from_index(i) c = mvalue_from_index(i)
if not ordering[(a, c)]: if not ordering[(a, c)]:
@ -143,9 +168,11 @@ def determine_dresult(size: int, ordering: Dict[ModelValue, ModelValue], a: Mode
if not invalid: if not invalid:
return c return c
print(a, "|", b, "is not defined")
def parse_order(infile: TextIO, size: int) -> Optional[Tuple[ModelFunction, ModelFunction]]: def parse_order(infile: TextIO, size: int) -> Optional[Tuple[ModelFunction, ModelFunction]]:
"""
Parse the line representing the ordering table
"""
line = next(infile).strip() line = next(infile).strip()
if line == '-1': if line == '-1':
return None return None
@ -164,11 +191,6 @@ def parse_order(infile: TextIO, size: int) -> Optional[Tuple[ModelFunction, Mode
omapping[(x, y)] = table[table_i] == '1' omapping[(x, y)] = table[table_i] == '1'
table_i += 1 table_i += 1
# NOTE: Print omapping for debugging
for (x, y) in omapping.keys():
print(x, y, "maps to", omapping[(x, y)])
cmapping = {} cmapping = {}
dmapping = {} dmapping = {}
@ -178,16 +200,30 @@ def parse_order(infile: TextIO, size: int) -> Optional[Tuple[ModelFunction, Mode
for j in range(size + 1): for j in range(size + 1):
y = mvalue_from_index(j) y = mvalue_from_index(j)
cmapping[(x, y)] = determine_cresult(size, omapping, x, y) cresult = determine_cresult(size, omapping, x, y)
dmapping[(x, y)] = determine_dresult(size, omapping, x, y) if cresult is None:
print("[Warning] Conjunction and Disjunction are not well-defined")
print(f"{x}{y} = ??")
return None, None
cmapping[(x, y)] = cresult
dresult = determine_dresult(size, omapping, x, y)
if dresult is None:
print("[Warning] Conjunction and Disjunction are not well-defined")
print(f"{x} {y} = ??")
return None, None
dmapping[(x, y)] = dresult
mconjunction = ModelFunction(2, cmapping, "Conjunction") mconjunction = ModelFunction(2, cmapping, "")
mdisjunction = ModelFunction(2, dmapping, "Disjunction") mdisjunction = ModelFunction(2, dmapping, "")
return mconjunction, mdisjunction return mconjunction, mdisjunction
def parse_designated(infile: TextIO, size: int) -> Optional[Set[ModelValue]]: def parse_designated(infile: TextIO, size: int) -> Optional[Set[ModelValue]]:
"""
Parse the line representing which model values are designated.
"""
line = next(infile).strip() line = next(infile).strip()
if line == '-1': if line == '-1':
return None return None
@ -206,6 +242,10 @@ def parse_designated(infile: TextIO, size: int) -> Optional[Set[ModelValue]]:
def parse_implication(infile: TextIO, size: int) -> Optional[List[ModelFunction]]: def parse_implication(infile: TextIO, size: int) -> Optional[List[ModelFunction]]:
"""
Parse the line representing the list of implication
tables.
"""
line = next(infile).strip() line = next(infile).strip()
if line == '-1': if line == '-1':
return None return None
@ -231,7 +271,7 @@ def parse_implication(infile: TextIO, size: int) -> Optional[List[ModelFunction]
mapping[(x, y)] = r mapping[(x, y)] = r
mimplication = ModelFunction(2, mapping, "Implication") mimplication = ModelFunction(2, mapping, "")
mimplications.append(mimplication) mimplications.append(mimplication)
return mimplications return mimplications
@ -241,13 +281,5 @@ if __name__ == "__main__":
solutions: List[Model] = parse_matrices(sys.stdin) solutions: List[Model] = parse_matrices(sys.stdin)
print(f"Parsed {len(solutions)} matrices") print(f"Parsed {len(solutions)} matrices")
for i, (model, interpretation) in enumerate(solutions): for i, (model, interpretation) in enumerate(solutions):
# TODO: Check if conjunction and disjunction are well defined while parsing print(model)
model.logical_operations -= {interpretation[Conjunction], interpretation[Disjunction]} print(has_vsp(model, interpretation))
del interpretation[Conjunction]
del interpretation[Disjunction]
# print(model)
if has_vsp(model, interpretation):
print(model)
print("Has VSP")
else:
print("Model", i, "does not have VSP")