def setUp(self):
from jazzparser.formalisms.music_halfspan.rules import ApplicationRule
from jazzparser.formalisms.music_halfspan.syntax import (
AtomicCategory,
ComplexCategory,
HalfCategory,
Sign,
Slash,
)
from jazzparser.formalisms.music_halfspan.semantics import DummyLogicalForm, Semantics
from jazzparser.grammar import Grammar
# Use the default grammar
self.grammar = Grammar()
# Get a rule to instantiate: forward application
self.rule = self.grammar.rules_by_name["appf"]
# Create some categories we can store as if the rule applied to them
# Create an atomic category
self.cat0 = AtomicCategory(HalfCategory("I"), HalfCategory("I"))
# Create a complex category that could be applied to the atomic one
self.cat1 = ComplexCategory(
HalfCategory("V", function="D"), Slash(True), HalfCategory("I", function=["D", "T"])
)
# An atomic category, as if 0 was applied to 1
self.cat2 = AtomicCategory(HalfCategory("V", function="D"), HalfCategory("I"))
# A dummy semantics to use for all signs
dummy_sem = Semantics(DummyLogicalForm())
# Create signs from the categories
self.sign0 = Sign(self.cat0, dummy_sem.copy())
self.sign1 = Sign(self.cat1, dummy_sem.copy())
self.sign2 = Sign(self.cat2, dummy_sem.copy())
def test_back_conversion(self):
"""
Creates a tonal space path, converts it to state labels and converts
it back again. This should produce the original path if all goes
well.
Note that the result of the back conversion will always have the
path shifted so it starts as close as possible to the origin. This is
correct behaviour: the state labels don't encode the enharmonic
block that the path starts in and it is merely by convention that we
assume the start point.
Each path-chord sequence pair also gives the expected output, which
may differ from the original path only in this respect.
@todo: update this test
"""
# Just return for now: I've not had a chance to update this
# lf_chords_to_states no longer exists
return
self.longMessage = True
# Run the test on a whole set of paths
for (coords, chords, output) in self.PATHS:
# Build a CoordinateList for the path
ens = [
EnharmonicCoordinate.from_harmonic_coord((x, y))
for (x, y, fun) in coords
]
pcs = [PathCoordinate.from_enharmonic_coord(en) for en in ens]
time = 0
for pc, (__, __, fun) in zip(pcs, coords):
pc.function = fun
pc.duration = 1
pc.time = time
time += 1
path = Semantics(CoordinateList(items=pcs))
# Build the list of chords
chords = [Chord.from_name(crd).to_db_mirror() for crd in chords]
for chord in chords:
chord.duration = 1
# Try converting it to states
states = lf_chords_to_states(path, chords)
# Now try converting it back
back = states_chords_to_lf(zip(states, chords))
# Check that we got the same coordinates out
in_coords = [(x, y) for (x, y, fun) in output]
in_funs = [fun for (x, y, fun) in output]
out_coords = [point.harmonic_coord for point in back.lf]
out_funs = [point.function for point in back.lf]
self.assertEqual(
in_coords,
out_coords,
msg=
"coordinates converted to states and back produced something different.\nState labels:\n%s"
% (states))
self.assertEqual(
in_funs,
out_funs,
msg=
"coordinates converted to states and back produced different functions.\nState labels:\n%s"
% (states))
def test_paper_example(self):
"""
Generates the example that we used in the paper (from Alice in
Wonderland) as if it's coming from the combinators. Checks that
the right overall LF comes out.
This is pretty insane, but a great test that the semantics is
behaving correctly in the contexts in which we'll be using it.
"""
sem = semantics_from_string
# Lexical
sem_0_1 = sem(r"[<0,0>]")
sem_1_2 = sem(r"\$x.$x")
# Bapply
sem_0_2 = apply(sem_1_2, sem_0_1)
self.assertTrue(sem_0_2.alpha_equivalent(sem(r"[<0,0>]")))
# Lexical
sem_2_3 = sem(r"\$x.leftonto($x)")
sem_3_4 = sem(r"\$x.leftonto($x)")
# Fcomp
sem_2_4 = compose(sem_2_3, sem_3_4)
self.assertTrue(sem_2_4.alpha_equivalent(
sem(r"\$x.leftonto(leftonto($x))")))
# Lexical
sem_4_5 = sem(r"\$x.leftonto($x)")
# Fcomp
sem_2_5 = compose(sem_2_4, sem_4_5)
self.assertTrue(sem_2_5.alpha_equivalent(
sem(r"\$x.leftonto(leftonto(leftonto($x)))")))
# Lexical
sem_5_6 = sem(r"\$x.leftonto($x)")
# Fcomp
sem_2_6 = compose(sem_2_5, sem_5_6)
self.assertTrue(sem_2_6.alpha_equivalent(
sem(r"\$x.leftonto(leftonto(leftonto(leftonto($x))))")))
# Lexical
sem_6_7 = sem(r"\$x.leftonto($x)")
# Fcomp
sem_2_7 = compose(sem_2_6, sem_6_7)
self.assertTrue(sem_2_7.alpha_equivalent(
sem(r"\$x.leftonto(leftonto(leftonto(leftonto(leftonto($x)))))")))
# Lexical
sem_7_8 = sem(r"\$x.leftonto($x)")
sem_8_9 = sem(r"\$x.$x")
# Fcomp
sem_7_9 = compose(sem_7_8, sem_8_9)
self.assertTrue(sem_7_9.alpha_equivalent(
sem(r"\$x.leftonto($x)")))
# Lexical
sem_9_10 = sem(r"\$x.leftonto($x)")
# Fcomp
sem_7_10 = compose(sem_7_9, sem_9_10)
self.assertTrue(sem_7_10.alpha_equivalent(
sem(r"\$x.leftonto(leftonto($x))")))
# Coord
sem_2_10 = Semantics(Coordination([sem_2_7.lf, sem_7_10.lf]))
sem_2_10.beta_reduce()
semtest = sem(r"(\$x.leftonto(leftonto(leftonto(leftonto(leftonto($x)))))) "\
"& (\$x.leftonto(leftonto($x)))")
semtest.beta_reduce()
self.assertTrue(sem_2_10.alpha_equivalent(semtest))
# Lexical
sem_10_11 = sem(r"\$x.leftonto($x)")
# Fcomp
sem_2_11 = compose(sem_2_10, sem_10_11)
semtest = sem(r"\$y.("\
"((\$x.leftonto(leftonto(leftonto(leftonto(leftonto($x)))))) "\
"& (\$x.leftonto(leftonto($x)))) leftonto($y))")
semtest.beta_reduce()
self.assertTrue(sem_2_11.alpha_equivalent(semtest))
# Skip a couple of lexical LFs
sem_11_13 = sem(r"\$x.leftonto(leftonto($x))")
# Coord
sem_2_13 = Semantics(Coordination([sem_2_11.lf, sem_11_13.lf]))
sem_2_13.beta_reduce()
semtest = sem(r"(\$y.("\
"((\$x.leftonto(leftonto(leftonto(leftonto(leftonto($x)))))) "\
"& (\$x.leftonto(leftonto($x)))) leftonto($y))) "\
"& (\$x.leftonto(leftonto($x)))")
semtest.beta_reduce()
self.assertTrue(sem_2_13.alpha_equivalent(semtest))
# Lexical
sem_13_14 = sem(r"[<0,0>]")
# Fapply
sem_2_14 = apply(sem_2_13, sem_13_14)
semtest = sem(r"((\$y.("\
"((\$x.leftonto(leftonto(leftonto(leftonto(leftonto($x)))))) "\
"& (\$x.leftonto(leftonto($x)))) leftonto($y))) "\
"& (\$x.leftonto(leftonto($x))) [<0,0>])")
semtest.beta_reduce()
self.assertTrue(sem_2_14.alpha_equivalent(semtest))
# Finally, development
sem_0_14 = Semantics(ListCat([sem_0_2.lf, sem_2_14.lf]))
sem_0_14.beta_reduce()
semtest = sem(r"[<0,0>, "\
"((\$y.("\
"((\$x.leftonto(leftonto(leftonto(leftonto(leftonto($x)))))) "\
"& (\$x.leftonto(leftonto($x)))) leftonto($y))) "\
"& (\$x.leftonto(leftonto($x))) <0,0>)]")
semtest.beta_reduce()
self.assertTrue(sem_0_14.alpha_equivalent(semtest))
