Create DAG out of melody

[oggy22]

Given a melody, create a DAG which breaks the melody down, looking for similarities. If multiple DAGs are possible, take one with the fittest score based on a criteria. A criteria should be probably one of the following:

• take the DAG with lowest memory requirement.
• take the DAG with lowest length sum of the leaf nodes.
• something else

This may be a hard AI/NP problem.

p.s. DAG is representation of melody as Directed Acyclic graph such that nodes represent parts of the melody, and edges represent containment i.e. "this part is composed of these smaller parts". The root node represent the whole melody.

[oggy22]

This problem is known as Smallest Grammar Problem in Chomsky grammars, and there are papers on its applications in music.

[oggy22]

The input should be midi files with fugal-like works. Fugal like work is a composition where each track has no more than a single tone in a time.

[oggy22]

The output should be a graphical layout of DAG with each node being a musical sheet snippet without clef. Each node will include stats as:

• what parts it is consisted of e.g. R3 = R1 R1 R2, or saying it's a leaf i.e. atomic part
• number of times it is repeated in the composition and corresponding places in the composition
• if inversions are possible/enabled (vertical and/or horizontal), it should note how many each of inversions is used

Each node will provide interface for modifications, so you can modify it and replay the composition.

You should be able to sort nodes based on:

• repetitions
• length

[oggy22]

The program should work nicely on Bach inventions, especially C major, D minor, F major, G major and A minor.

[oggy22]

The program should be able to analyze multiple compositions in parallel, e.g. all the 15 inventions by Bach and therefore provide some insights, possibly, to entire corpus.

[oggy22]

Here is code design:

interface IDuration { Fraction duration; }
class note : IDuration
{
}

class ChromaticPassage : IDuration, IEnumerable<note>
{
  List<IDuration> parts;
  duration => parts.Sum(part => part.duration);
  int offset;
}

class DiatonicPassage : IDuration
{
}

[oggy22]

If there were only chromatic melodies:

interface IMelodyPart { Fraction duration; IEnumerable GetNotes(); }

class note : IMelodyPart { Fraction duration => duration; IEnumerable GetNotes() { if (pause) yield return this; else yield break; } ... }

class MelodyPartList : List { }

class ChromaticMelodyPart : IMelodyPart { Int offset; MelodyPartList list; IEnumerable GetNotes() { foreach mp in list foreach note in mp yield return note + offset; } }

[oggy22]

To add diatonic: class DiatonicMelodyPart : IMelodyPart { int offset; TwevleToneSet scale; MelodyPartList list; }

[oggy22]

More songs which should be analyzed nicely: Winter wonderlands Mozart 6th symphony 1st movement Albinoni adagio

[oggy22]

This is mostly done by #29, and partly by #50, #63 etc, so I am closing it.

However, as of now, there are some missing parts as #36, #44 etc.