There's a problem with the input file. For input #3, /4/, this candidate: [(1)0(2)(2)] violates the same constraints, the same number of times, as this candidate: [(1)(2)0(2)] Moreover, for input #3, /4/, this candidate: [00(1)0] violates the same constraints, the same number of times, as this candidate: [0(1)00] Moreover, for input #4, /5/, this candidate: [00(01)0] violates the same constraints, the same number of times, as this candidate: [0(01)00] Moreover, for input #4, /5/, this candidate: [(01)0(2)(2)] violates the same constraints, the same number of times, as this candidate: [(01)(2)0(2)] Moreover, for input #4, /5/, this candidate: [(1)(2)(02)(2)] violates the same constraints, the same number of times, as this candidate: [(1)(02)(2)(2)] Moreover, for input #4, /5/, this candidate: [(1)(2)(02)0] violates the same constraints, the same number of times, as this candidate: [(1)(02)(2)0] Moreover, for input #4, /5/, this candidate: [(1)(2)0(2)(2)] violates the same constraints, the same number of times, as this candidate: [(1)(2)(2)0(2)] Moreover, for input #4, /5/, this candidate: [(1)0(2)(2)(2)] violates the same constraints, the same number of times, as this candidate: [(1)(2)(2)0(2)] Moreover, for input #4, /5/, this candidate: [(1)0(2)(2)(2)] violates the same constraints, the same number of times, as this candidate: [(1)(2)0(2)(2)] Moreover, for input #4, /5/, this candidate: [(1)0(2)(2)0] violates the same constraints, the same number of times, as this candidate: [(1)(2)0(2)0] Moreover, for input #4, /5/, this candidate: [(1)00(2)(2)] violates the same constraints, the same number of times, as this candidate: [(1)(2)00(2)] Moreover, for input #4, /5/, this candidate: [(1)00(2)0] violates the same constraints, the same number of times, as this candidate: [(1)0(2)00] Moreover, for input #4, /5/, this candidate: [0(1)0(2)(2)] violates the same constraints, the same number of times, as this candidate: [0(1)(2)0(2)] Moreover, for input #4, /5/, this candidate: [00(1)(2)0] violates the same constraints, the same number of times, as this candidate: [0(1)(2)00] Moreover, for input #4, /5/, this candidate: [00(1)0(2)] violates the same constraints, the same number of times, as this candidate: [0(1)00(2)] Moreover, for input #4, /5/, this candidate: [00(1)00] violates the same constraints, the same number of times, as this candidate: [0(1)000] Moreover, for input #4, /5/, this candidate: [000(1)0] violates the same constraints, the same number of times, as this candidate: [0(1)000] Moreover, for input #4, /5/, this candidate: [000(1)0] violates the same constraints, the same number of times, as this candidate: [00(1)00] Results of Factorial Typology Search 5-22-2009, 11:40 a.m. OTSoft version 2.1, release date 4/17/03 Source file: Unary.txt I. Constraints 1. Align-L (Al-L) 2. Align-R (Al-R) 3. *Align-L (*Al-L) 4. *Align-R (*Al-R) 5. *Lapse (*Lps) 6. Parse (Prs) 7. Prs-2 (Parse-2) 8. FtBin (FtBin) 9. Unary-L (Uni-L) 10. Unary-R (Uni-R) 11. Stress-L (Str-L) 12. Stress-R (Str-R) 13. *Clash (*Clash) All rankings were considered. Summary results appear at end of file. Immediately below are reports on individual patterns generated. II. Summary Information With 13 constraints, the number of logically possible grammars is 6227020800. There were 67 different output patterns. Forms marked as winners in the input file are marked with >. Output #1 Output #2 Output #3 Output #4 /2/: >(01) >(01) >(01) >(01) /3/: >(01)0 >(01)0 >(01)0 >(01)0 /4/: >(01)(02) >(01)(02) (01)00 0(01)0 /5/: >(01)(02)0 (01)0(02) >(01)(02)0 >(01)(02)0 Output #5 Output #6 Output #7 Output #8 /2/: >(01) >(01) >(01) >(01) /3/: >(01)0 >(01)0 0(01) 0(01) /4/: 0(01)0 0(01)0 >(01)(02) >(01)(02) /5/: 0(01)00 00(01)0 (01)0(02) 0(01)(02) Output #9 Output #10 Output #11 Output #12 /2/: >(01) >(01) >(01) >(01) /3/: 0(01) 0(01) 0(01) 0(01) /4/: 0(01)0 0(01)0 0(01)0 00(01) /5/: 0(01)(02) 0(01)00 00(01)0 0(01)(02) Output #13 Output #14 Output #15 Output #16 /2/: >(01) >(01) >(01) >(01) /3/: 0(01) (01)(2) (01)(2) (1)(02) /4/: (1)0(02) >(01)(02) >(01)(02) >(01)(02) /5/: 0(01)(02) (01)0(02) (01)(02)(2) (01)0(02) Output #17 Output #18 Output #19 Output #20 /2/: >(01) >(01) (1)(2) (1)(2) /3/: (1)(02) (1)(02) (1)(02) (1)(02) /4/: >(01)(02) (1)0(02) (1)(02)(2) (1)0(02) /5/: (1)(02)(02) (1)(02)(02) (1)(02)(02) (1)(02)(02) Output #21 Output #22 Output #23 Output #24 /2/: (1)0 (1)0 (1)0 (1)0 /3/: >(01)0 >(01)0 >(01)0 >(01)0 /4/: (01)00 0(01)0 0(01)0 0(01)0 /5/: >(01)(02)0 >(01)(02)0 0(01)00 00(01)0 Output #25 Output #26 Output #27 Output #28 /2/: (1)0 (1)0 (1)0 (1)0 /3/: >(01)0 >(01)0 >(01)0 0(01) /4/: 0(01)0 (1)(02)0 (1)(02)0 0(01)0 /5/: (1)0(02)0 >(01)(02)0 (1)0(02)0 0(01)(02) Output #29 Output #30 Output #31 Output #32 /2/: (1)0 (1)0 (1)0 (1)0 /3/: 0(01) 0(01) 0(01) (1)(02) /4/: 0(01)0 0(01)0 00(01) (1)(02)0 /5/: 0(01)00 00(01)0 0(01)(02) (1)(02)(02) Output #33 Output #34 Output #35 Output #36 /2/: (1)0 (1)0 (1)0 (1)0 /3/: (1)(02) (1)(02) (1)(2)0 (1)(2)0 /4/: (1)(02)0 (1)0(02) (1)(02)0 (1)(02)0 /5/: (1)0(02)0 (1)(02)(02) (1)(02)(2)0 (1)(2)(02)0 Output #37 Output #38 Output #39 Output #40 /2/: (1)0 (1)0 (1)0 (1)0 /3/: (1)(2)0 (1)00 (1)00 (1)00 /4/: (1)(02)0 0(01)0 0(01)0 (1)(02)0 /5/: (1)0(02)0 0(01)00 00(01)0 (1)0(02)0 Output #41 Output #42 Output #43 Output #44 /2/: (1)0 (1)0 (1)0 (1)0 /3/: 0(1)0 0(1)0 0(1)0 0(1)0 /4/: 0(01)0 0(01)0 0(01)0 (1)(02)0 /5/: 0(01)00 00(01)0 0(1)(02)0 (1)0(02)0 Output #45 Output #46 Output #47 Output #48 /2/: (1)0 (1)0 0(1) 0(1) /3/: 0(1)0 0(1)0 >(01)0 >(01)0 /4/: (1)(02)0 0(1)(2)0 >(01)(02) 0(01)0 /5/: 0(1)(02)0 0(1)(02)0 >(01)(02)0 >(01)(02)0 Output #49 Output #50 Output #51 Output #52 /2/: 0(1) 0(1) 0(1) 0(1) /3/: >(01)0 >(01)0 0(01) 0(01) /4/: 0(01)0 0(01)0 >(01)(02) 0(01)0 /5/: 0(01)00 00(01)0 0(01)(02) 0(01)(02) Output #53 Output #54 Output #55 Output #56 /2/: 0(1) 0(1) 0(1) 0(1) /3/: 0(01) 0(01) 0(01) 0(01) /4/: 0(01)0 0(01)0 00(01) 0(01)(2) /5/: 0(01)00 00(01)0 0(01)(02) 0(01)(02) Output #57 Output #58 Output #59 Output #60 /2/: 0(1) 0(1) 0(1) 0(1) /3/: 0(01) (01)(2) (1)(02) (1)(02) /4/: 0(1)(02) >(01)(02) >(01)(02) (1)0(02) /5/: 0(01)(02) (01)(02)(2) (1)(02)(02) (1)(02)(02) Output #61 Output #62 Output #63 Output #64 /2/: 0(1) 0(1) 0(1) 0(1) /3/: (1)(02) 0(1)(2) 0(1)0 0(1)0 /4/: 0(1)(02) 0(1)(02) 0(01)0 0(01)0 /5/: (1)(02)(02) 0(1)(02)(2) 0(01)00 00(01)0 Output #65 Output #66 Output #67 /2/: 0(1) 0(1) 0(1) /3/: 0(1)0 0(1)0 0(1)0 /4/: 0(01)0 0(1)(02) 0(1)(2)0 /5/: 0(1)(02)0 0(1)(02)0 0(1)(02)0 III. List of Winners The following specifies for each candidate whether there is at least one ranking that derives it: /2/: [(01)]: yes [(1)(2)]: yes [(1)0]: yes [0(1)]: yes /3/: [(01)0]: yes [0(01)]: yes [(01)(2)]: yes [(1)(02)]: yes [(1)(2)0]: yes [(1)00]: yes [0(1)(2)]: yes [0(1)0]: yes [(1)(2)(2)]: no [(1)0(2)]: no [00(1)]: no /4/: [(01)(02)]: yes [(01)00]: yes [0(01)0]: yes [00(01)]: yes [(1)(02)(2)]: yes [(1)(02)0]: yes [(1)0(02)]: yes [0(01)(2)]: yes [0(1)(02)]: yes [0(1)(2)0]: yes [(01)(2)(2)]: no [(01)(2)0]: no [(01)0(2)]: no [(1)(2)(02)]: no [(1)(2)(2)(2)]: no [(1)(2)(2)0]: no [(1)(2)0(2)]: no [(1)(2)00]: no [(1)0(2)(2)]: no [(1)0(2)0]: no [(1)00(2)]: no [(1)000]: no [0(1)(2)(2)]: no [0(1)0(2)]: no [0(1)00]: no [00(1)(2)]: no [00(1)0]: no [000(1)]: no /5/: [(01)(02)0]: yes [(01)0(02)]: yes [0(01)(02)]: yes [0(01)00]: yes [00(01)0]: yes [(01)(02)(2)]: yes [(1)(02)(02)]: yes [(1)(02)(2)0]: yes [(1)(2)(02)0]: yes [(1)0(02)0]: yes [0(1)(02)(2)]: yes [0(1)(02)0]: yes [(01)(2)(02)]: no [(01)(2)(2)(2)]: no [(01)(2)(2)0]: no [(01)(2)0(2)]: no [(01)(2)00]: no [(01)0(2)(2)]: no [(01)0(2)0]: no [(01)00(2)]: no [(01)000]: no [(1)(02)(2)(2)]: no [(1)(02)0(2)]: no [(1)(02)00]: no [(1)(2)(02)(2)]: no [(1)(2)(2)(02)]: no [(1)(2)(2)(2)(2)]: no [(1)(2)(2)(2)0]: no [(1)(2)(2)0(2)]: no [(1)(2)(2)00]: no [(1)(2)0(02)]: no [(1)(2)0(2)(2)]: no [(1)(2)0(2)0]: no [(1)(2)00(2)]: no [(1)(2)000]: no [(1)0(02)(2)]: no [(1)0(2)(02)]: no [(1)0(2)(2)(2)]: no [(1)0(2)(2)0]: no [(1)0(2)0(2)]: no [(1)0(2)00]: no [(1)00(02)]: no [(1)00(2)(2)]: no [(1)00(2)0]: no [(1)000(2)]: no [(1)0000]: no [0(01)(2)(2)]: no [0(01)(2)0]: no [0(01)0(2)]: no [0(1)(2)(02)]: no [0(1)(2)(2)(2)]: no [0(1)(2)(2)0]: no [0(1)(2)0(2)]: no [0(1)(2)00]: no [0(1)0(02)]: no [0(1)0(2)(2)]: no [0(1)0(2)0]: no [0(1)00(2)]: no [0(1)000]: no [00(01)(2)]: no [00(1)(02)]: no [00(1)(2)(2)]: no [00(1)(2)0]: no [00(1)0(2)]: no [00(1)00]: no [000(01)]: no [000(1)(2)]: no [000(1)0]: no [0000(1)]: no IV. Complete Listing of Output Patterns OUTPUT SET #1: /2/ --> >(01) /3/ --> >(01)0 /4/ --> >(01)(02) /5/ --> >(01)(02)0 Stratum #1 Align-L [= Al-L] *Lapse [= *Lps] Prs-2 [= Parse-2] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] *Align-R [= *Al-R] Parse [= Prs] Stress-L [= Str-L] Stress-R [= Str-R] 1.1. Ranking Arguments Direct Pairwise Arguments (none) There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-R, Prs, FtBin, Uni-R, Str-R} > *Al-R because (01) >> (1)0 { Al-R, Prs, FtBin, Uni-R, Str-R} > Str-L because (01) >> (1)0 { Al-L, Prs, FtBin, Uni-L} > *Al-L because (01) >> 0(1) { Al-L, *Al-R, *Lps} > *Al-L because (01)0 >> 0(01) { *Al-R, FtBin, Uni-L, *Clash} > Al-R because (01)0 >> (01)(2) { *Al-R, FtBin, Uni-L, *Clash} > Prs because (01)0 >> (01)(2) { *Al-R, FtBin, Uni-L, *Clash} > Str-R because (01)0 >> (01)(2) { *Al-R, FtBin, Uni-R} > Al-R because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-R} > Prs because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-R} > Str-L because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-R} > Str-R because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-L, Uni-R} > Str-R because (01)0 >> (1)0(2) { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because (01)(02) >> (01)00 { Al-L, Al-R, *Lps, Prs, Str-R} > *Al-L because (01)(02) >> 0(01)0 { Al-L, Al-R, *Lps, Prs, Str-R} > *Al-R because (01)(02) >> 0(01)0 { *Lps, Prs, FtBin, Uni-R} > Str-L because (01)(02) >> (1)0(02) { Al-L, Prs, FtBin, Uni-L, Uni-R} > *Al-L because (01)(02) >> 0(1)(02) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because (01)(02) >> (01)(2)0 { Prs, FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)(02) >> (1)(2)0(2) { Al-L, *Lps, Prs, Parse-2, FtBin, Uni-L} > *Al-L because (01)(02) >> 000(1) { *Al-R, *Lps} > Al-R because (01)(02)0 >> (01)0(02) { *Al-R, *Lps} > Str-R because (01)(02)0 >> (01)0(02) { Al-L, *Lps, Prs, Parse-2} > *Al-L because (01)(02)0 >> 00(01)0 { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)(02)0 >> (1)(2)(02)0 { *Lps, Prs, FtBin, Uni-R} > Str-L because (01)(02)0 >> (1)0(02)0 { *Al-R, *Lps, Prs, Parse-2, FtBin, Uni-L} > Al-R because (01)(02)0 >> (01)00(2) { *Al-R, *Lps, Prs, Parse-2, FtBin, Uni-L} > Str-R because (01)(02)0 >> (01)00(2) { *Al-R, *Lps, FtBin, Uni-L, Uni-R, *Clash} > Str-R because (01)(02)0 >> (1)0(02)(2) { Al-L, *Al-R, *Lps, Prs, FtBin, Uni-L} > Str-R because (01)(02)0 >> 0(01)0(2) { Al-L, *Al-R, FtBin, Uni-L, Uni-R, *Clash} > *Al-L because (01)(02)0 >> 0(1)(2)(2)(2) { Al-L, *Al-R, *Lps, Prs, Parse-2} > Str-R because (01)(02)0 >> 000(01) ------------------------------------------------------------------------------ OUTPUT SET #2: /2/ --> >(01) /3/ --> >(01)0 /4/ --> >(01)(02) /5/ --> >(01)0(02) Stratum #1 Align-L [= Al-L] Prs-2 [= Parse-2] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] Parse [= Prs] Stress-L [= Str-L] Stress-R [= Str-R] Stratum #3 *Align-R [= *Al-R] *Lapse [= *Lps] 2.1. Ranking Arguments Direct Pairwise Arguments Al-L >> *Al-L, because /5/ --> [(01)0(02)], not *[0(01)(02)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-R, Prs, FtBin, Uni-R, Str-R} > Str-L because (01) >> (1)0 { Al-L, *Al-R, *Lps} > Al-R because (01)0 >> 0(01) { Al-L, *Al-R, *Lps} > Str-R because (01)0 >> 0(01) { *Al-R, FtBin, Uni-L, *Clash} > Al-R because (01)0 >> (01)(2) { *Al-R, FtBin, Uni-L, *Clash} > Str-R because (01)0 >> (01)(2) { *Al-R, FtBin, Uni-R} > Al-R because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-R} > Str-L because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-R} > Str-R because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-L, Uni-R} > Str-R because (01)0 >> (1)0(2) { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because (01)(02) >> (01)00 { Al-L, Al-R, *Lps, Prs, Str-R} > *Al-R because (01)(02) >> 0(01)0 { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because (01)(02) >> (01)(2)0 { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)(02) >> (1)(2)(2)(2) { Al-R, Str-R} > *Al-R because (01)0(02) >> (01)(02)0 { Al-R, Str-R} > *Lps because (01)0(02) >> (01)(02)0 { FtBin, Uni-L, *Clash} > *Lps because (01)0(02) >> (01)(02)(2) { FtBin, Uni-L, *Clash} > Prs because (01)0(02) >> (01)(02)(2) { FtBin, Uni-R} > *Lps because (01)0(02) >> (1)(02)(02) { FtBin, Uni-R} > Prs because (01)0(02) >> (1)(02)(02) { FtBin, Uni-R} > Str-L because (01)0(02) >> (1)(02)(02) { Al-R, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because (01)0(02) >> (1)(02)(2)0 { FtBin, Uni-L, Uni-R} > Str-L because (01)0(02) >> (1)(02)0(2) { FtBin, Uni-L, Uni-R, *Clash} > Prs because (01)0(02) >> (1)(2)(2)(02) { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)0(02) >> (1)0(02)(2) { Prs, FtBin, Uni-L, Uni-R} > Str-L because (01)0(02) >> (1)0(2)0(2) { Al-L, Prs, FtBin, Uni-L, Uni-R, *Clash} > *Lps because (01)0(02) >> 0(1)0(2)(2) ------------------------------------------------------------------------------ OUTPUT SET #3: /2/ --> >(01) /3/ --> >(01)0 /4/ --> >(01)00 /5/ --> >(01)(02)0 Stratum #1 Align-L [= Al-L] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] *Clash [= *Clash] Stratum #2 *Align-L [= *Al-L] *Align-R [= *Al-R] Stress-L [= Str-L] Stratum #3 Align-R [= Al-R] *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] Stress-R [= Str-R] 3.1. Ranking Arguments Direct Pairwise Arguments Al-L >> *Al-L, because /4/ --> [(01)00], not *[0(01)0]: Al-L >> Parse-2, because /4/ --> [(01)00], not *[0(01)0]: *Al-R >> Al-R, because /5/ --> [(01)(02)0], not *[(01)0(02)]: *Al-R >> *Lps, because /4/ --> [(01)00], not *[(01)(02)]: *Al-R >> Prs, because /4/ --> [(01)00], not *[(01)(02)]: *Al-R >> Parse-2, because /4/ --> [(01)00], not *[(01)(02)]: *Al-R >> Str-R, because /5/ --> [(01)(02)0], not *[(01)0(02)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { FtBin, Uni-R} > *Al-R because (01) >> (1)0 { Al-R, Prs, FtBin, Uni-R, Str-R} > Str-L because (01) >> (1)0 { *Al-R, FtBin, Uni-R} > Str-L because (01)0 >> (1)(02) { FtBin, Uni-R} > *Lps because (01)00 >> (1)(02)0 { FtBin, Uni-R} > Prs because (01)00 >> (1)(02)0 { FtBin, Uni-R} > Parse-2 because (01)00 >> (1)(02)0 { FtBin, Uni-R} > Str-L because (01)00 >> (1)(02)0 { FtBin, Uni-L, Uni-R, *Clash} > *Lps because (01)00 >> (01)(2)0 { FtBin, Uni-L, Uni-R, *Clash} > Parse-2 because (01)00 >> (1)(2)(2)0 { FtBin, Uni-L, Uni-R} > Str-L because (01)00 >> (1)0(2)0 { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)(02)0 >> (1)(2)(02)0 { *Lps, Prs, FtBin, Uni-R} > Str-L because (01)(02)0 >> (1)0(02)0 { *Al-R, FtBin, Uni-L, Uni-R} > Str-L because (01)(02)0 >> (1)0(2)(02) { *Lps, Prs, Parse-2, FtBin, Uni-L, Uni-R} > Str-L because (01)(02)0 >> (1)00(2)0 ------------------------------------------------------------------------------ OUTPUT SET #4: /2/ --> >(01) /3/ --> >(01)0 /4/ --> >0(01)0 /5/ --> >(01)(02)0 Stratum #1 Prs-2 [= Parse-2] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] *Clash [= *Clash] Stratum #2 *Align-R [= *Al-R] Stress-L [= Str-L] Stratum #3 Align-L [= Al-L] Align-R [= Al-R] *Align-L [= *Al-L] *Lapse [= *Lps] Parse [= Prs] Stress-R [= Str-R] 4.1. Ranking Arguments Direct Pairwise Arguments (none) There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-R, Prs, FtBin, Uni-R, Str-R} > *Al-R because (01) >> (1)0 { Al-R, Prs, FtBin, Uni-R, Str-R} > Str-L because (01) >> (1)0 { Al-L, Prs, FtBin, Uni-L} > *Al-L because (01) >> 0(1) { Al-L, *Al-R, *Lps} > Al-R because (01)0 >> 0(01) { Al-L, *Al-R, *Lps} > *Al-L because (01)0 >> 0(01) { *Al-R, FtBin, Uni-L, *Clash} > Al-R because (01)0 >> (01)(2) { *Al-R, FtBin, Uni-L, *Clash} > Prs because (01)0 >> (01)(2) { *Al-R, FtBin, Uni-L, *Clash} > Str-R because (01)0 >> (01)(2) { *Al-R, FtBin, Uni-R} > Al-R because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-R} > Prs because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-R} > Str-L because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-R} > Str-R because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-L, Uni-R} > Str-R because (01)0 >> (1)0(2) { *Al-L, *Al-R} > Al-L because 0(01)0 >> (01)(02) { *Al-L, *Al-R} > Al-R because 0(01)0 >> (01)(02) { *Al-L, *Al-R} > *Lps because 0(01)0 >> (01)(02) { *Al-L, *Al-R} > Prs because 0(01)0 >> (01)(02) { *Al-L, *Al-R} > Str-R because 0(01)0 >> (01)(02) { *Al-L, Parse-2} > Al-L because 0(01)0 >> (01)00 { *Al-R, *Lps, Parse-2} > Al-R because 0(01)0 >> 00(01) { *Al-R, *Lps, Parse-2} > Str-R because 0(01)0 >> 00(01) { *Al-L, FtBin, Uni-R} > Al-L because 0(01)0 >> (1)(02)0 { *Al-L, FtBin, Uni-R} > *Lps because 0(01)0 >> (1)(02)0 { *Al-L, FtBin, Uni-R} > Prs because 0(01)0 >> (1)(02)0 { *Al-L, FtBin, Uni-R} > Str-L because 0(01)0 >> (1)(02)0 { FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)0 >> 0(1)(2)0 { *Al-R, FtBin, Uni-L, Uni-R} > *Lps because 0(01)0 >> 0(1)0(2) { *Al-R, *Lps} > Al-R because (01)(02)0 >> (01)0(02) { *Al-R, *Lps} > Str-R because (01)(02)0 >> (01)0(02) { Al-L, *Lps, Prs, Parse-2} > *Al-L because (01)(02)0 >> 0(01)00 { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)(02)0 >> (1)(2)(02)0 { *Lps, Prs, FtBin, Uni-R} > Str-L because (01)(02)0 >> (1)0(02)0 { *Al-R, *Lps, FtBin, Uni-L, Uni-R, *Clash} > Str-R because (01)(02)0 >> (1)0(02)(2) { *Lps, Prs, Parse-2, FtBin, Uni-L, Uni-R} > Str-L because (01)(02)0 >> (1)00(2)0 { Al-L, *Al-R, *Lps, Prs, FtBin, Uni-L} > Str-R because (01)(02)0 >> 0(01)0(2) { Al-L, *Al-R, FtBin, Uni-L, Uni-R, *Clash} > *Al-L because (01)(02)0 >> 0(1)(2)(2)(2) { Al-L, *Al-R, *Lps, Prs, Parse-2} > Str-R because (01)(02)0 >> 000(01) ------------------------------------------------------------------------------ OUTPUT SET #5: /2/ --> >(01) /3/ --> >(01)0 /4/ --> >0(01)0 /5/ --> >0(01)00 Stratum #1 FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] *Clash [= *Clash] Stratum #2 *Align-R [= *Al-R] Stress-L [= Str-L] Stratum #3 Align-R [= Al-R] *Align-L [= *Al-L] Stress-R [= Str-R] Stratum #4 Align-L [= Al-L] *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] 5.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)00], not *[(01)000]: *Al-L >> *Lps, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-L >> Prs, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-L >> Parse-2, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-R >> Al-L, because /5/ --> [0(01)00], not *[(01)0(02)]: *Al-R >> Al-R, because /5/ --> [0(01)00], not *[000(01)]: *Al-R >> *Al-L, because /3/ --> [(01)0], not *[0(01)]: *Al-R >> *Lps, because /5/ --> [0(01)00], not *[(01)0(02)]: *Al-R >> Prs, because /5/ --> [0(01)00], not *[(01)0(02)]: *Al-R >> Parse-2, because /5/ --> [0(01)00], not *[(01)0(02)]: *Al-R >> Str-R, because /5/ --> [0(01)00], not *[000(01)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01) >> (1)(2) { FtBin, Uni-R} > *Al-R because (01) >> (1)0 { Al-R, Prs, FtBin, Uni-R, Str-R} > Str-L because (01) >> (1)0 { FtBin, Uni-L} > *Al-L because (01) >> 0(1) { *Al-R, FtBin, Uni-R} > Str-L because (01)0 >> (1)(02) { *Lps, Prs, Parse-2, FtBin, Uni-R} > Str-L because (01)0 >> (1)00 { FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)0 >> 0(1)(2)0 { *Al-L, FtBin, Uni-R} > Str-L because 0(01)00 >> (1)0(02)0 { FtBin, Uni-L, Uni-R} > *Lps because 0(01)00 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Prs because 0(01)00 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Parse-2 because 0(01)00 >> 0(1)(02)0 { *Al-L, *Al-R, FtBin, Uni-L, Uni-R, *Clash} > Str-L because 0(01)00 >> (1)(2)00(2) { *Al-L, FtBin, Uni-L, Uni-R} > Str-L because 0(01)00 >> (1)00(2)0 { FtBin, Uni-L, Uni-R, *Clash} > Parse-2 because 0(01)00 >> 0(1)(2)(2)0 ------------------------------------------------------------------------------ OUTPUT SET #6: /2/ --> >(01) /3/ --> >(01)0 /4/ --> >0(01)0 /5/ --> >00(01)0 Stratum #1 FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] *Clash [= *Clash] Stratum #2 *Align-R [= *Al-R] Stress-L [= Str-L] Stratum #3 Align-R [= Al-R] *Align-L [= *Al-L] Stress-R [= Str-R] Stratum #4 Align-L [= Al-L] *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] 6.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [00(01)0], not *[(01)000]: *Al-L >> *Lps, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-L >> Prs, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-L >> Parse-2, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-R >> Al-L, because /5/ --> [00(01)0], not *[(01)0(02)]: *Al-R >> Al-R, because /5/ --> [00(01)0], not *[000(01)]: *Al-R >> *Al-L, because /3/ --> [(01)0], not *[0(01)]: *Al-R >> *Lps, because /5/ --> [00(01)0], not *[(01)0(02)]: *Al-R >> Prs, because /5/ --> [00(01)0], not *[(01)0(02)]: *Al-R >> Parse-2, because /5/ --> [00(01)0], not *[(01)0(02)]: *Al-R >> Str-R, because /5/ --> [00(01)0], not *[000(01)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01) >> (1)(2) { FtBin, Uni-R} > *Al-R because (01) >> (1)0 { Al-R, Prs, FtBin, Uni-R, Str-R} > Str-L because (01) >> (1)0 { FtBin, Uni-L} > *Al-L because (01) >> 0(1) { *Al-R, FtBin, Uni-R} > Str-L because (01)0 >> (1)(02) { *Lps, Prs, Parse-2, FtBin, Uni-R} > Str-L because (01)0 >> (1)00 { FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)0 >> 0(1)(2)0 { *Al-L, FtBin, Uni-R} > Str-L because 00(01)0 >> (1)0(02)0 { FtBin, Uni-L, Uni-R} > *Lps because 00(01)0 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Prs because 00(01)0 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Parse-2 because 00(01)0 >> 0(1)(02)0 { *Al-L, *Al-R, FtBin, Uni-L, Uni-R, *Clash} > Str-L because 00(01)0 >> (1)(2)00(2) { *Al-L, FtBin, Uni-L, Uni-R} > Str-L because 00(01)0 >> (1)00(2)0 { FtBin, Uni-L, Uni-R, *Clash} > Parse-2 because 00(01)0 >> 0(1)(2)(2)0 ------------------------------------------------------------------------------ OUTPUT SET #7: /2/ --> >(01) /3/ --> >0(01) /4/ --> >(01)(02) /5/ --> >(01)0(02) Stratum #1 Align-R [= Al-R] Prs-2 [= Parse-2] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] Stress-R [= Str-R] *Clash [= *Clash] Stratum #2 Align-L [= Al-L] *Align-R [= *Al-R] *Lapse [= *Lps] Parse [= Prs] Stress-L [= Str-L] Stratum #3 *Align-L [= *Al-L] 7.1. Ranking Arguments Direct Pairwise Arguments Al-L >> *Al-L, because /5/ --> [(01)0(02)], not *[0(01)(02)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-R, Str-R} > Al-L because 0(01) >> (01)0 { Al-R, *Al-L, Str-R} > *Al-R because 0(01) >> (01)0 { FtBin, Uni-L, *Clash} > Al-L because 0(01) >> (01)(2) { *Al-L, FtBin, Uni-L, *Clash} > Prs because 0(01) >> (01)(2) { FtBin, Uni-R} > Al-L because 0(01) >> (1)(02) { *Al-L, FtBin, Uni-R} > Prs because 0(01) >> (1)(02) { *Al-L, FtBin, Uni-R} > Str-L because 0(01) >> (1)(02) { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because (01)(02) >> (01)00 { Al-L, Al-R, *Lps, Prs, Str-R} > *Al-R because (01)(02) >> 0(01)0 { *Lps, Prs, FtBin, Uni-R} > Str-L because (01)(02) >> (1)0(02) { Al-R, Str-R} > *Al-R because (01)0(02) >> (01)(02)0 { Al-R, Str-R} > *Lps because (01)0(02) >> (01)(02)0 { FtBin, Uni-L, *Clash} > *Lps because (01)0(02) >> (01)(02)(2) { FtBin, Uni-L, *Clash} > Prs because (01)0(02) >> (01)(02)(2) { FtBin, Uni-R} > *Lps because (01)0(02) >> (1)(02)(02) { FtBin, Uni-R} > Prs because (01)0(02) >> (1)(02)(02) { FtBin, Uni-R} > Str-L because (01)0(02) >> (1)(02)(02) { Al-L, FtBin, Uni-L, Uni-R, *Clash} > *Lps because (01)0(02) >> 0(1)(02)(2) { FtBin, Uni-L, Uni-R, *Clash} > *Lps because (01)0(02) >> (01)(2)0(2) { FtBin, Uni-L, Uni-R} > *Lps because (01)0(02) >> (1)(02)0(2) { FtBin, Uni-L, Uni-R} > Str-L because (01)0(02) >> (1)(02)0(2) { Al-R, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because (01)0(02) >> (1)(2)(2)(2)0 { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)0(02) >> (1)(2)0(02) { FtBin, Uni-L, Uni-R} > *Lps because (01)0(02) >> (1)0(2)(02) { FtBin, Uni-L, Uni-R} > Str-L because (01)0(02) >> (1)0(2)(02) { Prs, FtBin, Uni-L, Uni-R} > *Lps because (01)0(02) >> (1)0(2)0(2) { Prs, FtBin, Uni-L, Uni-R} > Str-L because (01)0(02) >> (1)0(2)0(2) ------------------------------------------------------------------------------ OUTPUT SET #8: /2/ --> >(01) /3/ --> >0(01) /4/ --> >(01)(02) /5/ --> >0(01)(02) Stratum #1 Align-R [= Al-R] Prs-2 [= Parse-2] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] Stress-R [= Str-R] *Clash [= *Clash] Stratum #2 *Align-L [= *Al-L] *Align-R [= *Al-R] *Lapse [= *Lps] Parse [= Prs] Stress-L [= Str-L] Stratum #3 Align-L [= Al-L] 8.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)(02)], not *[(01)0(02)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-R, Prs, FtBin, Uni-R, Str-R} > *Al-R because (01) >> (1)0 { Al-R, Prs, FtBin, Uni-R, Str-R} > Str-L because (01) >> (1)0 { Prs, FtBin, Uni-L} > *Al-L because (01) >> 0(1) { Al-R, *Al-L, Str-R} > *Al-R because 0(01) >> (01)0 { Al-R, *Al-L, Str-R} > *Lps because 0(01) >> (01)0 { *Al-L, FtBin, Uni-L, *Clash} > *Lps because 0(01) >> (01)(2) { *Al-L, FtBin, Uni-L, *Clash} > Prs because 0(01) >> (01)(2) { *Al-L, FtBin, Uni-R} > *Lps because 0(01) >> (1)(02) { *Al-L, FtBin, Uni-R} > Prs because 0(01) >> (1)(02) { *Al-L, FtBin, Uni-R} > Str-L because 0(01) >> (1)(02) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Lps because 0(01) >> 0(1)0 { Al-R, *Lps, Prs, Str-R} > *Al-L because (01)(02) >> 0(01)0 { Al-L, Al-R, *Lps, Prs, Str-R} > *Al-R because (01)(02) >> 0(01)0 { *Lps, Prs, Parse-2} > *Al-L because (01)(02) >> 00(01) { *Lps, Prs, FtBin, Uni-R} > Str-L because (01)(02) >> (1)0(02) { Prs, FtBin, Uni-L, Uni-R} > *Al-L because (01)(02) >> 0(1)(02) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because (01)(02) >> (01)(2)0 { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)(02) >> (1)(2)(2)(2) { Prs, FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)(02) >> (1)(2)0(2) { *Lps, Prs, Parse-2, FtBin, Uni-L} > *Al-L because (01)(02) >> 000(1) { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because 0(01)(02) >> 00(01)0 { *Al-L, FtBin, Uni-L, Uni-R} > *Lps because 0(01)(02) >> (1)(02)0(2) { *Al-L, FtBin, Uni-L, Uni-R, *Clash} > Str-L because 0(01)(02) >> (1)(2)0(02) { *Al-L, Prs, FtBin, Uni-L, Uni-R} > Str-L because 0(01)(02) >> (1)0(2)0(2) { FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)(02) >> 0(1)(2)(2)(2) { Prs, FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)(02) >> 0(1)(2)0(2) ------------------------------------------------------------------------------ OUTPUT SET #9: /2/ --> >(01) /3/ --> >0(01) /4/ --> >0(01)0 /5/ --> >0(01)(02) Stratum #1 Prs-2 [= Parse-2] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] *Clash [= *Clash] Stratum #2 *Align-L [= *Al-L] Stress-L [= Str-L] Stratum #3 Align-L [= Al-L] Align-R [= Al-R] *Align-R [= *Al-R] *Lapse [= *Lps] Parse [= Prs] Stress-R [= Str-R] 9.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)(02)], not *[(01)0(02)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01) >> (1)(2) { Al-R, Prs, FtBin, Uni-R, Str-R} > *Al-R because (01) >> (1)0 { Al-R, Prs, FtBin, Uni-R, Str-R} > Str-L because (01) >> (1)0 { Prs, FtBin, Uni-L} > *Al-L because (01) >> 0(1) { Al-R, *Al-L, Str-R} > *Al-R because 0(01) >> (01)0 { Al-R, *Al-L, Str-R} > *Lps because 0(01) >> (01)0 { *Al-L, FtBin, Uni-L, *Clash} > *Lps because 0(01) >> (01)(2) { *Al-L, FtBin, Uni-L, *Clash} > Prs because 0(01) >> (01)(2) { *Al-L, FtBin, Uni-R} > *Lps because 0(01) >> (1)(02) { *Al-L, FtBin, Uni-R} > Prs because 0(01) >> (1)(02) { *Al-L, FtBin, Uni-R} > Str-L because 0(01) >> (1)(02) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Lps because 0(01) >> 0(1)0 { *Al-L, *Al-R} > Al-R because 0(01)0 >> (01)(02) { *Al-L, *Al-R} > *Lps because 0(01)0 >> (01)(02) { *Al-L, *Al-R} > Prs because 0(01)0 >> (01)(02) { *Al-L, *Al-R} > Str-R because 0(01)0 >> (01)(02) { *Al-R, *Lps, Parse-2} > Al-R because 0(01)0 >> 00(01) { *Al-R, *Lps, Parse-2} > Str-R because 0(01)0 >> 00(01) { *Al-L, *Al-R, FtBin, Uni-R} > Str-R because 0(01)0 >> (1)0(02) { *Al-R, FtBin, Uni-L, *Clash} > Al-R because 0(01)0 >> 0(01)(2) { *Al-R, FtBin, Uni-L, *Clash} > Prs because 0(01)0 >> 0(01)(2) { *Al-R, FtBin, Uni-L, *Clash} > Str-R because 0(01)0 >> 0(01)(2) { *Al-R, FtBin, Uni-L, Uni-R} > Al-R because 0(01)0 >> 0(1)(02) { *Al-R, FtBin, Uni-L, Uni-R} > *Lps because 0(01)0 >> 0(1)(02) { *Al-R, FtBin, Uni-L, Uni-R} > Prs because 0(01)0 >> 0(1)(02) { *Al-L, *Al-R, FtBin, Uni-L} > Str-R because 0(01)0 >> (01)0(2) { *Al-R, FtBin, Uni-L, Uni-R} > Str-R because 0(01)0 >> 0(1)0(2) { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because 0(01)(02) >> 0(01)00 { *Al-L, FtBin, Uni-L, Uni-R} > *Lps because 0(01)(02) >> (1)(02)0(2) { *Al-L, FtBin, Uni-L, Uni-R, *Clash} > Str-L because 0(01)(02) >> (1)(2)0(02) { *Al-L, Prs, FtBin, Uni-L, Uni-R} > Str-L because 0(01)(02) >> (1)0(2)0(2) { FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)(02) >> 0(1)(2)(2)(2) { Prs, FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)(02) >> 0(1)(2)0(2) { Al-R, Prs, Parse-2, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because 0(01)(02) >> 00(1)(2)0 ------------------------------------------------------------------------------ OUTPUT SET #10: /2/ --> >(01) /3/ --> >0(01) /4/ --> >0(01)0 /5/ --> >0(01)00 Stratum #1 FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] *Clash [= *Clash] Stratum #2 *Align-L [= *Al-L] Stress-L [= Str-L] Stratum #3 Align-L [= Al-L] *Align-R [= *Al-R] Stratum #4 Align-R [= Al-R] *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] Stress-R [= Str-R] 10.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)00], not *[(01)000]: *Al-L >> *Al-R, because /3/ --> [0(01)], not *[(01)0]: *Al-L >> *Lps, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-L >> Prs, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-L >> Parse-2, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-R >> Al-R, because /5/ --> [0(01)00], not *[000(01)]: *Al-R >> *Lps, because /5/ --> [0(01)00], not *[0(01)(02)]: *Al-R >> Prs, because /5/ --> [0(01)00], not *[0(01)(02)]: *Al-R >> Parse-2, because /5/ --> [0(01)00], not *[0(01)(02)]: *Al-R >> Str-R, because /5/ --> [0(01)00], not *[000(01)]: Arguments Derived from Transitivity of Domination *Al-L >> Al-R *Al-L >> Str-R Irreducible Set Arguments { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01) >> (1)(2) { FtBin, Uni-R} > *Al-R because (01) >> (1)0 { Al-R, Prs, FtBin, Uni-R, Str-R} > Str-L because (01) >> (1)0 { FtBin, Uni-L} > *Al-L because (01) >> 0(1) { *Al-L, *Lps, Prs, Parse-2, FtBin, Uni-R} > Str-L because 0(01)0 >> (1)000 { FtBin, Uni-L, Uni-R} > *Lps because 0(01)00 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Prs because 0(01)00 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Parse-2 because 0(01)00 >> 0(1)(02)0 { *Al-L, FtBin, Uni-R} > Str-L because 0(01)00 >> (1)(02)00 { *Al-L, *Al-R, FtBin, Uni-L, Uni-R, *Clash} > Str-L because 0(01)00 >> (1)0(02)(2) { *Al-L, FtBin, Uni-L, Uni-R} > Str-L because 0(01)00 >> (1)0(2)00 { *Al-L, FtBin, Uni-L, Uni-R} > Str-L because 0(01)00 >> (1)00(2)0 { FtBin, Uni-L, Uni-R, *Clash} > Parse-2 because 0(01)00 >> 0(1)(2)(2)0 { FtBin, Uni-L, Uni-R} > *Lps because 0(01)00 >> 0(1)0(2)0 ------------------------------------------------------------------------------ OUTPUT SET #11: /2/ --> >(01) /3/ --> >0(01) /4/ --> >0(01)0 /5/ --> >00(01)0 Stratum #1 FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] *Clash [= *Clash] Stratum #2 *Align-L [= *Al-L] Stress-L [= Str-L] Stratum #3 Align-L [= Al-L] *Align-R [= *Al-R] Stratum #4 Align-R [= Al-R] *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] Stress-R [= Str-R] 11.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [00(01)0], not *[(01)000]: *Al-L >> *Al-R, because /3/ --> [0(01)], not *[(01)0]: *Al-L >> *Lps, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-L >> Prs, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-L >> Parse-2, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-R >> Al-R, because /5/ --> [00(01)0], not *[000(01)]: *Al-R >> *Lps, because /5/ --> [00(01)0], not *[0(01)(02)]: *Al-R >> Prs, because /5/ --> [00(01)0], not *[0(01)(02)]: *Al-R >> Parse-2, because /5/ --> [00(01)0], not *[0(01)(02)]: *Al-R >> Str-R, because /5/ --> [00(01)0], not *[000(01)]: Arguments Derived from Transitivity of Domination *Al-L >> Al-R *Al-L >> Str-R Irreducible Set Arguments { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01) >> (1)(2) { FtBin, Uni-R} > *Al-R because (01) >> (1)0 { Al-R, Prs, FtBin, Uni-R, Str-R} > Str-L because (01) >> (1)0 { FtBin, Uni-L} > *Al-L because (01) >> 0(1) { *Al-L, *Lps, Prs, Parse-2, FtBin, Uni-R} > Str-L because 0(01)0 >> (1)000 { FtBin, Uni-L, Uni-R} > *Lps because 00(01)0 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Prs because 00(01)0 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Parse-2 because 00(01)0 >> 0(1)(02)0 { *Al-L, FtBin, Uni-R} > Str-L because 00(01)0 >> (1)(02)00 { *Al-L, *Al-R, FtBin, Uni-L, Uni-R, *Clash} > Str-L because 00(01)0 >> (1)0(02)(2) { *Al-L, FtBin, Uni-L, Uni-R} > Str-L because 00(01)0 >> (1)0(2)00 { *Al-L, FtBin, Uni-L, Uni-R} > Str-L because 00(01)0 >> (1)00(2)0 { FtBin, Uni-L, Uni-R, *Clash} > Parse-2 because 00(01)0 >> 0(1)(2)(2)0 { FtBin, Uni-L, Uni-R} > *Lps because 00(01)0 >> 0(1)0(2)0 ------------------------------------------------------------------------------ OUTPUT SET #12: /2/ --> >(01) /3/ --> >0(01) /4/ --> >00(01) /5/ --> >0(01)(02) Stratum #1 Align-R [= Al-R] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] Stress-R [= Str-R] *Clash [= *Clash] Stratum #2 *Align-L [= *Al-L] *Align-R [= *Al-R] Stress-L [= Str-L] Stratum #3 Align-L [= Al-L] *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] 12.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)(02)], not *[(01)0(02)]: *Al-L >> *Lps, because /4/ --> [00(01)], not *[(01)(02)]: *Al-L >> Prs, because /4/ --> [00(01)], not *[(01)(02)]: *Al-L >> Parse-2, because /4/ --> [00(01)], not *[(01)(02)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01) >> (1)(2) { Al-R, Prs, FtBin, Uni-R, Str-R} > Str-L because (01) >> (1)0 { FtBin, Uni-L} > *Al-L because (01) >> 0(1) { Al-R, *Al-L, Str-R} > *Al-R because 0(01) >> (01)0 { Al-R, Str-R} > *Al-R because 00(01) >> 0(01)0 { Al-R, Str-R} > *Lps because 00(01) >> 0(01)0 { Al-R, Str-R} > Parse-2 because 00(01) >> 0(01)0 { *Al-L, FtBin, Uni-R} > Str-L because 00(01) >> (1)0(02) { FtBin, Uni-L, *Clash} > *Lps because 00(01) >> 0(01)(2) { FtBin, Uni-L, *Clash} > Prs because 00(01) >> 0(01)(2) { FtBin, Uni-L, *Clash} > Parse-2 because 00(01) >> 0(01)(2) { FtBin, Uni-L, Uni-R} > Prs because 00(01) >> 0(1)(02) { FtBin, Uni-L, Uni-R} > Parse-2 because 00(01) >> 0(1)(02) { Al-R, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because 00(01) >> 0(1)(2)0 { Al-R, *Al-L, FtBin, Uni-L, Uni-R, Str-R} > Str-L because 00(01) >> (1)0(2)0 { FtBin, Uni-L, Uni-R} > *Lps because 00(01) >> 0(1)0(2) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Lps because 00(01) >> 00(1)0 { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because 0(01)(02) >> 0(01)00 { Al-R, *Al-L, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because 0(01)(02) >> (01)0(2)0 { *Al-L, FtBin, Uni-L, Uni-R, *Clash} > Str-L because 0(01)(02) >> (1)(2)0(02) { *Al-L, Prs, FtBin, Uni-L, Uni-R} > Str-L because 0(01)(02) >> (1)0(2)0(2) { Prs, FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)(02) >> 0(1)(2)0(2) ------------------------------------------------------------------------------ OUTPUT SET #13: /2/ --> >(01) /3/ --> >0(01) /4/ --> >(1)0(02) /5/ --> >0(01)(02) Stratum #1 Align-R [= Al-R] Prs-2 [= Parse-2] Unary-L [= Uni-L] Stress-R [= Str-R] *Clash [= *Clash] Stratum #2 *Align-L [= *Al-L] *Align-R [= *Al-R] Stratum #3 Align-L [= Al-L] Stress-L [= Str-L] Stratum #4 *Lapse [= *Lps] Parse [= Prs] FtBin [= FtBin] Unary-R [= Uni-R] 13.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)(02)], not *[(01)0(02)]: *Al-L >> *Lps, because /5/ --> [0(01)(02)], not *[(1)(02)(02)]: *Al-L >> Prs, because /5/ --> [0(01)(02)], not *[(1)(02)(02)]: *Al-L >> Str-L, because /5/ --> [0(01)(02)], not *[(1)(02)(02)]: Parse-2 >> *Al-L, because /4/ --> [(1)0(02)], not *[00(01)]: Uni-L >> *Al-L, because /4/ --> [(1)0(02)], not *[0(1)(02)]: Uni-L >> *Lps, because /5/ --> [0(01)(02)], not *[(1)0(2)0(2)]: Uni-L >> Str-L, because /5/ --> [0(01)(02)], not *[(1)0(2)(02)]: Str-L >> *Lps, because /4/ --> [(1)0(02)], not *[(01)(02)]: Str-L >> Prs, because /4/ --> [(1)0(02)], not *[(01)(02)]: Str-L >> FtBin, because /4/ --> [(1)0(02)], not *[(01)(02)]: Str-L >> Uni-R, because /4/ --> [(1)0(02)], not *[(01)(02)]: Arguments Derived from Transitivity of Domination *Al-L >> FtBin *Al-L >> Uni-R Parse-2 >> Al-L Parse-2 >> *Lps Parse-2 >> Prs Parse-2 >> FtBin Parse-2 >> Uni-R Parse-2 >> Str-L Uni-L >> Al-L Uni-L >> Prs Uni-L >> FtBin Uni-L >> Uni-R Irreducible Set Arguments { Al-R, Str-R} > Str-L because (01) >> (1)0 { Al-R, *Al-L, Str-R} > *Al-R because 0(01) >> (01)0 { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because 0(01) >> 0(1)0 { Al-R, Prs, Parse-2, Str-L, Str-R} > *Al-R because (1)0(02) >> (01)00 { Al-R, Str-R} > *Al-L because (1)0(02) >> 0(01)0 { Al-L, Al-R, Prs, Str-L, Str-R} > *Al-R because (1)0(02) >> 0(01)0 { Al-R, Str-R} > *Al-R because (1)0(02) >> (1)(02)0 { Al-R, Str-R} > *Lps because (1)0(02) >> (1)(02)0 { Al-R, Uni-L, Str-L, Str-R, *Clash} > *Al-R because (1)0(02) >> (01)(2)0 { Al-R, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because (1)0(02) >> (1)(2)(2)0 { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because 0(01)(02) >> 00(01)0 { Al-R, *Al-L, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because 0(01)(02) >> (01)0(2)0 { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because 0(01)(02) >> 0(01)(2)0 ------------------------------------------------------------------------------ OUTPUT SET #14: /2/ --> >(01) /3/ --> >(01)(2) /4/ --> >(01)(02) /5/ --> >(01)0(02) Stratum #1 Align-L [= Al-L] Align-R [= Al-R] Prs-2 [= Parse-2] Unary-R [= Uni-R] Stress-R [= Str-R] Stratum #2 *Align-L [= *Al-L] *Align-R [= *Al-R] FtBin [= FtBin] Unary-L [= Uni-L] Stress-L [= Str-L] *Clash [= *Clash] Stratum #3 *Lapse [= *Lps] Parse [= Prs] 14.1. Ranking Arguments Direct Pairwise Arguments Al-L >> *Al-L, because /5/ --> [(01)0(02)], not *[0(01)(02)]: Uni-R >> Uni-L, because /3/ --> [(01)(2)], not *[(1)(02)]: Uni-R >> Str-L, because /3/ --> [(01)(2)], not *[(1)(02)]: Uni-R >> *Clash, because /3/ --> [(01)(2)], not *[(1)(02)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-R, Prs, Str-R} > *Al-R because (01)(2) >> (01)0 { Al-R, Prs, Str-R} > FtBin because (01)(2) >> (01)0 { Al-R, Prs, Str-R} > Uni-L because (01)(2) >> (01)0 { Al-R, Prs, Str-R} > *Clash because (01)(2) >> (01)0 { Al-L, *Lps, Prs} > FtBin because (01)(2) >> 0(01) { Al-L, *Lps, Prs} > Uni-L because (01)(2) >> 0(01) { Al-L, *Lps, Prs} > *Clash because (01)(2) >> 0(01) { Al-L, Al-R, Prs, Uni-R, Str-R} > *Al-R because (01)(2) >> 0(1)0 { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because (01)(02) >> (01)00 { Al-L, Al-R, *Lps, Prs, Str-R} > *Al-R because (01)(02) >> 0(01)0 { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because (01)(02) >> (1)0(2)0 { Al-R, Str-R} > *Al-R because (01)0(02) >> (01)(02)0 { Al-R, Str-R} > *Lps because (01)0(02) >> (01)(02)0 { FtBin, Uni-L, *Clash} > *Lps because (01)0(02) >> (01)(02)(2) { FtBin, Uni-L, *Clash} > Prs because (01)0(02) >> (01)(02)(2) { FtBin, Uni-R} > *Lps because (01)0(02) >> (1)(02)(02) { FtBin, Uni-R} > Prs because (01)0(02) >> (1)(02)(02) { FtBin, Uni-L, Uni-R} > *Lps because (01)0(02) >> (1)(02)0(2) { Al-L, FtBin, Uni-L, Uni-R, *Clash} > *Lps because (01)0(02) >> 0(1)(2)(2)(2) ------------------------------------------------------------------------------ OUTPUT SET #15: /2/ --> >(01) /3/ --> >(01)(2) /4/ --> >(01)(02) /5/ --> >(01)(02)(2) Stratum #1 Align-L [= Al-L] Align-R [= Al-R] *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] Unary-R [= Uni-R] Stress-R [= Str-R] Stratum #2 *Align-L [= *Al-L] *Align-R [= *Al-R] FtBin [= FtBin] Unary-L [= Uni-L] Stress-L [= Str-L] *Clash [= *Clash] 15.1. Ranking Arguments Direct Pairwise Arguments Uni-R >> Uni-L, because /5/ --> [(01)(02)(2)], not *[(1)(02)(02)]: Uni-R >> Str-L, because /5/ --> [(01)(02)(2)], not *[(1)(02)(02)]: Uni-R >> *Clash, because /5/ --> [(01)(02)(2)], not *[(1)(02)(02)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-L, Prs, FtBin, Uni-L} > *Al-L because (01) >> 0(1) { Al-R, Prs, Str-R} > FtBin because (01)(2) >> (01)0 { Al-R, Prs, Str-R} > Uni-L because (01)(2) >> (01)0 { Al-R, Prs, Str-R} > *Clash because (01)(2) >> (01)0 { Al-L, *Lps, Prs} > *Al-L because (01)(2) >> 0(01) { Al-L, *Lps, Prs} > Uni-L because (01)(2) >> 0(01) { Al-L, Al-R, Prs, Uni-R, Str-R} > *Al-L because (01)(2) >> 0(1)0 { Al-L, Al-R, *Lps, Prs, Str-R} > *Al-R because (01)(02) >> 0(01)0 { Al-R, *Lps, Prs, Parse-2, FtBin, Uni-R, Str-R} > *Al-R because (01)(02) >> (1)000 { Al-L, *Lps, Prs, Parse-2, FtBin, Uni-L} > *Al-L because (01)(02) >> 000(1) { Al-R, Prs, Str-R} > *Al-R because (01)(02)(2) >> (01)(02)0 { *Lps, Prs} > FtBin because (01)(02)(2) >> (01)0(02) { *Lps, Prs} > Uni-L because (01)(02)(2) >> (01)0(02) { *Lps, Prs} > *Clash because (01)(02)(2) >> (01)0(02) { Al-L, Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because (01)(02)(2) >> 00(01)0 { Al-R, Prs, FtBin, Uni-R, Str-R} > *Al-R because (01)(02)(2) >> (1)(2)(02)0 { Al-R, *Lps, Prs, Uni-R, Str-R} > *Al-R because (01)(02)(2) >> (1)0(02)0 { Al-R, Prs, Uni-R, Str-R} > *Al-R because (01)(02)(2) >> (01)0(2)0 { *Lps, Prs, Parse-2} > *Clash because (01)(02)(2) >> (01)00(2) { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because (01)(02)(2) >> (01)000 { Al-L, Prs, FtBin, Uni-L, Uni-R} > *Al-L because (01)(02)(2) >> 0(1)(2)0(2) { Al-L, *Lps, Prs, Parse-2, Uni-R} > *Al-L because (01)(02)(2) >> 00(1)(02) ------------------------------------------------------------------------------ OUTPUT SET #16: /2/ --> >(01) /3/ --> >(1)(02) /4/ --> >(01)(02) /5/ --> >(01)0(02) Stratum #1 Align-L [= Al-L] Align-R [= Al-R] Prs-2 [= Parse-2] Unary-L [= Uni-L] Stress-R [= Str-R] *Clash [= *Clash] Stratum #2 *Align-L [= *Al-L] *Align-R [= *Al-R] FtBin [= FtBin] Unary-R [= Uni-R] Stratum #3 *Lapse [= *Lps] Parse [= Prs] Stress-L [= Str-L] 16.1. Ranking Arguments Direct Pairwise Arguments Al-L >> *Al-L, because /5/ --> [(01)0(02)], not *[0(01)(02)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-R, Prs, Str-L, Str-R} > *Al-R because (1)(02) >> (01)0 { Al-R, Prs, Str-L, Str-R} > FtBin because (1)(02) >> (01)0 { Al-R, Prs, Str-L, Str-R} > Uni-R because (1)(02) >> (01)0 { Al-L, *Lps, Prs, Str-L} > FtBin because (1)(02) >> 0(01) { Al-L, *Lps, Prs, Str-L} > Uni-R because (1)(02) >> 0(01) { Uni-L, Str-L, *Clash} > Uni-R because (1)(02) >> (01)(2) { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because (1)(02) >> (1)00 { Al-L, Al-R, *Lps, Prs, Str-R} > *Al-R because (01)(02) >> 0(01)0 { *Lps, Prs, FtBin, Uni-R} > Str-L because (01)(02) >> (1)0(02) { Al-R, Str-R} > *Al-R because (01)0(02) >> (01)(02)0 { Al-R, Str-R} > *Lps because (01)0(02) >> (01)(02)0 { FtBin, Uni-L, *Clash} > *Lps because (01)0(02) >> (01)(02)(2) { FtBin, Uni-L, *Clash} > Prs because (01)0(02) >> (01)(02)(2) { FtBin, Uni-R} > *Lps because (01)0(02) >> (1)(02)(02) { FtBin, Uni-R} > Prs because (01)0(02) >> (1)(02)(02) { FtBin, Uni-R} > Str-L because (01)0(02) >> (1)(02)(02) { Al-R, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because (01)0(02) >> (1)(2)(02)0 { Al-R, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because (01)0(02) >> (01)(2)(2)0 { FtBin, Uni-L, Uni-R} > *Lps because (01)0(02) >> (1)(02)0(2) { FtBin, Uni-L, Uni-R} > Str-L because (01)0(02) >> (1)(02)0(2) { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)0(02) >> (1)(2)0(02) { FtBin, Uni-L, Uni-R} > Str-L because (01)0(02) >> (1)0(2)(02) { Prs, FtBin, Uni-L, Uni-R} > Str-L because (01)0(02) >> (1)0(2)0(2) ------------------------------------------------------------------------------ OUTPUT SET #17: /2/ --> >(01) /3/ --> >(1)(02) /4/ --> >(01)(02) /5/ --> >(1)(02)(02) Stratum #1 Align-L [= Al-L] Align-R [= Al-R] *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] Unary-L [= Uni-L] Stress-R [= Str-R] *Clash [= *Clash] Stratum #2 *Align-L [= *Al-L] *Align-R [= *Al-R] FtBin [= FtBin] Unary-R [= Uni-R] Stress-L [= Str-L] 17.1. Ranking Arguments Direct Pairwise Arguments (none) There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-R, Prs, FtBin, Uni-R, Str-R} > *Al-R because (01) >> (1)0 { Al-R, Prs, FtBin, Uni-R, Str-R} > Str-L because (01) >> (1)0 { Al-L, Prs, FtBin, Uni-L} > *Al-L because (01) >> 0(1) { Al-R, Prs, Str-L, Str-R} > *Al-R because (1)(02) >> (01)0 { Al-R, Prs, Str-L, Str-R} > FtBin because (1)(02) >> (01)0 { Al-R, Prs, Str-L, Str-R} > Uni-R because (1)(02) >> (01)0 { Al-L, *Lps, Prs, Str-L} > *Al-L because (1)(02) >> 0(01) { Al-L, *Lps, Prs, Str-L} > Uni-R because (1)(02) >> 0(01) { Uni-L, Str-L, *Clash} > Uni-R because (1)(02) >> (01)(2) { Al-L, Al-R, Prs, Uni-L, Str-L, Str-R} > *Al-L because (1)(02) >> 0(1)0 { Al-L, Al-R, *Lps, Prs, Str-R} > *Al-L because (01)(02) >> 0(01)0 { Al-L, Al-R, *Lps, Prs, Str-R} > *Al-R because (01)(02) >> 0(01)0 { Al-L, *Lps, Prs, Parse-2} > *Al-L because (01)(02) >> 00(01) { *Lps, Prs, FtBin, Uni-R} > Str-L because (01)(02) >> (1)0(02) { Al-L, Prs, FtBin, Uni-L, Uni-R} > *Al-L because (01)(02) >> 0(1)(02) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because (01)(02) >> (01)(2)0 { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)(02) >> (1)(2)(2)(2) { Prs, FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)(02) >> (1)(2)0(2) { Al-L, *Lps, Prs, Parse-2, FtBin, Uni-L} > *Al-L because (01)(02) >> 000(1) { *Lps, Prs, Str-L} > FtBin because (1)(02)(02) >> (01)0(02) { *Lps, Prs, Str-L} > Uni-R because (1)(02)(02) >> (01)0(02) { Al-R, *Lps, Prs, Str-R} > *Al-R because (1)(02)(02) >> (1)0(02)0 { Al-R, *Lps, Prs, Parse-2, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because (1)(02)(02) >> (1)0(2)00 { Al-L, *Lps, Prs, Uni-L, Str-L} > *Al-L because (1)(02)(02) >> 0(01)0(2) { Al-L, Prs, FtBin, Uni-L, Uni-R, Str-L, *Clash} > *Al-L because (1)(02)(02) >> 0(1)(2)0(2) { Al-L, *Lps, Prs, Parse-2, Str-L} > *Al-L because (1)(02)(02) >> 000(01) ------------------------------------------------------------------------------ OUTPUT SET #18: /2/ --> >(01) /3/ --> >(1)(02) /4/ --> >(1)0(02) /5/ --> >(1)(02)(02) Stratum #1 Align-L [= Al-L] Align-R [= Al-R] Prs-2 [= Parse-2] Unary-L [= Uni-L] Stress-R [= Str-R] *Clash [= *Clash] Stratum #2 *Align-L [= *Al-L] *Align-R [= *Al-R] Stress-L [= Str-L] Stratum #3 *Lapse [= *Lps] Parse [= Prs] FtBin [= FtBin] Unary-R [= Uni-R] 18.1. Ranking Arguments Direct Pairwise Arguments Str-L >> *Lps, because /4/ --> [(1)0(02)], not *[(01)(02)]: Str-L >> Prs, because /4/ --> [(1)0(02)], not *[(01)(02)]: Str-L >> FtBin, because /5/ --> [(1)(02)(02)], not *[(01)0(02)]: Str-L >> Uni-R, because /5/ --> [(1)(02)(02)], not *[(01)0(02)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Uni-L, *Clash} > Str-L because (01) >> (1)(2) { Al-R, Str-R} > Str-L because (01) >> (1)0 { Al-L, Prs, FtBin, Uni-L} > *Al-L because (01) >> 0(1) { Al-R, Prs, Str-L, Str-R} > *Al-R because (1)(02) >> (01)0 { Al-L, Al-R, Prs, Str-L, Str-R} > *Al-L because (1)0(02) >> 0(01)0 { FtBin, Uni-L, *Clash} > *Lps because (1)0(02) >> (1)(02)(2) { FtBin, Uni-L, *Clash} > Prs because (1)0(02) >> (1)(02)(2) { Al-R, Str-R} > *Al-R because (1)0(02) >> (1)(02)0 { Al-R, Str-R} > *Lps because (1)0(02) >> (1)(02)0 { Al-L, Uni-L, Str-L} > *Al-L because (1)0(02) >> 0(1)(02) { Al-R, Uni-L, Str-L, Str-R, *Clash} > *Al-R because (1)0(02) >> (01)(2)0 { FtBin, Uni-L, Uni-R, *Clash} > Prs because (1)0(02) >> (1)(2)(2)(2) { Al-R, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because (1)0(02) >> (1)(2)(2)0 { FtBin, Uni-L, Uni-R, *Clash} > *Lps because (1)0(02) >> (1)(2)0(2) { Al-L, Al-R, Prs, Parse-2, Uni-L, Str-L, Str-R} > *Al-L because (1)0(02) >> 00(1)0 { Al-L, *Lps, Prs, Str-L} > *Al-L because (1)(02)(02) >> 0(01)(02) { Al-R, *Lps, Prs, Str-R} > *Al-R because (1)(02)(02) >> (1)0(02)0 { Al-R, *Lps, Prs, Parse-2, Str-L, Str-R} > *Al-R because (1)(02)(02) >> (01)000 { Al-R, *Lps, Prs, Parse-2, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because (1)(02)(02) >> (1)0(2)00 { Al-L, *Lps, Prs, Uni-L, Str-L} > *Al-L because (1)(02)(02) >> 0(01)0(2) { Al-L, Prs, FtBin, Uni-L, Uni-R, Str-L, *Clash} > *Al-L because (1)(02)(02) >> 0(1)(2)0(2) { Al-L, *Lps, Prs, Parse-2, Str-L} > *Al-L because (1)(02)(02) >> 000(01) ------------------------------------------------------------------------------ OUTPUT SET #19: /2/ --> >(1)(2) /3/ --> >(1)(02) /4/ --> >(1)(02)(2) /5/ --> >(1)(02)(02) Stratum #1 Align-L [= Al-L] Align-R [= Al-R] *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] Stress-L [= Str-L] Stress-R [= Str-R] Stratum #2 *Align-L [= *Al-L] *Align-R [= *Al-R] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] *Clash [= *Clash] 19.1. Ranking Arguments Direct Pairwise Arguments Str-L >> FtBin, because /4/ --> [(1)(02)(2)], not *[(01)(02)]: Str-L >> Uni-L, because /4/ --> [(1)(02)(2)], not *[(01)(02)]: Str-L >> Uni-R, because /5/ --> [(1)(02)(02)], not *[(01)(02)(2)]: Str-L >> *Clash, because /4/ --> [(1)(02)(2)], not *[(01)(02)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-R, Prs, Str-R} > *Al-R because (1)(2) >> (1)0 { Al-R, Prs, Str-R} > FtBin because (1)(2) >> (1)0 { Al-R, Prs, Str-R} > Uni-L because (1)(2) >> (1)0 { Al-R, Prs, Str-R} > *Clash because (1)(2) >> (1)0 { Al-L, Al-R, *Lps, Prs, Str-L, Str-R} > *Al-L because (1)(02)(2) >> 0(01)0 { *Lps, Prs} > FtBin because (1)(02)(2) >> (1)0(02) { *Lps, Prs} > Uni-L because (1)(02)(2) >> (1)0(02) { *Lps, Prs} > *Clash because (1)(02)(2) >> (1)0(02) { Al-L, Prs, Str-L} > *Al-L because (1)(02)(2) >> 0(1)(02) { Al-R, Prs, Str-L, Str-R} > *Al-R because (1)(02)(2) >> (01)(2)0 { Al-L, Prs, Uni-L, Str-L} > *Al-L because (1)(02)(2) >> 0(1)0(2) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because (1)(02)(02) >> (1)(02)(2)0 { Al-R, *Lps, Prs, Str-R} > *Al-R because (1)(02)(02) >> (1)0(02)0 { Al-R, Prs, Uni-L, Str-L, Str-R} > *Al-R because (1)(02)(02) >> (01)0(2)0 { Al-R, *Lps, Prs, Parse-2, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because (1)(02)(02) >> (1)0(2)00 { Al-L, Prs, FtBin, Uni-L, Uni-R, Str-L, *Clash} > *Al-L because (1)(02)(02) >> 0(1)(2)(02) { Al-L, *Lps, Prs, Parse-2, Uni-L, Str-L, *Clash} > *Al-L because (1)(02)(02) >> 00(01)(2) { Al-L, *Lps, Prs, Parse-2, FtBin, Uni-L, Str-L} > *Al-L because (1)(02)(02) >> 00(1)0(2) { Al-L, *Lps, Prs, Parse-2, Str-L} > *Al-L because (1)(02)(02) >> 000(01) ------------------------------------------------------------------------------ OUTPUT SET #20: /2/ --> >(1)(2) /3/ --> >(1)(02) /4/ --> >(1)0(02) /5/ --> >(1)(02)(02) Stratum #1 Align-L [= Al-L] Align-R [= Al-R] Prs-2 [= Parse-2] Stress-L [= Str-L] Stress-R [= Str-R] Stratum #2 *Align-L [= *Al-L] *Align-R [= *Al-R] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] *Clash [= *Clash] Stratum #3 *Lapse [= *Lps] Parse [= Prs] 20.1. Ranking Arguments Direct Pairwise Arguments Str-L >> *Lps, because /4/ --> [(1)0(02)], not *[(01)0(2)]: Str-L >> Prs, because /4/ --> [(1)0(02)], not *[(01)(2)(2)]: Str-L >> FtBin, because /5/ --> [(1)(02)(02)], not *[(01)0(02)]: Str-L >> Uni-L, because /2/ --> [(1)(2)], not *[(01)]: Str-L >> Uni-R, because /5/ --> [(1)(02)(02)], not *[(01)(02)(2)]: Str-L >> *Clash, because /2/ --> [(1)(2)], not *[(01)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-R, Prs, Str-R} > FtBin because (1)(2) >> (1)0 { Al-R, Prs, Str-R} > Uni-L because (1)(2) >> (1)0 { Al-R, Prs, Str-R} > *Clash because (1)(2) >> (1)0 { Al-L, Prs, Str-L} > *Al-L because (1)(2) >> 0(1) { Al-L, Al-R, Prs, Str-L, Str-R} > *Al-L because (1)0(02) >> 0(01)0 { FtBin, Uni-L, *Clash} > *Lps because (1)0(02) >> (1)(02)(2) { FtBin, Uni-L, *Clash} > Prs because (1)0(02) >> (1)(02)(2) { Al-R, Str-R} > *Al-R because (1)0(02) >> (1)(02)0 { Al-R, Str-R} > *Lps because (1)0(02) >> (1)(02)0 { Al-L, Uni-L, Str-L} > *Al-L because (1)0(02) >> 0(1)(02) { Al-R, Uni-L, Str-L, Str-R, *Clash} > *Al-R because (1)0(02) >> (01)(2)0 { FtBin, Uni-L, Uni-R, *Clash} > Prs because (1)0(02) >> (1)(2)(2)(2) { Al-R, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because (1)0(02) >> (1)(2)(2)0 { FtBin, Uni-L, Uni-R, *Clash} > *Lps because (1)0(02) >> (1)(2)0(2) { Al-L, Al-R, Prs, Parse-2, Uni-L, Str-L, Str-R} > *Al-L because (1)0(02) >> 00(1)0 { Al-L, *Lps, Prs, Str-L} > *Al-L because (1)(02)(02) >> 0(01)(02) { Al-R, *Lps, Prs, Str-R} > *Al-R because (1)(02)(02) >> (1)0(02)0 { Al-R, Prs, Uni-L, Str-L, Str-R} > *Al-R because (1)(02)(02) >> (01)0(2)0 { Al-R, *Lps, Prs, Parse-2, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because (1)(02)(02) >> (1)0(2)00 { Al-L, *Lps, Prs, Parse-2, Str-L} > *Al-L because (1)(02)(02) >> 000(01) ------------------------------------------------------------------------------ OUTPUT SET #21: /2/ --> >(1)0 /3/ --> >(01)0 /4/ --> >(01)00 /5/ --> >(01)(02)0 Stratum #1 Align-L [= Al-L] *Align-R [= *Al-R] Unary-L [= Uni-L] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] FtBin [= FtBin] Unary-R [= Uni-R] Stress-R [= Str-R] Stratum #3 *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] Stress-L [= Str-L] 21.1. Ranking Arguments Direct Pairwise Arguments Al-L >> *Al-L, because /4/ --> [(01)00], not *[0(01)0]: Al-L >> Parse-2, because /4/ --> [(01)00], not *[0(01)0]: *Al-R >> Al-R, because /5/ --> [(01)(02)0], not *[(01)0(02)]: *Al-R >> *Lps, because /4/ --> [(01)00], not *[(01)(02)]: *Al-R >> Prs, because /4/ --> [(01)00], not *[(01)(02)]: *Al-R >> Parse-2, because /4/ --> [(01)00], not *[(01)(02)]: *Al-R >> Str-R, because /5/ --> [(01)(02)0], not *[(01)0(02)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { *Al-R, Str-L} > FtBin because (1)0 >> (01) { *Al-R, Str-L} > Uni-R because (1)0 >> (01) { *Lps, Prs, Parse-2, FtBin, Uni-R} > Str-L because (01)0 >> (1)00 { FtBin, Uni-R} > *Lps because (01)00 >> (1)(02)0 { FtBin, Uni-R} > Prs because (01)00 >> (1)(02)0 { FtBin, Uni-R} > Parse-2 because (01)00 >> (1)(02)0 { FtBin, Uni-R} > Str-L because (01)00 >> (1)(02)0 { FtBin, Uni-L, Uni-R, *Clash} > *Lps because (01)00 >> (01)(2)0 { FtBin, Uni-L, Uni-R, *Clash} > Parse-2 because (01)00 >> (1)(2)(2)0 { FtBin, Uni-L, Uni-R} > Str-L because (01)00 >> (1)0(2)0 { *Lps, Prs, FtBin, Uni-R} > Str-L because (01)(02)0 >> (1)0(02)0 { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)(02)0 >> (1)(2)(2)(2)0 { *Al-R, FtBin, Uni-L, Uni-R} > Str-L because (01)(02)0 >> (1)0(2)(02) ------------------------------------------------------------------------------ OUTPUT SET #22: /2/ --> >(1)0 /3/ --> >(01)0 /4/ --> >0(01)0 /5/ --> >(01)(02)0 Stratum #1 *Align-R [= *Al-R] Prs-2 [= Parse-2] Unary-L [= Uni-L] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] FtBin [= FtBin] Unary-R [= Uni-R] Stress-R [= Str-R] Stratum #3 Align-L [= Al-L] *Lapse [= *Lps] Parse [= Prs] Stress-L [= Str-L] 22.1. Ranking Arguments Direct Pairwise Arguments (none) There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { *Al-R, Str-L} > Al-R because (1)0 >> (01) { *Al-R, Str-L} > Prs because (1)0 >> (01) { *Al-R, Str-L} > FtBin because (1)0 >> (01) { *Al-R, Str-L} > Uni-R because (1)0 >> (01) { *Al-R, Str-L} > Str-R because (1)0 >> (01) { *Al-R, FtBin, Uni-L, *Clash} > Al-R because (1)0 >> (1)(2) { *Al-R, FtBin, Uni-L, *Clash} > Prs because (1)0 >> (1)(2) { *Al-R, FtBin, Uni-L, *Clash} > Str-R because (1)0 >> (1)(2) { Al-L, *Al-R, Uni-L, Str-L} > *Al-L because (1)0 >> 0(1) { Al-L, *Al-R, *Lps} > Al-R because (01)0 >> 0(01) { Al-L, *Al-R, *Lps} > *Al-L because (01)0 >> 0(01) { *Al-R, FtBin, Uni-R} > Al-R because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-R} > Prs because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-R} > Str-L because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-R} > Str-R because (01)0 >> (1)(02) { *Lps, Prs, Parse-2, FtBin, Uni-R} > Str-L because (01)0 >> (1)00 { Al-L, Prs, FtBin, Uni-L, Uni-R} > *Al-L because (01)0 >> 0(1)0 { *Al-R, FtBin, Uni-L, Uni-R} > Str-L because (01)0 >> (1)0(2) { *Al-L, *Al-R} > Al-L because 0(01)0 >> (01)(02) { *Al-L, *Al-R} > Al-R because 0(01)0 >> (01)(02) { *Al-L, *Al-R} > *Lps because 0(01)0 >> (01)(02) { *Al-L, *Al-R} > Prs because 0(01)0 >> (01)(02) { *Al-L, *Al-R} > Str-R because 0(01)0 >> (01)(02) { *Al-L, Parse-2} > Al-L because 0(01)0 >> (01)00 { *Al-R, *Lps, Parse-2} > Al-R because 0(01)0 >> 00(01) { *Al-R, *Lps, Parse-2} > Str-R because 0(01)0 >> 00(01) { *Al-L, FtBin, Uni-R} > Al-L because 0(01)0 >> (1)(02)0 { *Al-L, FtBin, Uni-R} > *Lps because 0(01)0 >> (1)(02)0 { *Al-L, FtBin, Uni-R} > Prs because 0(01)0 >> (1)(02)0 { *Al-L, FtBin, Uni-R} > Str-L because 0(01)0 >> (1)(02)0 { FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)0 >> 0(1)(2)0 { *Al-R, FtBin, Uni-L, Uni-R} > *Lps because 0(01)0 >> 0(1)0(2) { *Al-R, *Lps} > Al-R because (01)(02)0 >> (01)0(02) { *Al-R, *Lps} > Str-R because (01)(02)0 >> (01)0(02) { Al-L, *Lps, Prs, Parse-2} > *Al-L because (01)(02)0 >> 0(01)00 { *Lps, Prs, FtBin, Uni-R} > Str-L because (01)(02)0 >> (1)0(02)0 { *Al-R, FtBin, Uni-L, Uni-R, *Clash} > Str-R because (01)(02)0 >> (01)0(2)(2) { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)(02)0 >> (1)(2)(2)(2)0 { *Al-R, FtBin, Uni-L, Uni-R} > Str-L because (01)(02)0 >> (1)0(2)(02) { Al-L, *Al-R, FtBin, Uni-L, Uni-R, *Clash} > *Al-L because (01)(02)0 >> 0(1)(2)(2)(2) { Al-L, *Lps, Prs, Parse-2, FtBin, Uni-L, Uni-R} > *Al-L because (01)(02)0 >> 0(1)000 ------------------------------------------------------------------------------ OUTPUT SET #23: /2/ --> >(1)0 /3/ --> >(01)0 /4/ --> >0(01)0 /5/ --> >0(01)00 Stratum #1 *Align-R [= *Al-R] Unary-L [= Uni-L] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] FtBin [= FtBin] Unary-R [= Uni-R] Stress-R [= Str-R] Stratum #3 Align-L [= Al-L] *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] Stress-L [= Str-L] 23.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)00], not *[(01)000]: *Al-L >> *Lps, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-L >> Prs, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-L >> Parse-2, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-R >> Al-L, because /5/ --> [0(01)00], not *[(01)0(02)]: *Al-R >> Al-R, because /5/ --> [0(01)00], not *[000(01)]: *Al-R >> *Al-L, because /3/ --> [(01)0], not *[0(01)]: *Al-R >> *Lps, because /5/ --> [0(01)00], not *[(01)0(02)]: *Al-R >> Prs, because /5/ --> [0(01)00], not *[(01)0(02)]: *Al-R >> Parse-2, because /5/ --> [0(01)00], not *[(01)0(02)]: *Al-R >> Str-R, because /5/ --> [0(01)00], not *[000(01)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { *Al-R, Str-L} > FtBin because (1)0 >> (01) { *Al-R, Str-L} > Uni-R because (1)0 >> (01) { *Al-R, FtBin, Uni-R} > Str-L because (01)0 >> (1)(02) { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)0 >> (1)(2)0 { *Lps, Prs, Parse-2, FtBin, Uni-R} > Str-L because (01)0 >> (1)00 { FtBin, Uni-L, Uni-R} > *Al-L because (01)0 >> 0(1)0 { *Al-R, FtBin, Uni-L, Uni-R} > Str-L because (01)0 >> (1)0(2) { FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)0 >> 0(1)(2)0 { *Al-L, FtBin, Uni-R} > Str-L because 0(01)00 >> (1)0(02)0 { FtBin, Uni-L, Uni-R} > *Lps because 0(01)00 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Prs because 0(01)00 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Parse-2 because 0(01)00 >> 0(1)(02)0 { *Al-L, FtBin, Uni-L, Uni-R} > Str-L because 0(01)00 >> (1)0(2)00 { FtBin, Uni-L, Uni-R, *Clash} > Parse-2 because 0(01)00 >> 0(1)(2)(2)0 ------------------------------------------------------------------------------ OUTPUT SET #24: /2/ --> >(1)0 /3/ --> >(01)0 /4/ --> >0(01)0 /5/ --> >00(01)0 Stratum #1 *Align-R [= *Al-R] Unary-L [= Uni-L] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] FtBin [= FtBin] Unary-R [= Uni-R] Stress-R [= Str-R] Stratum #3 Align-L [= Al-L] *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] Stress-L [= Str-L] 24.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [00(01)0], not *[(01)000]: *Al-L >> *Lps, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-L >> Prs, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-L >> Parse-2, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-R >> Al-L, because /5/ --> [00(01)0], not *[(01)0(02)]: *Al-R >> Al-R, because /5/ --> [00(01)0], not *[000(01)]: *Al-R >> *Al-L, because /3/ --> [(01)0], not *[0(01)]: *Al-R >> *Lps, because /5/ --> [00(01)0], not *[(01)0(02)]: *Al-R >> Prs, because /5/ --> [00(01)0], not *[(01)0(02)]: *Al-R >> Parse-2, because /5/ --> [00(01)0], not *[(01)0(02)]: *Al-R >> Str-R, because /5/ --> [00(01)0], not *[000(01)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { *Al-R, Str-L} > FtBin because (1)0 >> (01) { *Al-R, Str-L} > Uni-R because (1)0 >> (01) { *Al-R, FtBin, Uni-R} > Str-L because (01)0 >> (1)(02) { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)0 >> (1)(2)0 { *Lps, Prs, Parse-2, FtBin, Uni-R} > Str-L because (01)0 >> (1)00 { FtBin, Uni-L, Uni-R} > *Al-L because (01)0 >> 0(1)0 { *Al-R, FtBin, Uni-L, Uni-R} > Str-L because (01)0 >> (1)0(2) { FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)0 >> 0(1)(2)0 { *Al-L, FtBin, Uni-R} > Str-L because 00(01)0 >> (1)0(02)0 { FtBin, Uni-L, Uni-R} > *Lps because 00(01)0 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Prs because 00(01)0 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Parse-2 because 00(01)0 >> 0(1)(02)0 { *Al-L, FtBin, Uni-L, Uni-R} > Str-L because 00(01)0 >> (1)0(2)00 { FtBin, Uni-L, Uni-R, *Clash} > Parse-2 because 00(01)0 >> 0(1)(2)(2)0 ------------------------------------------------------------------------------ OUTPUT SET #25: /2/ --> >(1)0 /3/ --> >(01)0 /4/ --> >0(01)0 /5/ --> >(1)0(02)0 Stratum #1 *Align-R [= *Al-R] Prs-2 [= Parse-2] Unary-L [= Uni-L] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] Stress-R [= Str-R] Stratum #3 Align-L [= Al-L] Stress-L [= Str-L] Stratum #4 *Lapse [= *Lps] Parse [= Prs] FtBin [= FtBin] Unary-R [= Uni-R] 25.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /4/ --> [0(01)0], not *[(1)(02)0]: *Al-L >> *Lps, because /4/ --> [0(01)0], not *[(1)(02)0]: *Al-L >> Prs, because /4/ --> [0(01)0], not *[(1)(02)0]: *Al-L >> Str-L, because /4/ --> [0(01)0], not *[(1)(02)0]: *Al-R >> Al-R, because /5/ --> [(1)0(02)0], not *[(1)(02)(02)]: *Al-R >> *Al-L, because /5/ --> [(1)0(02)0], not *[0(01)(02)]: *Al-R >> *Lps, because /5/ --> [(1)0(02)0], not *[(1)(02)(02)]: *Al-R >> Prs, because /5/ --> [(1)0(02)0], not *[(1)(02)(02)]: *Al-R >> Str-L, because /3/ --> [(01)0], not *[(1)(02)]: *Al-R >> Str-R, because /5/ --> [(1)0(02)0], not *[(1)(02)(02)]: Parse-2 >> *Al-L, because /5/ --> [(1)0(02)0], not *[00(01)0]: Parse-2 >> Str-L, because /3/ --> [(01)0], not *[(1)00]: Uni-L >> *Al-L, because /5/ --> [(1)0(02)0], not *[0(1)(02)0]: Str-L >> *Lps, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: Str-L >> Prs, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: Str-L >> FtBin, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: Str-L >> Uni-R, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: Arguments Derived from Transitivity of Domination *Al-L >> FtBin *Al-L >> Uni-R *Al-R >> Al-L *Al-R >> FtBin *Al-R >> Uni-R Parse-2 >> Al-L Parse-2 >> *Lps Parse-2 >> Prs Parse-2 >> FtBin Parse-2 >> Uni-R Uni-L >> Al-L Uni-L >> *Lps Uni-L >> Prs Uni-L >> FtBin Uni-L >> Uni-R Uni-L >> Str-L There were no irreducible set arguments. ------------------------------------------------------------------------------ OUTPUT SET #26: /2/ --> >(1)0 /3/ --> >(01)0 /4/ --> >(1)(02)0 /5/ --> >(01)(02)0 Stratum #1 Align-L [= Al-L] *Align-R [= *Al-R] *Lapse [= *Lps] Prs-2 [= Parse-2] Unary-L [= Uni-L] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] Parse [= Prs] FtBin [= FtBin] Unary-R [= Uni-R] Stress-L [= Str-L] Stress-R [= Str-R] 26.1. Ranking Arguments Direct Pairwise Arguments (none) There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { *Al-R, Str-L} > Al-R because (1)0 >> (01) { *Al-R, Str-L} > Prs because (1)0 >> (01) { *Al-R, Str-L} > FtBin because (1)0 >> (01) { *Al-R, Str-L} > Uni-R because (1)0 >> (01) { *Al-R, Str-L} > Str-R because (1)0 >> (01) { *Al-R, FtBin, Uni-L, *Clash} > Al-R because (1)0 >> (1)(2) { *Al-R, FtBin, Uni-L, *Clash} > Prs because (1)0 >> (1)(2) { *Al-R, FtBin, Uni-L, *Clash} > Str-R because (1)0 >> (1)(2) { Al-L, *Al-R, Uni-L, Str-L} > *Al-L because (1)0 >> 0(1) { Al-L, *Al-R, *Lps} > *Al-L because (01)0 >> 0(01) { *Al-R, FtBin, Uni-R} > Al-R because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-R} > Prs because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-R} > Str-L because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-R} > Str-R because (01)0 >> (1)(02) { *Lps, Prs, Parse-2, FtBin, Uni-R} > Str-L because (01)0 >> (1)00 { Al-L, Prs, FtBin, Uni-L, Uni-R} > *Al-L because (01)0 >> 0(1)0 { *Al-R, FtBin, Uni-L, Uni-R} > Str-L because (01)0 >> (1)0(2) { *Lps, Prs, Parse-2, Str-L} > FtBin because (1)(02)0 >> (01)00 { *Lps, Prs, Parse-2, Str-L} > Uni-R because (1)(02)0 >> (01)00 { Al-L, *Lps, Prs, Str-L} > *Al-L because (1)(02)0 >> 0(01)0 { Al-L, *Lps, Prs, Str-L} > FtBin because (1)(02)0 >> 0(01)0 { Al-L, *Lps, Prs, Str-L} > Uni-R because (1)(02)0 >> 0(01)0 { *Al-R, *Lps} > Str-R because (1)(02)0 >> (1)0(02) { Al-L, *Al-R, Uni-L, Str-L} > *Al-L because (1)(02)0 >> 0(1)(02) { *Al-R, Uni-L, Str-L} > Str-R because (1)(02)0 >> (01)0(2) { *Al-R, FtBin, Uni-L, Uni-R, *Clash} > Str-R because (1)(02)0 >> (1)0(2)(2) { *Al-R, *Lps, Prs, Parse-2, FtBin, Uni-L} > Al-R because (1)(02)0 >> (1)00(2) { Al-L, *Lps, Prs, Parse-2, Uni-L, Str-L} > *Al-L because (1)(02)0 >> 00(1)0 { *Al-R, *Lps} > Al-R because (01)(02)0 >> (01)0(02) { *Al-R, *Lps} > Str-R because (01)(02)0 >> (01)0(02) { Al-L, *Lps, Prs, Parse-2} > *Al-L because (01)(02)0 >> 0(01)00 { *Lps, Prs, FtBin, Uni-R} > Str-L because (01)(02)0 >> (1)0(02)0 { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)(02)0 >> (1)(2)(2)(2)0 { *Al-R, FtBin, Uni-L, Uni-R} > Str-L because (01)(02)0 >> (1)0(2)(02) { Al-L, *Al-R, FtBin, Uni-L, Uni-R, *Clash} > *Al-L because (01)(02)0 >> 0(1)(2)(2)(2) { Al-L, *Lps, Prs, Parse-2, FtBin, Uni-L, Uni-R} > *Al-L because (01)(02)0 >> 0(1)000 ------------------------------------------------------------------------------ OUTPUT SET #27: /2/ --> >(1)0 /3/ --> >(01)0 /4/ --> >(1)(02)0 /5/ --> >(1)0(02)0 Stratum #1 Align-L [= Al-L] *Align-R [= *Al-R] Prs-2 [= Parse-2] Unary-L [= Uni-L] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] Stress-L [= Str-L] Stress-R [= Str-R] Stratum #3 *Lapse [= *Lps] Parse [= Prs] FtBin [= FtBin] Unary-R [= Uni-R] 27.1. Ranking Arguments Direct Pairwise Arguments *Al-R >> Al-R, because /4/ --> [(1)(02)0], not *[(1)0(02)]: *Al-R >> *Lps, because /5/ --> [(1)0(02)0], not *[(1)(02)(02)]: *Al-R >> Prs, because /5/ --> [(1)0(02)0], not *[(1)(02)(02)]: *Al-R >> Str-L, because /3/ --> [(01)0], not *[(1)(02)]: *Al-R >> Str-R, because /4/ --> [(1)(02)0], not *[(1)0(02)]: Parse-2 >> Str-L, because /3/ --> [(01)0], not *[(1)00]: Str-L >> *Lps, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: Str-L >> Prs, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: Str-L >> FtBin, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: Str-L >> Uni-R, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: Arguments Derived from Transitivity of Domination *Al-R >> FtBin *Al-R >> Uni-R Parse-2 >> *Lps Parse-2 >> Prs Parse-2 >> FtBin Parse-2 >> Uni-R Irreducible Set Arguments { Al-L, *Al-R, *Lps} > *Al-L because (01)0 >> 0(01) { Uni-L, *Clash} > Str-L because (01)0 >> (1)(2)0 { Al-L, *Al-R, FtBin, Uni-L, Uni-R, *Clash} > *Al-L because (01)0 >> 0(1)(2) { Al-L, Prs, FtBin, Uni-L, Uni-R} > *Al-L because (01)0 >> 0(1)0 { Al-L, *Lps, Prs, Str-L} > *Al-L because (1)(02)0 >> 0(01)0 { Al-L, *Al-R, Str-L} > *Al-L because (1)0(02)0 >> 0(01)(02) { Al-L, *Lps, Prs, Parse-2, Str-L} > *Al-L because (1)0(02)0 >> 00(01)0 { FtBin, Uni-L, Uni-R, *Clash} > Prs because (1)0(02)0 >> (1)(02)(2)0 { Al-L, Uni-L, Str-L} > *Al-L because (1)0(02)0 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R, *Clash} > *Lps because (1)0(02)0 >> (1)0(2)(2)0 { Al-L, Uni-L, Str-L, *Clash} > *Al-L because (1)0(02)0 >> 0(01)(2)0 { Al-L, Prs, FtBin, Uni-L, Uni-R, Str-L} > *Al-L because (1)0(02)0 >> 0(1)0(2)0 { Al-L, *Al-R, Parse-2, Uni-L, Str-L} > *Al-L because (1)0(02)0 >> 00(1)(02) ------------------------------------------------------------------------------ OUTPUT SET #28: /2/ --> >(1)0 /3/ --> >0(01) /4/ --> >0(01)0 /5/ --> >0(01)(02) Stratum #1 Prs-2 [= Parse-2] Unary-L [= Uni-L] *Clash [= *Clash] Stratum #2 *Align-L [= *Al-L] Stratum #3 Align-L [= Al-L] *Align-R [= *Al-R] *Lapse [= *Lps] Stress-L [= Str-L] Stratum #4 Align-R [= Al-R] Parse [= Prs] FtBin [= FtBin] Unary-R [= Uni-R] Stress-R [= Str-R] 28.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)(02)], not *[(01)0(02)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { *Al-R, Str-L} > Al-R because (1)0 >> (01) { *Al-R, Str-L} > Prs because (1)0 >> (01) { *Al-R, Str-L} > FtBin because (1)0 >> (01) { *Al-R, Str-L} > Uni-R because (1)0 >> (01) { *Al-R, Str-L} > Str-R because (1)0 >> (01) { *Al-R, FtBin, Uni-L, *Clash} > Al-R because (1)0 >> (1)(2) { *Al-R, FtBin, Uni-L, *Clash} > Prs because (1)0 >> (1)(2) { *Al-R, FtBin, Uni-L, *Clash} > Str-R because (1)0 >> (1)(2) { *Al-R, Uni-L, Str-L} > *Al-L because (1)0 >> 0(1) { Al-R, *Al-L, Str-R} > *Al-R because 0(01) >> (01)0 { Al-R, *Al-L, Str-R} > *Lps because 0(01) >> (01)0 { *Al-L, FtBin, Uni-L, *Clash} > *Lps because 0(01) >> (01)(2) { *Al-L, FtBin, Uni-L, *Clash} > Prs because 0(01) >> (01)(2) { *Al-L, FtBin, Uni-R} > *Lps because 0(01) >> (1)(02) { *Al-L, FtBin, Uni-R} > Prs because 0(01) >> (1)(02) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Lps because 0(01) >> 0(1)0 { *Al-L, FtBin, Uni-L, Uni-R} > Str-L because 0(01) >> (1)0(2) { *Al-L, *Al-R} > Al-R because 0(01)0 >> (01)(02) { *Al-L, *Al-R} > *Lps because 0(01)0 >> (01)(02) { *Al-L, *Al-R} > Prs because 0(01)0 >> (01)(02) { *Al-L, *Al-R} > Str-R because 0(01)0 >> (01)(02) { *Al-R, *Lps, Parse-2} > Al-R because 0(01)0 >> 00(01) { *Al-R, *Lps, Parse-2} > Str-R because 0(01)0 >> 00(01) { *Al-L, FtBin, Uni-R} > Str-L because 0(01)0 >> (1)(02)0 { *Al-R, FtBin, Uni-L, Uni-R} > Al-R because 0(01)0 >> 0(1)(02) { *Al-R, FtBin, Uni-L, Uni-R} > *Lps because 0(01)0 >> 0(1)(02) { *Al-R, FtBin, Uni-L, Uni-R} > Prs because 0(01)0 >> 0(1)(02) { *Al-R, FtBin, Uni-L, Uni-R} > Str-R because 0(01)0 >> 0(1)(02) { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because 0(01)(02) >> 0(01)00 { Al-R, *Al-L, Prs, FtBin, Uni-R, Str-R} > Str-L because 0(01)(02) >> (1)0(02)0 { *Al-L, FtBin, Uni-L, Uni-R, *Clash} > Str-L because 0(01)(02) >> (1)(2)(2)0(2) { Al-R, *Al-L, Prs, FtBin, Uni-L, Uni-R, Str-R, *Clash} > Str-L because 0(01)(02) >> (1)(2)0(2)0 { *Al-L, *Lps, Prs, Parse-2, FtBin, Uni-L, Uni-R} > Str-L because 0(01)(02) >> (1)000(2) { FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)(02) >> 0(1)(2)(2)(2) { Prs, FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)(02) >> 0(1)(2)0(2) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because 0(01)(02) >> 0(1)0(2)0 { Al-R, Prs, Parse-2, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because 0(01)(02) >> 00(1)(2)0 ------------------------------------------------------------------------------ OUTPUT SET #29: /2/ --> >(1)0 /3/ --> >0(01) /4/ --> >0(01)0 /5/ --> >0(01)00 Stratum #1 Unary-L [= Uni-L] *Clash [= *Clash] Stratum #2 *Align-L [= *Al-L] Stratum #3 Align-L [= Al-L] *Align-R [= *Al-R] Stress-L [= Str-L] Stratum #4 Align-R [= Al-R] *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] FtBin [= FtBin] Unary-R [= Uni-R] Stress-R [= Str-R] 29.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)00], not *[(01)000]: *Al-L >> *Al-R, because /3/ --> [0(01)], not *[(01)0]: *Al-L >> *Lps, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-L >> Prs, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-L >> Parse-2, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-R >> Al-R, because /5/ --> [0(01)00], not *[000(01)]: *Al-R >> *Lps, because /5/ --> [0(01)00], not *[0(01)(02)]: *Al-R >> Prs, because /5/ --> [0(01)00], not *[0(01)(02)]: *Al-R >> Parse-2, because /5/ --> [0(01)00], not *[0(01)(02)]: *Al-R >> Str-R, because /5/ --> [0(01)00], not *[000(01)]: Arguments Derived from Transitivity of Domination *Al-L >> Al-R *Al-L >> Str-R Irreducible Set Arguments { *Al-R, Str-L} > FtBin because (1)0 >> (01) { *Al-R, Str-L} > Uni-R because (1)0 >> (01) { Uni-L, Str-L} > *Al-L because (1)0 >> 0(1) { Al-R, *Al-L, Prs, Parse-2, FtBin, Uni-R, Str-R} > Str-L because 0(01) >> (1)00 { FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01) >> 0(1)(2) { FtBin, Uni-L, Uni-R} > *Al-R because 0(01) >> 0(1)0 { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Lps because 0(01) >> 0(1)0 { *Al-L, FtBin, Uni-R} > Str-L because 0(01)0 >> (1)(02)0 { *Al-L, *Al-R, Parse-2, FtBin, Uni-L, Uni-R} > Str-L because 0(01)0 >> (1)00(2) { *Al-L, *Al-R, FtBin, Uni-R} > Str-L because 0(01)00 >> (1)(02)(02) { FtBin, Uni-L, Uni-R} > *Lps because 0(01)00 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Prs because 0(01)00 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Parse-2 because 0(01)00 >> 0(1)(02)0 { *Al-L, FtBin, Uni-L, Uni-R, *Clash} > Str-L because 0(01)00 >> (1)(2)0(2)0 { *Al-L, *Al-R, FtBin, Uni-L, Uni-R} > Str-L because 0(01)00 >> (1)0(2)(02) { *Al-L, FtBin, Uni-L, Uni-R} > Str-L because 0(01)00 >> (1)0(2)00 { FtBin, Uni-L, Uni-R, *Clash} > Parse-2 because 0(01)00 >> 0(1)(2)(2)0 ------------------------------------------------------------------------------ OUTPUT SET #30: /2/ --> >(1)0 /3/ --> >0(01) /4/ --> >0(01)0 /5/ --> >00(01)0 Stratum #1 Unary-L [= Uni-L] *Clash [= *Clash] Stratum #2 *Align-L [= *Al-L] Stratum #3 Align-L [= Al-L] *Align-R [= *Al-R] Stress-L [= Str-L] Stratum #4 Align-R [= Al-R] *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] FtBin [= FtBin] Unary-R [= Uni-R] Stress-R [= Str-R] 30.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [00(01)0], not *[(01)000]: *Al-L >> *Al-R, because /3/ --> [0(01)], not *[(01)0]: *Al-L >> *Lps, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-L >> Prs, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-L >> Parse-2, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-R >> Al-R, because /5/ --> [00(01)0], not *[000(01)]: *Al-R >> *Lps, because /5/ --> [00(01)0], not *[0(01)(02)]: *Al-R >> Prs, because /5/ --> [00(01)0], not *[0(01)(02)]: *Al-R >> Parse-2, because /5/ --> [00(01)0], not *[0(01)(02)]: *Al-R >> Str-R, because /5/ --> [00(01)0], not *[000(01)]: Arguments Derived from Transitivity of Domination *Al-L >> Al-R *Al-L >> Str-R Irreducible Set Arguments { *Al-R, Str-L} > FtBin because (1)0 >> (01) { *Al-R, Str-L} > Uni-R because (1)0 >> (01) { Uni-L, Str-L} > *Al-L because (1)0 >> 0(1) { Al-R, *Al-L, Prs, Parse-2, FtBin, Uni-R, Str-R} > Str-L because 0(01) >> (1)00 { FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01) >> 0(1)(2) { FtBin, Uni-L, Uni-R} > *Al-R because 0(01) >> 0(1)0 { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Lps because 0(01) >> 0(1)0 { *Al-L, FtBin, Uni-R} > Str-L because 0(01)0 >> (1)(02)0 { *Al-L, *Al-R, Parse-2, FtBin, Uni-L, Uni-R} > Str-L because 0(01)0 >> (1)00(2) { *Al-L, *Al-R, FtBin, Uni-R} > Str-L because 00(01)0 >> (1)(02)(02) { FtBin, Uni-L, Uni-R} > *Lps because 00(01)0 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Prs because 00(01)0 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Parse-2 because 00(01)0 >> 0(1)(02)0 { *Al-L, FtBin, Uni-L, Uni-R, *Clash} > Str-L because 00(01)0 >> (1)(2)0(2)0 { *Al-L, *Al-R, FtBin, Uni-L, Uni-R} > Str-L because 00(01)0 >> (1)0(2)(02) { *Al-L, FtBin, Uni-L, Uni-R} > Str-L because 00(01)0 >> (1)0(2)00 { FtBin, Uni-L, Uni-R, *Clash} > Parse-2 because 00(01)0 >> 0(1)(2)(2)0 ------------------------------------------------------------------------------ OUTPUT SET #31: /2/ --> >(1)0 /3/ --> >0(01) /4/ --> >00(01) /5/ --> >0(01)(02) Stratum #1 Unary-L [= Uni-L] *Clash [= *Clash] Stratum #2 *Align-L [= *Al-L] Stratum #3 Align-L [= Al-L] Stress-L [= Str-L] Stratum #4 Align-R [= Al-R] Parse [= Prs] FtBin [= FtBin] Unary-R [= Uni-R] Stress-R [= Str-R] Stratum #5 *Align-R [= *Al-R] *Lapse [= *Lps] Prs-2 [= Parse-2] 31.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)(02)], not *[(01)0(02)]: *Al-L >> *Lps, because /4/ --> [00(01)], not *[(01)(02)]: *Al-L >> Prs, because /4/ --> [00(01)], not *[(01)(02)]: *Al-L >> Parse-2, because /4/ --> [00(01)], not *[(01)(02)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { *Al-R, Str-L} > Al-R because (1)0 >> (01) { *Al-R, Str-L} > Prs because (1)0 >> (01) { *Al-R, Str-L} > FtBin because (1)0 >> (01) { *Al-R, Str-L} > Uni-R because (1)0 >> (01) { *Al-R, Str-L} > Str-R because (1)0 >> (01) { *Al-R, FtBin, Uni-L, *Clash} > Al-R because (1)0 >> (1)(2) { *Al-R, FtBin, Uni-L, *Clash} > Str-R because (1)0 >> (1)(2) { *Al-R, Uni-L, Str-L} > *Al-L because (1)0 >> 0(1) { *Al-L, FtBin, Uni-R} > Str-L because 0(01) >> (1)(02) { Al-R, Str-R} > *Al-R because 00(01) >> 0(01)0 { Al-R, Str-R} > *Lps because 00(01) >> 0(01)0 { Al-R, Str-R} > Parse-2 because 00(01) >> 0(01)0 { Al-R, *Al-L, FtBin, Uni-R, Str-R} > Str-L because 00(01) >> (1)(02)0 { FtBin, Uni-L, *Clash} > *Lps because 00(01) >> 0(01)(2) { FtBin, Uni-L, *Clash} > Prs because 00(01) >> 0(01)(2) { FtBin, Uni-L, *Clash} > Parse-2 because 00(01) >> 0(01)(2) { FtBin, Uni-L, Uni-R} > Prs because 00(01) >> 0(1)(02) { FtBin, Uni-L, Uni-R} > Parse-2 because 00(01) >> 0(1)(02) { Al-R, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because 00(01) >> 0(1)(2)0 { *Al-L, FtBin, Uni-L, Uni-R} > Str-L because 00(01) >> (1)00(2) { FtBin, Uni-L, Uni-R} > *Lps because 00(01) >> 0(1)0(2) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Lps because 00(01) >> 00(1)0 { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because 0(01)(02) >> 0(01)00 { Al-R, *Al-L, Prs, FtBin, Uni-R, Str-R} > Str-L because 0(01)(02) >> (1)0(02)0 { *Al-L, FtBin, Uni-L, Uni-R, *Clash} > Str-L because 0(01)(02) >> (1)(2)(2)0(2) { *Al-L, *Lps, Prs, Parse-2, FtBin, Uni-L, Uni-R} > Str-L because 0(01)(02) >> (1)000(2) { Prs, FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)(02) >> 0(1)(2)0(2) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because 0(01)(02) >> 0(1)0(2)0 ------------------------------------------------------------------------------ OUTPUT SET #32: /2/ --> >(1)0 /3/ --> >(1)(02) /4/ --> >(1)(02)0 /5/ --> >(1)(02)(02) Stratum #1 Align-L [= Al-L] *Lapse [= *Lps] Prs-2 [= Parse-2] Unary-L [= Uni-L] Stress-L [= Str-L] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] *Align-R [= *Al-R] Parse [= Prs] FtBin [= FtBin] Unary-R [= Uni-R] Stress-R [= Str-R] 32.1. Ranking Arguments Direct Pairwise Arguments (none) There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { *Al-R, Str-L} > Al-R because (1)0 >> (01) { *Al-R, Str-L} > Prs because (1)0 >> (01) { *Al-R, Str-L} > FtBin because (1)0 >> (01) { *Al-R, Str-L} > Uni-R because (1)0 >> (01) { *Al-R, Str-L} > Str-R because (1)0 >> (01) { *Al-R, FtBin, Uni-L, *Clash} > Al-R because (1)0 >> (1)(2) { *Al-R, FtBin, Uni-L, *Clash} > Prs because (1)0 >> (1)(2) { *Al-R, FtBin, Uni-L, *Clash} > Str-R because (1)0 >> (1)(2) { Al-R, Prs, Str-L, Str-R} > *Al-R because (1)(02) >> (01)0 { Al-R, Prs, Str-L, Str-R} > FtBin because (1)(02) >> (01)0 { Al-R, Prs, Str-L, Str-R} > Uni-R because (1)(02) >> (01)0 { Al-L, *Lps, Prs, Str-L} > *Al-L because (1)(02) >> 0(01) { Al-L, *Lps, Prs, Str-L} > Uni-R because (1)(02) >> 0(01) { Uni-L, Str-L, *Clash} > Uni-R because (1)(02) >> (01)(2) { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because (1)(02) >> (1)00 { Al-L, Prs, FtBin, Uni-L, Str-L, *Clash} > *Al-L because (1)(02) >> 0(1)(2) { Al-L, Al-R, Prs, Uni-L, Str-L, Str-R} > *Al-L because (1)(02) >> 0(1)0 { *Lps, Prs, Parse-2, Str-L} > FtBin because (1)(02)0 >> (01)00 { *Al-R, *Lps} > Al-R because (1)(02)0 >> (1)0(02) { *Al-R, *Lps} > Str-R because (1)(02)0 >> (1)0(02) { Al-L, *Al-R, Uni-L, Str-L} > *Al-L because (1)(02)0 >> 0(1)(02) { *Al-R, Uni-L, Str-L} > Str-R because (1)(02)0 >> (01)0(2) { *Al-R, FtBin, Uni-L, Uni-R, *Clash} > Str-R because (1)(02)0 >> (1)(2)(2)(2) { Al-L, *Al-R, Prs, FtBin, Uni-L, Str-L} > *Al-L because (1)(02)0 >> 0(1)0(2) { *Lps, Prs, Str-L} > FtBin because (1)(02)(02) >> (01)0(02) { *Lps, Prs, Str-L} > Uni-R because (1)(02)(02) >> (01)0(02) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because (1)(02)(02) >> (1)(2)(02)0 { Al-R, *Lps, Prs, Str-R} > *Al-R because (1)(02)(02) >> (1)0(02)0 { Al-R, Prs, Uni-L, Str-L, Str-R} > *Al-R because (1)(02)(02) >> (01)0(2)0 { Al-R, *Lps, Prs, Parse-2, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because (1)(02)(02) >> (1)0(2)00 { Al-L, Prs, FtBin, Uni-L, Uni-R, Str-L, *Clash} > *Al-L because (1)(02)(02) >> 0(1)(2)(2)(2) { Al-L, *Lps, Prs, Uni-L, Str-L} > *Al-L because (1)(02)(02) >> 0(1)0(02) { Al-L, *Lps, Prs, Parse-2, FtBin, Uni-L, Str-L} > *Al-L because (1)(02)(02) >> 00(1)0(2) { Al-L, *Lps, Prs, Parse-2, Str-L} > *Al-L because (1)(02)(02) >> 000(01) ------------------------------------------------------------------------------ OUTPUT SET #33: /2/ --> >(1)0 /3/ --> >(1)(02) /4/ --> >(1)(02)0 /5/ --> >(1)0(02)0 Stratum #1 Align-L [= Al-L] Prs-2 [= Parse-2] Unary-L [= Uni-L] Stress-L [= Str-L] *Clash [= *Clash] Stratum #2 *Align-L [= *Al-L] *Align-R [= *Al-R] FtBin [= FtBin] Unary-R [= Uni-R] Stratum #3 Align-R [= Al-R] *Lapse [= *Lps] Parse [= Prs] Stress-R [= Str-R] 33.1. Ranking Arguments Direct Pairwise Arguments *Al-R >> Al-R, because /4/ --> [(1)(02)0], not *[(1)0(02)]: *Al-R >> *Lps, because /5/ --> [(1)0(02)0], not *[(1)(02)(02)]: *Al-R >> Prs, because /5/ --> [(1)0(02)0], not *[(1)(02)(02)]: *Al-R >> Str-R, because /4/ --> [(1)(02)0], not *[(1)0(02)]: Parse-2 >> *Al-R, because /3/ --> [(1)(02)], not *[(1)00]: Str-L >> *Al-R, because /3/ --> [(1)(02)], not *[(01)0]: Str-L >> *Lps, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: Str-L >> Prs, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: Str-L >> FtBin, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: Str-L >> Uni-R, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: Arguments Derived from Transitivity of Domination Parse-2 >> Al-R Parse-2 >> *Lps Parse-2 >> Prs Parse-2 >> Str-R Str-L >> Al-R Str-L >> Str-R Irreducible Set Arguments { FtBin, Uni-L, Uni-R, *Clash} > *Al-R because (1)(02) >> (1)(2)0 { Al-L, Al-R, Prs, Uni-L, Str-L, Str-R} > *Al-L because (1)(02) >> 0(1)0 { Al-L, *Lps, Prs, Str-L} > *Al-L because (1)(02)0 >> 0(01)0 { Al-L, *Al-R, Uni-L, Str-L} > *Al-L because (1)(02)0 >> 0(1)(02) { Al-L, *Al-R, Str-L} > *Al-L because (1)0(02)0 >> 0(01)(02) { Al-L, *Lps, Prs, Parse-2, Str-L} > *Al-L because (1)0(02)0 >> 00(01)0 { FtBin, Uni-L, Uni-R, *Clash} > Prs because (1)0(02)0 >> (1)(02)(2)0 { Al-L, Uni-L, Str-L} > *Al-L because (1)0(02)0 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R, *Clash} > *Lps because (1)0(02)0 >> (1)0(2)(2)0 { Al-L, Uni-L, Str-L, *Clash} > *Al-L because (1)0(02)0 >> 0(01)(2)0 { Al-L, Prs, FtBin, Uni-L, Uni-R, Str-L} > *Al-L because (1)0(02)0 >> 0(1)0(2)0 { Al-L, *Al-R, *Lps, Prs, Parse-2, Str-L} > *Al-L because (1)0(02)0 >> 000(01) ------------------------------------------------------------------------------ OUTPUT SET #34: /2/ --> >(1)0 /3/ --> >(1)(02) /4/ --> >(1)0(02) /5/ --> >(1)(02)(02) Stratum #1 Align-L [= Al-L] Prs-2 [= Parse-2] Unary-L [= Uni-L] Stress-L [= Str-L] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] Parse [= Prs] FtBin [= FtBin] Unary-R [= Uni-R] Stress-R [= Str-R] Stratum #3 *Align-R [= *Al-R] *Lapse [= *Lps] 34.1. Ranking Arguments Direct Pairwise Arguments Str-L >> *Lps, because /4/ --> [(1)0(02)], not *[(01)(02)]: Str-L >> Prs, because /4/ --> [(1)0(02)], not *[(01)(02)]: Str-L >> FtBin, because /5/ --> [(1)(02)(02)], not *[(01)0(02)]: Str-L >> Uni-R, because /5/ --> [(1)(02)(02)], not *[(01)0(02)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { *Al-R, Str-L} > Al-R because (1)0 >> (01) { *Al-R, Str-L} > Str-R because (1)0 >> (01) { *Al-R, FtBin, Uni-L, *Clash} > Al-R because (1)0 >> (1)(2) { *Al-R, FtBin, Uni-L, *Clash} > Str-R because (1)0 >> (1)(2) { Al-L, *Al-R, Uni-L, Str-L} > *Al-L because (1)0 >> 0(1) { Al-L, Al-R, Prs, Str-L, Str-R} > *Al-L because (1)0(02) >> 0(01)0 { FtBin, Uni-L, *Clash} > *Lps because (1)0(02) >> (1)(02)(2) { FtBin, Uni-L, *Clash} > Prs because (1)0(02) >> (1)(02)(2) { Al-R, Str-R} > *Al-R because (1)0(02) >> (1)(02)0 { Al-R, Str-R} > *Lps because (1)0(02) >> (1)(02)0 { Al-L, Uni-L, Str-L} > *Al-L because (1)0(02) >> 0(1)(02) { Al-R, Uni-L, Str-L, Str-R, *Clash} > *Al-R because (1)0(02) >> (01)(2)0 { FtBin, Uni-L, Uni-R, *Clash} > Prs because (1)0(02) >> (1)(2)(02) { Al-R, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because (1)0(02) >> (1)(2)(2)0 { FtBin, Uni-L, Uni-R, *Clash} > *Lps because (1)0(02) >> (1)(2)0(2) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because (1)0(02) >> (1)0(2)0 { Al-L, FtBin, Uni-L, Uni-R, Str-L, *Clash} > *Al-L because (1)0(02) >> 0(1)(2)(2) { Al-L, Prs, FtBin, Uni-L, Str-L} > *Al-L because (1)0(02) >> 0(1)0(2) { Al-L, Al-R, Prs, Parse-2, Uni-L, Str-L, Str-R} > *Al-L because (1)0(02) >> 00(1)0 { Al-L, *Lps, Prs, Str-L} > *Al-L because (1)(02)(02) >> 0(01)(02) { Al-L, Al-R, *Lps, Prs, Parse-2, Str-L, Str-R} > *Al-L because (1)(02)(02) >> 00(01)0 { Al-R, *Lps, Prs, Str-R} > *Al-R because (1)(02)(02) >> (1)0(02)0 { Al-R, Prs, Uni-L, Str-L, Str-R} > *Al-R because (1)(02)(02) >> (01)0(2)0 { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because (1)(02)(02) >> (1)0000 { Al-L, *Lps, Prs, Uni-L, Str-L} > *Al-L because (1)(02)(02) >> 0(1)0(02) { Al-L, *Lps, Prs, Parse-2, Uni-L, Str-L} > *Al-L because (1)(02)(02) >> 0000(1) ------------------------------------------------------------------------------ OUTPUT SET #35: /2/ --> >(1)0 /3/ --> >(1)(2)0 /4/ --> >(1)(02)0 /5/ --> >(1)(02)(2)0 Stratum #1 Align-L [= Al-L] *Align-R [= *Al-R] *Lapse [= *Lps] Prs-2 [= Parse-2] Stress-L [= Str-L] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] Stress-R [= Str-R] *Clash [= *Clash] 35.1. Ranking Arguments Direct Pairwise Arguments *Al-R >> Al-R, because /5/ --> [(1)(02)(2)0], not *[(1)0(2)0(2)]: *Al-R >> Prs, because /5/ --> [(1)(02)(2)0], not *[(1)(2)(2)(2)(2)]: *Al-R >> FtBin, because /5/ --> [(1)(02)(2)0], not *[(1)(02)(02)]: *Al-R >> Uni-L, because /5/ --> [(1)(02)(2)0], not *[(1)(02)(02)]: *Al-R >> Uni-R, because /5/ --> [(1)(02)(2)0], not *[(1)(02)0(2)]: *Al-R >> Str-R, because /5/ --> [(1)(02)(2)0], not *[(1)0(2)0(2)]: *Al-R >> *Clash, because /5/ --> [(1)(02)(2)0], not *[(1)0(2)0(2)]: Str-L >> FtBin, because /5/ --> [(1)(02)(2)0], not *[(01)(02)0]: Str-L >> Uni-L, because /5/ --> [(1)(02)(2)0], not *[(01)(02)0]: Str-L >> Uni-R, because /5/ --> [(1)(02)(2)0], not *[(01)(02)0]: Str-L >> *Clash, because /5/ --> [(1)(02)(2)0], not *[(01)(02)0]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-L, *Al-R, *Lps, Str-L} > *Al-L because (1)(2)0 >> 0(01) { *Lps, Prs, Parse-2} > FtBin because (1)(2)0 >> (1)00 { *Lps, Prs, Parse-2} > Uni-R because (1)(2)0 >> (1)00 { Al-L, Prs, Str-L} > *Al-L because (1)(2)0 >> 0(1)0 { Al-L, *Al-R, Uni-L, Str-L} > *Al-L because (1)(02)0 >> 0(1)(02) { Al-L, *Al-R, Prs, FtBin, Uni-L, Str-L} > *Al-L because (1)(02)0 >> 0(1)0(2) { *Lps, Prs} > FtBin because (1)(02)(2)0 >> (1)0(02)0 { *Lps, Prs} > Uni-L because (1)(02)(2)0 >> (1)0(02)0 { *Lps, Prs} > Uni-R because (1)(02)(2)0 >> (1)0(02)0 { *Lps, Prs} > *Clash because (1)(02)(2)0 >> (1)0(02)0 { *Lps, Prs, Parse-2} > *Clash because (1)(02)(2)0 >> (1)0(2)00 { Al-L, *Al-R, FtBin, Uni-L, Uni-R, Str-L, *Clash} > *Al-L because (1)(02)(2)0 >> 0(1)(2)(2)(2) ------------------------------------------------------------------------------ OUTPUT SET #36: /2/ --> >(1)0 /3/ --> >(1)(2)0 /4/ --> >(1)(02)0 /5/ --> >(1)(2)(02)0 Stratum #1 Align-L [= Al-L] *Align-R [= *Al-R] *Lapse [= *Lps] Prs-2 [= Parse-2] Stress-L [= Str-L] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] Stress-R [= Str-R] *Clash [= *Clash] 36.1. Ranking Arguments Direct Pairwise Arguments *Al-R >> Al-R, because /5/ --> [(1)(2)(02)0], not *[(1)0(2)0(2)]: *Al-R >> Prs, because /5/ --> [(1)(2)(02)0], not *[(1)(2)(2)(2)(2)]: *Al-R >> FtBin, because /5/ --> [(1)(2)(02)0], not *[(1)(02)(02)]: *Al-R >> Uni-L, because /5/ --> [(1)(2)(02)0], not *[(1)(02)(02)]: *Al-R >> Uni-R, because /5/ --> [(1)(2)(02)0], not *[(1)(02)0(2)]: *Al-R >> Str-R, because /5/ --> [(1)(2)(02)0], not *[(1)0(2)0(2)]: *Al-R >> *Clash, because /5/ --> [(1)(2)(02)0], not *[(1)0(2)0(2)]: Str-L >> FtBin, because /5/ --> [(1)(2)(02)0], not *[(01)(02)0]: Str-L >> Uni-L, because /5/ --> [(1)(2)(02)0], not *[(01)(02)0]: Str-L >> Uni-R, because /5/ --> [(1)(2)(02)0], not *[(01)(02)0]: Str-L >> *Clash, because /5/ --> [(1)(2)(02)0], not *[(01)(02)0]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-L, *Al-R, *Lps, Str-L} > *Al-L because (1)(2)0 >> 0(01) { *Lps, Prs, Parse-2} > FtBin because (1)(2)0 >> (1)00 { *Lps, Prs, Parse-2} > Uni-R because (1)(2)0 >> (1)00 { Al-L, Prs, Str-L} > *Al-L because (1)(2)0 >> 0(1)0 { Al-L, *Al-R, Uni-L, Str-L} > *Al-L because (1)(02)0 >> 0(1)(02) { Al-L, *Al-R, Prs, FtBin, Uni-L, Str-L} > *Al-L because (1)(02)0 >> 0(1)0(2) { *Lps, Prs} > FtBin because (1)(2)(02)0 >> (1)0(02)0 { *Lps, Prs} > Uni-L because (1)(2)(02)0 >> (1)0(02)0 { *Lps, Prs} > Uni-R because (1)(2)(02)0 >> (1)0(02)0 { *Lps, Prs} > *Clash because (1)(2)(02)0 >> (1)0(02)0 { *Lps, Prs, Parse-2} > *Clash because (1)(2)(02)0 >> (1)0(2)00 { Al-L, *Al-R, FtBin, Uni-L, Uni-R, Str-L, *Clash} > *Al-L because (1)(2)(02)0 >> 0(1)(2)(2)(2) ------------------------------------------------------------------------------ OUTPUT SET #37: /2/ --> >(1)0 /3/ --> >(1)(2)0 /4/ --> >(1)(02)0 /5/ --> >(1)0(02)0 Stratum #1 Align-L [= Al-L] *Align-R [= *Al-R] Prs-2 [= Parse-2] Stress-L [= Str-L] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] Stress-R [= Str-R] *Clash [= *Clash] Stratum #3 *Lapse [= *Lps] Parse [= Prs] 37.1. Ranking Arguments Direct Pairwise Arguments *Al-R >> Al-R, because /5/ --> [(1)0(02)0], not *[(1)0(2)0(2)]: *Al-R >> *Lps, because /5/ --> [(1)0(02)0], not *[(1)0(2)0(2)]: *Al-R >> Prs, because /5/ --> [(1)0(02)0], not *[(1)0(2)(2)(2)]: *Al-R >> FtBin, because /3/ --> [(1)(2)0], not *[(1)(02)]: *Al-R >> Uni-L, because /3/ --> [(1)(2)0], not *[(1)(02)]: *Al-R >> Uni-R, because /3/ --> [(1)(2)0], not *[(1)0(2)]: *Al-R >> Str-R, because /5/ --> [(1)0(02)0], not *[(1)0(2)0(2)]: *Al-R >> *Clash, because /3/ --> [(1)(2)0], not *[(1)0(2)]: Str-L >> *Lps, because /5/ --> [(1)0(02)0], not *[(01)0(2)0]: Str-L >> Prs, because /5/ --> [(1)0(02)0], not *[(01)(2)(2)0]: Str-L >> FtBin, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: Str-L >> Uni-L, because /3/ --> [(1)(2)0], not *[(01)0]: Str-L >> Uni-R, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: Str-L >> *Clash, because /3/ --> [(1)(2)0], not *[(01)0]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { *Lps, Prs, Parse-2} > FtBin because (1)(2)0 >> (1)00 { *Lps, Prs, Parse-2} > Uni-L because (1)(2)0 >> (1)00 { *Lps, Prs, Parse-2} > Uni-R because (1)(2)0 >> (1)00 { *Lps, Prs, Parse-2} > *Clash because (1)(2)0 >> (1)00 { Al-L, Prs, Str-L} > *Al-L because (1)(2)0 >> 0(1)0 { Al-L, *Al-R, Prs, FtBin, Uni-L, Str-L} > *Al-L because (1)(02)0 >> 0(1)0(2) { Al-L, *Al-R, Str-L} > *Al-L because (1)0(02)0 >> 0(01)(02) { Al-L, *Lps, Prs, Parse-2, Str-L} > *Al-L because (1)0(02)0 >> 00(01)0 { FtBin, Uni-L, Uni-R, *Clash} > Prs because (1)0(02)0 >> (1)(02)(2)0 { Al-L, Uni-L, Str-L} > *Al-L because (1)0(02)0 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R, *Clash} > *Lps because (1)0(02)0 >> (1)0(2)(2)0 { Al-L, Uni-L, Str-L, *Clash} > *Al-L because (1)0(02)0 >> 0(01)(2)0 { Al-L, FtBin, Uni-L, Uni-R, Str-L, *Clash} > *Al-L because (1)0(02)0 >> 0(1)(2)(2)0 { Al-L, *Al-R, Parse-2, Uni-L, Str-L} > *Al-L because (1)0(02)0 >> 00(1)(02) ------------------------------------------------------------------------------ OUTPUT SET #38: /2/ --> >(1)0 /3/ --> >(1)00 /4/ --> >0(01)0 /5/ --> >0(01)00 Stratum #1 *Align-R [= *Al-R] Unary-L [= Uni-L] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] Stress-R [= Str-R] Stratum #3 Align-L [= Al-L] Stress-L [= Str-L] Stratum #4 *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] FtBin [= FtBin] Unary-R [= Uni-R] 38.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)00], not *[(01)000]: *Al-L >> *Lps, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-L >> Prs, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-L >> Parse-2, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-L >> Str-L, because /5/ --> [0(01)00], not *[(1)(02)00]: *Al-R >> Al-R, because /5/ --> [0(01)00], not *[000(01)]: *Al-R >> *Al-L, because /3/ --> [(1)00], not *[0(01)]: *Al-R >> *Lps, because /5/ --> [0(01)00], not *[0(01)(02)]: *Al-R >> Prs, because /5/ --> [0(01)00], not *[0(01)(02)]: *Al-R >> Parse-2, because /5/ --> [0(01)00], not *[0(01)(02)]: *Al-R >> Str-R, because /5/ --> [0(01)00], not *[000(01)]: Uni-L >> *Al-L, because /3/ --> [(1)00], not *[0(1)0]: Uni-L >> *Lps, because /5/ --> [0(01)00], not *[0(1)0(2)0]: Uni-L >> Prs, because /5/ --> [0(01)00], not *[0(1)(02)0]: Uni-L >> Parse-2, because /5/ --> [0(01)00], not *[0(1)0(2)0]: Str-L >> *Lps, because /3/ --> [(1)00], not *[(01)0]: Str-L >> Prs, because /3/ --> [(1)00], not *[(01)0]: Str-L >> Parse-2, because /3/ --> [(1)00], not *[(01)0]: Str-L >> FtBin, because /3/ --> [(1)00], not *[(01)0]: Str-L >> Uni-R, because /3/ --> [(1)00], not *[(01)0]: Arguments Derived from Transitivity of Domination *Al-L >> FtBin *Al-L >> Uni-R *Al-R >> Al-L *Al-R >> FtBin *Al-R >> Uni-R *Al-R >> Str-L Uni-L >> Al-L Uni-L >> FtBin Uni-L >> Uni-R Uni-L >> Str-L There were no irreducible set arguments. ------------------------------------------------------------------------------ OUTPUT SET #39: /2/ --> >(1)0 /3/ --> >(1)00 /4/ --> >0(01)0 /5/ --> >00(01)0 Stratum #1 *Align-R [= *Al-R] Unary-L [= Uni-L] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] Stress-R [= Str-R] Stratum #3 Align-L [= Al-L] Stress-L [= Str-L] Stratum #4 *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] FtBin [= FtBin] Unary-R [= Uni-R] 39.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [00(01)0], not *[(01)000]: *Al-L >> *Lps, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-L >> Prs, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-L >> Parse-2, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-L >> Str-L, because /5/ --> [00(01)0], not *[(1)(02)00]: *Al-R >> Al-R, because /5/ --> [00(01)0], not *[000(01)]: *Al-R >> *Al-L, because /3/ --> [(1)00], not *[0(01)]: *Al-R >> *Lps, because /5/ --> [00(01)0], not *[0(01)(02)]: *Al-R >> Prs, because /5/ --> [00(01)0], not *[0(01)(02)]: *Al-R >> Parse-2, because /5/ --> [00(01)0], not *[0(01)(02)]: *Al-R >> Str-R, because /5/ --> [00(01)0], not *[000(01)]: Uni-L >> *Al-L, because /3/ --> [(1)00], not *[0(1)0]: Uni-L >> *Lps, because /5/ --> [00(01)0], not *[0(1)0(2)0]: Uni-L >> Prs, because /5/ --> [00(01)0], not *[0(1)(02)0]: Uni-L >> Parse-2, because /5/ --> [00(01)0], not *[0(1)0(2)0]: Str-L >> *Lps, because /3/ --> [(1)00], not *[(01)0]: Str-L >> Prs, because /3/ --> [(1)00], not *[(01)0]: Str-L >> Parse-2, because /3/ --> [(1)00], not *[(01)0]: Str-L >> FtBin, because /3/ --> [(1)00], not *[(01)0]: Str-L >> Uni-R, because /3/ --> [(1)00], not *[(01)0]: Arguments Derived from Transitivity of Domination *Al-L >> FtBin *Al-L >> Uni-R *Al-R >> Al-L *Al-R >> FtBin *Al-R >> Uni-R *Al-R >> Str-L Uni-L >> Al-L Uni-L >> FtBin Uni-L >> Uni-R Uni-L >> Str-L There were no irreducible set arguments. ------------------------------------------------------------------------------ OUTPUT SET #40: /2/ --> >(1)0 /3/ --> >(1)00 /4/ --> >(1)(02)0 /5/ --> >(1)0(02)0 Stratum #1 Align-L [= Al-L] *Align-R [= *Al-R] Unary-L [= Uni-L] Stress-L [= Str-L] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] FtBin [= FtBin] Unary-R [= Uni-R] Stress-R [= Str-R] 40.1. Ranking Arguments Direct Pairwise Arguments *Al-R >> Al-R, because /5/ --> [(1)0(02)0], not *[(1)00(02)]: *Al-R >> *Lps, because /5/ --> [(1)0(02)0], not *[(1)(02)(02)]: *Al-R >> Prs, because /5/ --> [(1)0(02)0], not *[(1)(02)(02)]: *Al-R >> Parse-2, because /3/ --> [(1)00], not *[(1)(02)]: *Al-R >> Str-R, because /5/ --> [(1)0(02)0], not *[(1)00(02)]: Str-L >> *Lps, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: Str-L >> Prs, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: Str-L >> Parse-2, because /3/ --> [(1)00], not *[(01)0]: Str-L >> FtBin, because /5/ --> [(1)0(02)0], not *[(01)000]: Str-L >> Uni-R, because /5/ --> [(1)0(02)0], not *[(01)000]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { FtBin, Uni-L, Uni-R, *Clash} > *Lps because (1)00 >> (1)(2)0 { FtBin, Uni-L, Uni-R, *Clash} > Parse-2 because (1)00 >> (1)(2)0 { Al-L, Uni-L, Str-L} > *Al-L because (1)00 >> 0(1)0 { Al-L, *Lps, Prs, Str-L} > *Al-L because (1)(02)0 >> 0(01)0 { Al-L, *Al-R, Str-L} > *Al-L because (1)0(02)0 >> 0(01)(02) { Al-L, *Lps, Prs, Parse-2, Str-L} > *Al-L because (1)0(02)0 >> 00(01)0 { FtBin, Uni-L, Uni-R, *Clash} > Prs because (1)0(02)0 >> (1)(2)(02)0 { FtBin, Uni-L, Uni-R, *Clash} > *Lps because (1)0(02)0 >> (1)0(2)(2)0 { Al-L, *Al-R, FtBin, Uni-L, Uni-R, Str-L, *Clash} > *Al-L because (1)0(02)0 >> 0(1)(2)(02) { Al-L, Prs, FtBin, Uni-L, Uni-R, Str-L} > *Al-L because (1)0(02)0 >> 0(1)0(2)0 { Al-L, *Al-R, Parse-2, Uni-L, Str-L} > *Al-L because (1)0(02)0 >> 00(1)(02) ------------------------------------------------------------------------------ OUTPUT SET #41: /2/ --> >(1)0 /3/ --> >0(1)0 /4/ --> >0(01)0 /5/ --> >0(01)00 Stratum #1 *Align-R [= *Al-R] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] Stress-R [= Str-R] Stratum #3 Align-L [= Al-L] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] Stress-L [= Str-L] Stratum #4 *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] 41.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)00], not *[(1)0000]: *Al-L >> *Lps, because /5/ --> [0(01)00], not *[(1)00(2)0]: *Al-L >> Prs, because /5/ --> [0(01)00], not *[(1)(02)00]: *Al-L >> Parse-2, because /5/ --> [0(01)00], not *[(01)0(2)0]: *Al-L >> FtBin, because /3/ --> [0(1)0], not *[(01)0]: *Al-L >> Uni-L, because /3/ --> [0(1)0], not *[(1)00]: *Al-L >> Uni-R, because /3/ --> [0(1)0], not *[(01)0]: *Al-L >> Str-L, because /5/ --> [0(01)00], not *[(1)0000]: *Al-R >> Al-R, because /5/ --> [0(01)00], not *[0000(1)]: *Al-R >> *Al-L, because /2/ --> [(1)0], not *[0(1)]: *Al-R >> *Lps, because /5/ --> [0(01)00], not *[00(1)0(2)]: *Al-R >> Prs, because /5/ --> [0(01)00], not *[00(1)(02)]: *Al-R >> Parse-2, because /5/ --> [0(01)00], not *[0(1)0(02)]: *Al-R >> FtBin, because /3/ --> [0(1)0], not *[0(01)]: *Al-R >> Uni-L, because /3/ --> [0(1)0], not *[0(01)]: *Al-R >> Uni-R, because /3/ --> [0(1)0], not *[00(1)]: *Al-R >> Str-R, because /5/ --> [0(01)00], not *[0000(1)]: Arguments Derived from Transitivity of Domination *Al-R >> Al-L *Al-R >> Str-L Irreducible Set Arguments { FtBin, Uni-L, Uni-R} > Prs because 0(01)00 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Parse-2 because 0(01)00 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R, *Clash} > Parse-2 because 0(01)00 >> 0(1)(2)(2)0 { FtBin, Uni-L, Uni-R} > *Lps because 0(01)00 >> 0(1)0(2)0 ------------------------------------------------------------------------------ OUTPUT SET #42: /2/ --> >(1)0 /3/ --> >0(1)0 /4/ --> >0(01)0 /5/ --> >00(01)0 Stratum #1 *Align-R [= *Al-R] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] Stress-R [= Str-R] Stratum #3 Align-L [= Al-L] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] Stress-L [= Str-L] Stratum #4 *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] 42.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [00(01)0], not *[(1)0000]: *Al-L >> *Lps, because /5/ --> [00(01)0], not *[(1)00(2)0]: *Al-L >> Prs, because /5/ --> [00(01)0], not *[(1)(02)00]: *Al-L >> Parse-2, because /5/ --> [00(01)0], not *[(01)0(2)0]: *Al-L >> FtBin, because /3/ --> [0(1)0], not *[(01)0]: *Al-L >> Uni-L, because /3/ --> [0(1)0], not *[(1)00]: *Al-L >> Uni-R, because /3/ --> [0(1)0], not *[(01)0]: *Al-L >> Str-L, because /5/ --> [00(01)0], not *[(1)0000]: *Al-R >> Al-R, because /5/ --> [00(01)0], not *[0000(1)]: *Al-R >> *Al-L, because /2/ --> [(1)0], not *[0(1)]: *Al-R >> *Lps, because /5/ --> [00(01)0], not *[00(1)0(2)]: *Al-R >> Prs, because /5/ --> [00(01)0], not *[00(1)(02)]: *Al-R >> Parse-2, because /5/ --> [00(01)0], not *[0(1)0(02)]: *Al-R >> FtBin, because /3/ --> [0(1)0], not *[0(01)]: *Al-R >> Uni-L, because /3/ --> [0(1)0], not *[0(01)]: *Al-R >> Uni-R, because /3/ --> [0(1)0], not *[00(1)]: *Al-R >> Str-R, because /5/ --> [00(01)0], not *[0000(1)]: Arguments Derived from Transitivity of Domination *Al-R >> Al-L *Al-R >> Str-L Irreducible Set Arguments { FtBin, Uni-L, Uni-R} > Prs because 00(01)0 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Parse-2 because 00(01)0 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R, *Clash} > Parse-2 because 00(01)0 >> 0(1)(2)(2)0 { FtBin, Uni-L, Uni-R} > *Lps because 00(01)0 >> 0(1)0(2)0 ------------------------------------------------------------------------------ OUTPUT SET #43: /2/ --> >(1)0 /3/ --> >0(1)0 /4/ --> >0(01)0 /5/ --> >0(1)(02)0 Stratum #1 *Align-R [= *Al-R] Prs-2 [= Parse-2] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] Stress-R [= Str-R] Stratum #3 Align-L [= Al-L] *Lapse [= *Lps] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] Stress-L [= Str-L] 43.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(1)(02)0], not *[(1)0(02)0]: *Al-L >> *Lps, because /4/ --> [0(01)0], not *[(1)0(2)0]: *Al-L >> Prs, because /4/ --> [0(01)0], not *[(1)(02)0]: *Al-L >> FtBin, because /5/ --> [0(1)(02)0], not *[(01)(02)0]: *Al-L >> Uni-L, because /5/ --> [0(1)(02)0], not *[(1)0(02)0]: *Al-L >> Uni-R, because /5/ --> [0(1)(02)0], not *[(01)(02)0]: *Al-L >> Str-L, because /5/ --> [0(1)(02)0], not *[(1)0(02)0]: *Al-R >> Al-R, because /5/ --> [0(1)(02)0], not *[(1)(02)(02)]: *Al-R >> *Al-L, because /2/ --> [(1)0], not *[0(1)]: *Al-R >> *Lps, because /4/ --> [0(01)0], not *[0(1)0(2)]: *Al-R >> Prs, because /5/ --> [0(1)(02)0], not *[0(01)(02)]: *Al-R >> FtBin, because /5/ --> [0(1)(02)0], not *[0(01)(02)]: *Al-R >> Uni-L, because /5/ --> [0(1)(02)0], not *[0(01)(02)]: *Al-R >> Uni-R, because /5/ --> [0(1)(02)0], not *[0(01)0(2)]: *Al-R >> Str-R, because /5/ --> [0(1)(02)0], not *[(1)(02)(02)]: Arguments Derived from Transitivity of Domination *Al-R >> Al-L *Al-R >> Str-L Irreducible Set Arguments { FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)0 >> 0(1)(2)0 { *Lps, Prs, Parse-2} > FtBin because 0(1)(02)0 >> 0(01)00 { *Lps, Prs, Parse-2} > Uni-L because 0(1)(02)0 >> 0(01)00 { *Lps, Prs, Parse-2} > Uni-R because 0(1)(02)0 >> 0(01)00 ------------------------------------------------------------------------------ OUTPUT SET #44: /2/ --> >(1)0 /3/ --> >0(1)0 /4/ --> >(1)(02)0 /5/ --> >(1)0(02)0 Stratum #1 *Align-R [= *Al-R] Prs-2 [= Parse-2] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] Stress-L [= Str-L] Stress-R [= Str-R] Stratum #3 *Align-L [= *Al-L] *Lapse [= *Lps] Stratum #4 Align-L [= Al-L] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] 44.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /3/ --> [0(1)0], not *[(01)0]: *Al-L >> Prs, because /3/ --> [0(1)0], not *[(01)0]: *Al-L >> FtBin, because /3/ --> [0(1)0], not *[(01)0]: *Al-L >> Uni-L, because /3/ --> [0(1)0], not *[(01)0]: *Al-L >> Uni-R, because /3/ --> [0(1)0], not *[(01)0]: *Al-R >> Al-R, because /5/ --> [(1)0(02)0], not *[(1)0(2)0(2)]: *Al-R >> *Lps, because /5/ --> [(1)0(02)0], not *[(1)0(2)0(2)]: *Al-R >> Prs, because /5/ --> [(1)0(02)0], not *[(1)0(2)(02)]: *Al-R >> FtBin, because /3/ --> [0(1)0], not *[0(01)]: *Al-R >> Uni-L, because /3/ --> [0(1)0], not *[0(01)]: *Al-R >> Uni-R, because /3/ --> [0(1)0], not *[0(01)]: *Al-R >> Str-L, because /3/ --> [0(1)0], not *[(1)0(2)]: *Al-R >> Str-R, because /5/ --> [(1)0(02)0], not *[(1)0(2)0(2)]: Parse-2 >> Str-L, because /3/ --> [0(1)0], not *[(1)00]: Str-L >> *Al-L, because /4/ --> [(1)(02)0], not *[0(01)0]: Str-L >> *Lps, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: Str-L >> Prs, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: Str-L >> FtBin, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: Str-L >> Uni-R, because /5/ --> [(1)0(02)0], not *[(01)(02)0]: *Clash >> *Lps, because /5/ --> [(1)0(02)0], not *[(1)0(2)(2)0]: *Clash >> Prs, because /5/ --> [(1)0(02)0], not *[(1)(2)(2)(2)0]: *Clash >> Str-L, because /3/ --> [0(1)0], not *[(1)(2)0]: Arguments Derived from Transitivity of Domination *Al-R >> Al-L *Al-R >> *Al-L Parse-2 >> Al-L Parse-2 >> *Al-L Parse-2 >> *Lps Parse-2 >> Prs Parse-2 >> FtBin Parse-2 >> Uni-L Parse-2 >> Uni-R Str-L >> Al-L Str-L >> Uni-L *Clash >> Al-L *Clash >> *Al-L *Clash >> FtBin *Clash >> Uni-L *Clash >> Uni-R There were no irreducible set arguments. ------------------------------------------------------------------------------ OUTPUT SET #45: /2/ --> >(1)0 /3/ --> >0(1)0 /4/ --> >(1)(02)0 /5/ --> >0(1)(02)0 Stratum #1 *Align-R [= *Al-R] *Lapse [= *Lps] Prs-2 [= Parse-2] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] Stress-L [= Str-L] Stress-R [= Str-R] Stratum #3 Align-L [= Al-L] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] 45.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(1)(02)0], not *[(01)0(2)0]: *Al-L >> Prs, because /5/ --> [0(1)(02)0], not *[(01)(02)0]: *Al-L >> FtBin, because /5/ --> [0(1)(02)0], not *[(01)(02)0]: *Al-L >> Uni-L, because /5/ --> [0(1)(02)0], not *[(01)(02)0]: *Al-L >> Uni-R, because /5/ --> [0(1)(02)0], not *[(01)(02)0]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { *Al-R, Str-L} > Al-R because (1)0 >> (01) { *Al-R, Str-L} > Prs because (1)0 >> (01) { *Al-R, Str-L} > FtBin because (1)0 >> (01) { *Al-R, Str-L} > Uni-R because (1)0 >> (01) { *Al-R, Str-L} > Str-R because (1)0 >> (01) { *Al-R, FtBin, Uni-L, *Clash} > Al-R because (1)0 >> (1)(2) { *Al-R, FtBin, Uni-L, *Clash} > Prs because (1)0 >> (1)(2) { *Al-R, FtBin, Uni-L, *Clash} > Str-R because (1)0 >> (1)(2) { *Al-R, *Lps} > Al-R because 0(1)0 >> 0(01) { *Al-R, *Lps} > Prs because 0(1)0 >> 0(01) { *Al-R, *Lps} > FtBin because 0(1)0 >> 0(01) { *Al-R, *Lps} > Uni-L because 0(1)0 >> 0(01) { *Al-R, *Lps} > Uni-R because 0(1)0 >> 0(01) { *Al-L, *Al-R} > Al-R because 0(1)0 >> (1)(02) { *Al-L, *Al-R} > Str-L because 0(1)0 >> (1)(02) { *Al-L, FtBin, Uni-R, *Clash} > Str-L because 0(1)0 >> (1)(2)0 { *Al-L, *Al-R, FtBin} > Al-R because 0(1)0 >> (1)0(2) { *Lps, Str-L} > *Al-L because (1)(02)0 >> 0(01)0 { Al-L, *Lps, Prs, Str-L} > FtBin because (1)(02)0 >> 0(01)0 { Al-L, *Lps, Prs, Str-L} > Uni-R because (1)(02)0 >> 0(01)0 { Str-L, *Clash} > *Al-L because (1)(02)0 >> 0(1)(2)0 { *Al-R, Uni-L, Str-L} > Str-R because (1)(02)0 >> (01)0(2) { *Al-R, FtBin, Uni-L, Uni-R, *Clash} > Str-R because (1)(02)0 >> (1)(2)(2)(2) { *Al-R, Str-L} > *Al-L because (1)(02)0 >> 0(1)0(2) { *Lps, Parse-2, Str-L} > *Al-L because (1)(02)0 >> 00(1)0 { *Al-R, *Lps} > Str-R because 0(1)(02)0 >> 0(01)(02) { *Lps, Prs, Parse-2} > Uni-L because 0(1)(02)0 >> 0(01)00 { *Lps, Prs, Parse-2} > FtBin because 0(1)(02)0 >> 00(01)0 { *Lps, Prs, Parse-2} > Uni-R because 0(1)(02)0 >> 00(01)0 { *Al-L, *Al-R} > Al-R because 0(1)(02)0 >> (1)(02)(02) { *Al-L, *Al-R} > Str-R because 0(1)(02)0 >> (1)(02)(02) { *Al-L, FtBin, Uni-R, *Clash} > Str-L because 0(1)(02)0 >> (1)(2)(02)0 { *Al-L, *Lps} > Str-L because 0(1)(02)0 >> (1)0(02)0 { *Al-L, *Al-R, FtBin} > Str-R because 0(1)(02)0 >> (1)(02)0(2) { *Al-L, *Al-R, FtBin, Uni-L, Uni-R, *Clash} > Str-L because 0(1)(02)0 >> (1)(2)0(2)(2) { *Al-L, *Al-R, FtBin, Uni-L, Uni-R} > Str-R because 0(1)(02)0 >> (1)0(2)0(2) { *Al-L, *Lps, Prs, Parse-2, FtBin, Uni-R} > Str-L because 0(1)(02)0 >> (1)00(2)0 { *Al-R, *Lps, Parse-2} > Str-R because 0(1)(02)0 >> 00(1)(02) { *Al-R, *Lps, Prs, Parse-2} > Str-R because 0(1)(02)0 >> 000(01) ------------------------------------------------------------------------------ OUTPUT SET #46: /2/ --> >(1)0 /3/ --> >0(1)0 /4/ --> >0(1)(2)0 /5/ --> >0(1)(02)0 Stratum #1 *Align-R [= *Al-R] *Lapse [= *Lps] Prs-2 [= Parse-2] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] Stress-R [= Str-R] Stratum #3 Align-L [= Al-L] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] Stress-L [= Str-L] *Clash [= *Clash] 46.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(1)(02)0], not *[(1)0(2)(2)0]: *Al-L >> Prs, because /5/ --> [0(1)(02)0], not *[(1)(2)(2)(2)0]: *Al-L >> FtBin, because /5/ --> [0(1)(02)0], not *[(01)(02)0]: *Al-L >> Uni-L, because /5/ --> [0(1)(02)0], not *[(01)(02)0]: *Al-L >> Uni-R, because /5/ --> [0(1)(02)0], not *[(01)(02)0]: *Al-L >> Str-L, because /5/ --> [0(1)(02)0], not *[(1)0(2)(2)0]: *Al-L >> *Clash, because /4/ --> [0(1)(2)0], not *[(1)0(2)0]: *Al-R >> Al-R, because /5/ --> [0(1)(02)0], not *[0(1)0(2)(2)]: *Al-R >> *Al-L, because /2/ --> [(1)0], not *[0(1)]: *Al-R >> Prs, because /5/ --> [0(1)(02)0], not *[0(1)(2)(2)(2)]: *Al-R >> FtBin, because /4/ --> [0(1)(2)0], not *[0(1)(02)]: *Al-R >> Uni-L, because /4/ --> [0(1)(2)0], not *[0(1)(02)]: *Al-R >> Uni-R, because /4/ --> [0(1)(2)0], not *[0(1)0(2)]: *Al-R >> Str-R, because /5/ --> [0(1)(02)0], not *[0(1)0(2)(2)]: *Al-R >> *Clash, because /4/ --> [0(1)(2)0], not *[0(1)0(2)]: *Lps >> FtBin, because /4/ --> [0(1)(2)0], not *[0(01)0]: *Lps >> Uni-L, because /4/ --> [0(1)(2)0], not *[0(01)0]: *Lps >> Uni-R, because /4/ --> [0(1)(2)0], not *[0(01)0]: *Lps >> *Clash, because /4/ --> [0(1)(2)0], not *[0(01)0]: Arguments Derived from Transitivity of Domination *Al-R >> Al-L *Al-R >> Str-L There were no irreducible set arguments. ------------------------------------------------------------------------------ OUTPUT SET #47: /2/ --> >0(1) (actual) /3/ --> >(01)0 /4/ --> >(01)(02) /5/ --> >(01)(02)0 Stratum #1 *Lapse [= *Lps] Prs-2 [= Parse-2] Unary-R [= Uni-R] *Clash [= *Clash] Stratum #2 Align-R [= Al-R] *Align-L [= *Al-L] *Align-R [= *Al-R] Stress-L [= Str-L] Stress-R [= Str-R] Stratum #3 Align-L [= Al-L] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] 47.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /2/ --> [0(1)], not *[(01)]: *Al-L >> Prs, because /2/ --> [0(1)], not *[(01)]: *Al-L >> FtBin, because /2/ --> [0(1)], not *[(01)]: *Al-L >> Uni-L, because /2/ --> [0(1)], not *[(01)]: Uni-R >> *Al-L, because /5/ --> [(01)(02)0], not *[0(1)0(2)0]: Arguments Derived from Transitivity of Domination Uni-R >> Al-L Uni-R >> Prs Uni-R >> FtBin Uni-R >> Uni-L Irreducible Set Arguments { *Al-L, FtBin, Uni-R, *Clash} > Str-L because 0(1) >> (1)(2) { Al-R, *Al-L, Uni-R, Str-R} > *Al-R because 0(1) >> (1)0 { Al-R, *Al-L, Uni-R, Str-R} > Str-L because 0(1) >> (1)0 { *Al-R, *Lps} > *Al-L because (01)0 >> 0(01) { *Al-R, FtBin, Uni-L, *Clash} > Al-R because (01)0 >> (01)(2) { *Al-R, FtBin, Uni-L, *Clash} > Prs because (01)0 >> (01)(2) { *Al-R, FtBin, Uni-L, *Clash} > Str-R because (01)0 >> (01)(2) { *Al-R, FtBin, Uni-R} > Al-R because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-R} > Str-L because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-R} > Str-R because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-L, Uni-R} > Str-L because (01)0 >> (1)0(2) { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because (01)(02) >> (01)00 { Al-R, *Lps, Str-R} > *Al-L because (01)(02) >> 0(01)0 { Al-L, Al-R, *Lps, Prs, Str-R} > *Al-R because (01)(02) >> 0(01)0 { Al-R, Prs, FtBin, Uni-R, Str-R} > *Al-R because (01)(02) >> (1)(02)0 { Al-R, Prs, FtBin, Uni-R, Str-R} > Str-L because (01)(02) >> (1)(02)0 { *Lps, Prs, FtBin, Uni-R} > Str-L because (01)(02) >> (1)0(02) { *Lps, *Clash} > *Al-L because (01)(02) >> 0(01)(2) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because (01)(02) >> (01)(2)0 { *Al-R, *Lps} > Al-R because (01)(02)0 >> (01)0(02) { *Al-R, *Lps} > Str-R because (01)(02)0 >> (01)0(02) { *Lps, Parse-2} > *Al-L because (01)(02)0 >> 00(01)0 { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)(02)0 >> (1)(2)(02)0 { *Lps, Prs, FtBin, Uni-R} > Str-L because (01)(02)0 >> (1)0(02)0 { *Al-R, FtBin, Uni-L, Uni-R, *Clash} > Str-R because (01)(02)0 >> (01)(2)0(2) { *Al-R, *Lps, Prs, Parse-2, FtBin, Uni-L} > Al-R because (01)(02)0 >> (01)00(2) { *Al-R, *Lps, Prs, Parse-2, FtBin, Uni-L} > Str-R because (01)(02)0 >> (01)00(2) { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)(02)0 >> (1)(2)(2)(2)0 { *Al-R, FtBin, Uni-L, Uni-R} > Str-L because (01)(02)0 >> (1)0(2)(02) { Al-L, *Al-R, *Lps, Prs, FtBin, Uni-L} > Str-R because (01)(02)0 >> 0(01)0(2) { Al-L, *Al-R, *Lps, Prs, Parse-2} > Str-R because (01)(02)0 >> 000(01) ------------------------------------------------------------------------------ OUTPUT SET #48: /2/ --> >0(1) (actual) /3/ --> >(01)0 /4/ --> >0(01)0 /5/ --> >(01)(02)0 Stratum #1 Prs-2 [= Parse-2] Unary-R [= Uni-R] *Clash [= *Clash] Stratum #2 *Align-R [= *Al-R] Stress-L [= Str-L] Stratum #3 Align-R [= Al-R] *Align-L [= *Al-L] *Lapse [= *Lps] Stress-R [= Str-R] Stratum #4 Align-L [= Al-L] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] 48.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /2/ --> [0(1)], not *[(01)]: *Al-L >> Prs, because /2/ --> [0(1)], not *[(01)]: *Al-L >> FtBin, because /2/ --> [0(1)], not *[(01)]: *Al-L >> Uni-L, because /2/ --> [0(1)], not *[(01)]: Uni-R >> *Al-L, because /5/ --> [(01)(02)0], not *[0(1)0(2)0]: Uni-R >> *Lps, because /4/ --> [0(01)0], not *[(1)0(2)0]: Uni-R >> Str-L, because /5/ --> [(01)(02)0], not *[(1)0(02)0]: Arguments Derived from Transitivity of Domination Uni-R >> Al-L Uni-R >> Prs Uni-R >> FtBin Uni-R >> Uni-L Irreducible Set Arguments { Al-R, *Al-L, Uni-R, Str-R} > *Al-R because 0(1) >> (1)0 { Al-L, *Al-R, *Lps} > Al-R because (01)0 >> 0(01) { *Al-R, *Lps} > *Al-L because (01)0 >> 0(01) { Al-L, *Al-R, *Lps} > Str-R because (01)0 >> 0(01) { *Al-R, FtBin, Uni-L, *Clash} > Al-R because (01)0 >> (01)(2) { *Al-R, FtBin, Uni-L, *Clash} > Prs because (01)0 >> (01)(2) { *Al-R, FtBin, Uni-L, *Clash} > Str-R because (01)0 >> (01)(2) { *Al-R, FtBin, Uni-R} > Al-R because (01)0 >> (1)(02) { *Al-R, FtBin, Uni-R} > Str-R because (01)0 >> (1)(02) { *Al-L, *Al-R} > Al-R because 0(01)0 >> (01)(02) { *Al-L, *Al-R} > *Lps because 0(01)0 >> (01)(02) { *Al-L, *Al-R} > Str-R because 0(01)0 >> (01)(02) { *Al-R, *Lps, Parse-2} > Str-R because 0(01)0 >> 00(01) { *Al-R, FtBin, Uni-L, Uni-R} > Str-R because 0(01)0 >> 0(1)0(2) { *Al-R, *Lps} > Al-R because (01)(02)0 >> (01)0(02) { *Al-R, *Lps} > Str-R because (01)(02)0 >> (01)0(02) { *Lps, Parse-2} > *Al-L because (01)(02)0 >> 0(01)00 { *Al-R, FtBin, Uni-L, Uni-R, *Clash} > Str-R because (01)(02)0 >> (1)(2)0(2)(2) { Al-L, *Al-R, *Lps, Prs, Parse-2, FtBin, Uni-L} > Str-R because (01)(02)0 >> 0000(1) ------------------------------------------------------------------------------ OUTPUT SET #49: /2/ --> >0(1) (actual) /3/ --> >(01)0 /4/ --> >0(01)0 /5/ --> >0(01)00 Stratum #1 Unary-R [= Uni-R] *Clash [= *Clash] Stratum #2 *Align-R [= *Al-R] Stress-L [= Str-L] Stratum #3 Align-R [= Al-R] *Align-L [= *Al-L] Stress-R [= Str-R] Stratum #4 Align-L [= Al-L] *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] FtBin [= FtBin] Unary-L [= Uni-L] 49.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)00], not *[(01)000]: *Al-L >> *Lps, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-L >> Prs, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-L >> Parse-2, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-L >> FtBin, because /2/ --> [0(1)], not *[(01)]: *Al-L >> Uni-L, because /2/ --> [0(1)], not *[(01)]: *Al-R >> Al-L, because /5/ --> [0(01)00], not *[(01)0(02)]: *Al-R >> Al-R, because /5/ --> [0(01)00], not *[000(01)]: *Al-R >> *Al-L, because /3/ --> [(01)0], not *[0(01)]: *Al-R >> *Lps, because /5/ --> [0(01)00], not *[(01)0(02)]: *Al-R >> Prs, because /5/ --> [0(01)00], not *[(01)0(02)]: *Al-R >> Parse-2, because /5/ --> [0(01)00], not *[(01)0(02)]: *Al-R >> Str-R, because /5/ --> [0(01)00], not *[000(01)]: Uni-R >> *Al-L, because /3/ --> [(01)0], not *[0(1)0]: Uni-R >> *Al-R, because /2/ --> [0(1)], not *[(1)0]: Uni-R >> *Lps, because /5/ --> [0(01)00], not *[0(1)0(2)0]: Uni-R >> Prs, because /5/ --> [0(01)00], not *[0(1)(02)0]: Uni-R >> Parse-2, because /5/ --> [0(01)00], not *[0(1)0(2)0]: Uni-R >> Str-L, because /5/ --> [0(01)00], not *[(1)0000]: Arguments Derived from Transitivity of Domination *Al-R >> FtBin *Al-R >> Uni-L Uni-R >> Al-L Uni-R >> Al-R Uni-R >> FtBin Uni-R >> Uni-L Uni-R >> Str-R There were no irreducible set arguments. ------------------------------------------------------------------------------ OUTPUT SET #50: /2/ --> >0(1) (actual) /3/ --> >(01)0 /4/ --> >0(01)0 /5/ --> >00(01)0 Stratum #1 Unary-R [= Uni-R] *Clash [= *Clash] Stratum #2 *Align-R [= *Al-R] Stress-L [= Str-L] Stratum #3 Align-R [= Al-R] *Align-L [= *Al-L] Stress-R [= Str-R] Stratum #4 Align-L [= Al-L] *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] FtBin [= FtBin] Unary-L [= Uni-L] 50.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [00(01)0], not *[(01)000]: *Al-L >> *Lps, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-L >> Prs, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-L >> Parse-2, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-L >> FtBin, because /2/ --> [0(1)], not *[(01)]: *Al-L >> Uni-L, because /2/ --> [0(1)], not *[(01)]: *Al-R >> Al-L, because /5/ --> [00(01)0], not *[(01)0(02)]: *Al-R >> Al-R, because /5/ --> [00(01)0], not *[000(01)]: *Al-R >> *Al-L, because /3/ --> [(01)0], not *[0(01)]: *Al-R >> *Lps, because /5/ --> [00(01)0], not *[(01)0(02)]: *Al-R >> Prs, because /5/ --> [00(01)0], not *[(01)0(02)]: *Al-R >> Parse-2, because /5/ --> [00(01)0], not *[(01)0(02)]: *Al-R >> Str-R, because /5/ --> [00(01)0], not *[000(01)]: Uni-R >> *Al-L, because /3/ --> [(01)0], not *[0(1)0]: Uni-R >> *Al-R, because /2/ --> [0(1)], not *[(1)0]: Uni-R >> *Lps, because /5/ --> [00(01)0], not *[0(1)0(2)0]: Uni-R >> Prs, because /5/ --> [00(01)0], not *[0(1)(02)0]: Uni-R >> Parse-2, because /5/ --> [00(01)0], not *[0(1)0(2)0]: Uni-R >> Str-L, because /5/ --> [00(01)0], not *[(1)0000]: Arguments Derived from Transitivity of Domination *Al-R >> FtBin *Al-R >> Uni-L Uni-R >> Al-L Uni-R >> Al-R Uni-R >> FtBin Uni-R >> Uni-L Uni-R >> Str-R There were no irreducible set arguments. ------------------------------------------------------------------------------ OUTPUT SET #51: /2/ --> >0(1) (actual) /3/ --> >0(01) /4/ --> >(01)(02) /5/ --> >0(01)(02) Stratum #1 Align-R [= Al-R] Prs-2 [= Parse-2] Unary-R [= Uni-R] Stress-R [= Str-R] *Clash [= *Clash] Stratum #2 *Align-L [= *Al-L] *Align-R [= *Al-R] *Lapse [= *Lps] Stress-L [= Str-L] Stratum #3 Align-L [= Al-L] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] 51.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)(02)], not *[(01)0(02)]: *Al-L >> Prs, because /2/ --> [0(1)], not *[(01)]: *Al-L >> FtBin, because /2/ --> [0(1)], not *[(01)]: *Al-L >> Uni-L, because /2/ --> [0(1)], not *[(01)]: Uni-R >> *Al-L, because /4/ --> [(01)(02)], not *[0(1)0(2)]: Uni-R >> *Lps, because /5/ --> [0(01)(02)], not *[(1)0(2)0(2)]: Uni-R >> Str-L, because /5/ --> [0(01)(02)], not *[(1)0(2)0(2)]: Arguments Derived from Transitivity of Domination Uni-R >> Al-L Uni-R >> Prs Uni-R >> FtBin Uni-R >> Uni-L Irreducible Set Arguments { Al-R, *Al-L, Str-R} > *Lps because 0(01) >> (01)0 { *Al-L, FtBin, Uni-L, *Clash} > *Lps because 0(01) >> (01)(2) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because 0(01) >> 0(1)0 { Al-R, *Lps, Str-R} > *Al-L because (01)(02) >> 0(01)0 { Al-L, Al-R, *Lps, Prs, Str-R} > *Al-R because (01)(02) >> 0(01)0 { *Lps, Parse-2} > *Al-L because (01)(02) >> 00(01) { Al-R, Prs, FtBin, Uni-R, Str-R} > *Al-R because (01)(02) >> (1)(02)0 { *Lps, *Clash} > *Al-L because (01)(02) >> 0(01)(2) { Al-R, *Lps, Prs, Parse-2, FtBin, Uni-R, Str-R} > *Al-R because (01)(02) >> (1)000 { Al-R, *Al-L, Str-R} > *Al-R because 0(01)(02) >> (01)(02)0 { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because 0(01)(02) >> 00(01)0 { Al-R, *Al-L, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because 0(01)(02) >> (1)(2)(02)0 ------------------------------------------------------------------------------ OUTPUT SET #52: /2/ --> >0(1) (actual) /3/ --> >0(01) /4/ --> >0(01)0 /5/ --> >0(01)(02) Stratum #1 *Align-L [= *Al-L] Prs-2 [= Parse-2] Unary-R [= Uni-R] *Clash [= *Clash] Stratum #2 Align-L [= Al-L] Align-R [= Al-R] *Align-R [= *Al-R] *Lapse [= *Lps] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] Stress-L [= Str-L] Stress-R [= Str-R] 52.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)(02)], not *[(01)0(02)]: *Al-L >> Prs, because /2/ --> [0(1)], not *[(01)]: *Al-L >> FtBin, because /2/ --> [0(1)], not *[(01)]: *Al-L >> Uni-L, because /2/ --> [0(1)], not *[(01)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-R, *Al-L, Uni-R, Str-R} > Str-L because 0(1) >> (1)0 { Al-R, *Al-L, Str-R} > *Lps because 0(01) >> (01)0 { *Al-L, FtBin, Uni-L, *Clash} > *Lps because 0(01) >> (01)(2) { *Al-L, FtBin, Uni-R} > *Lps because 0(01) >> (1)(02) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Lps because 0(01) >> 0(1)0 { *Al-L, *Al-R} > Al-R because 0(01)0 >> (01)(02) { *Al-L, *Al-R} > *Lps because 0(01)0 >> (01)(02) { *Al-L, *Al-R} > Str-R because 0(01)0 >> (01)(02) { *Al-R, *Lps, Parse-2} > Al-R because 0(01)0 >> 00(01) { *Al-R, *Lps, Parse-2} > Str-R because 0(01)0 >> 00(01) { *Al-L, FtBin, Uni-R} > Str-L because 0(01)0 >> (1)(02)0 { *Al-L, *Al-R, FtBin, Uni-R} > Str-L because 0(01)0 >> (1)0(02) { *Al-R, FtBin, Uni-L, *Clash} > Al-R because 0(01)0 >> 0(01)(2) { *Al-R, FtBin, Uni-L, *Clash} > Prs because 0(01)0 >> 0(01)(2) { *Al-R, FtBin, Uni-L, *Clash} > Str-R because 0(01)0 >> 0(01)(2) { *Al-R, FtBin, Uni-L, Uni-R} > Al-R because 0(01)0 >> 0(1)(02) { *Al-R, FtBin, Uni-L, Uni-R} > *Lps because 0(01)0 >> 0(1)(02) { *Al-R, FtBin, Uni-L, Uni-R} > Prs because 0(01)0 >> 0(1)(02) { *Al-R, FtBin, Uni-L, Uni-R} > Str-R because 0(01)0 >> 0(1)(02) { *Al-L, *Al-R, FtBin, Uni-L} > Str-R because 0(01)0 >> (01)0(2) { *Al-L, *Lps, Prs, Parse-2, FtBin, Uni-R} > Str-L because 0(01)0 >> (1)000 { Al-R, *Al-L, Str-R} > *Al-R because 0(01)(02) >> (01)(02)0 { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because 0(01)(02) >> 0(01)00 { *Al-L, FtBin, Uni-R} > Str-L because 0(01)(02) >> (1)(02)(02) { *Al-L, FtBin, Uni-L, Uni-R, *Clash} > Str-L because 0(01)(02) >> (1)(2)0(02) { *Al-L, Prs, FtBin, Uni-L, Uni-R} > Str-L because 0(01)(02) >> (1)0(2)0(2) { FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)(02) >> 0(1)(2)(2)(2) { Prs, FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)(02) >> 0(1)(2)0(2) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because 0(01)(02) >> 0(1)0(2)0 { Al-R, Prs, Parse-2, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because 0(01)(02) >> 00(1)(2)0 ------------------------------------------------------------------------------ OUTPUT SET #53: /2/ --> >0(1) (actual) /3/ --> >0(01) /4/ --> >0(01)0 /5/ --> >0(01)00 Stratum #1 *Align-L [= *Al-L] Unary-R [= Uni-R] *Clash [= *Clash] Stratum #2 Align-L [= Al-L] *Align-R [= *Al-R] FtBin [= FtBin] Unary-L [= Uni-L] Stress-L [= Str-L] Stratum #3 Align-R [= Al-R] *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] Stress-R [= Str-R] 53.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)00], not *[(01)000]: *Al-L >> *Al-R, because /3/ --> [0(01)], not *[(01)0]: *Al-L >> *Lps, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-L >> Prs, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-L >> Parse-2, because /5/ --> [0(01)00], not *[(01)(02)0]: *Al-L >> FtBin, because /2/ --> [0(1)], not *[(01)]: *Al-L >> Uni-L, because /2/ --> [0(1)], not *[(01)]: *Al-R >> Al-R, because /5/ --> [0(01)00], not *[000(01)]: *Al-R >> *Lps, because /5/ --> [0(01)00], not *[0(01)(02)]: *Al-R >> Prs, because /5/ --> [0(01)00], not *[0(01)(02)]: *Al-R >> Parse-2, because /5/ --> [0(01)00], not *[0(01)(02)]: *Al-R >> Str-R, because /5/ --> [0(01)00], not *[000(01)]: Arguments Derived from Transitivity of Domination *Al-L >> Al-R *Al-L >> Str-R Irreducible Set Arguments { Al-R, *Al-L, Uni-R, Str-R} > Str-L because 0(1) >> (1)0 { FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01) >> 0(1)(2) { FtBin, Uni-L, Uni-R} > *Al-R because 0(01) >> 0(1)0 { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Lps because 0(01) >> 0(1)0 { *Al-L, FtBin, Uni-L, Uni-R} > Str-L because 0(01)0 >> (1)0(2)0 { *Al-L, *Lps, Prs, Parse-2, FtBin, Uni-R} > Str-L because 0(01)0 >> (1)000 { *Al-L, FtBin, Uni-R} > Str-L because 0(01)00 >> (1)0(02)0 { FtBin, Uni-L, Uni-R} > *Lps because 0(01)00 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Prs because 0(01)00 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Parse-2 because 0(01)00 >> 0(1)(02)0 { *Al-L, FtBin, Uni-R} > Str-L because 0(01)00 >> (1)(02)00 { *Al-L, FtBin, Uni-L, Uni-R, *Clash} > Str-L because 0(01)00 >> (1)0(2)(2)0 { *Al-L, FtBin, Uni-L, Uni-R} > Str-L because 0(01)00 >> (1)0(2)00 { FtBin, Uni-L, Uni-R, *Clash} > Parse-2 because 0(01)00 >> 0(1)(2)(2)0 ------------------------------------------------------------------------------ OUTPUT SET #54: /2/ --> >0(1) (actual) /3/ --> >0(01) /4/ --> >0(01)0 /5/ --> >00(01)0 Stratum #1 *Align-L [= *Al-L] Unary-R [= Uni-R] *Clash [= *Clash] Stratum #2 Align-L [= Al-L] *Align-R [= *Al-R] FtBin [= FtBin] Unary-L [= Uni-L] Stress-L [= Str-L] Stratum #3 Align-R [= Al-R] *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] Stress-R [= Str-R] 54.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [00(01)0], not *[(01)000]: *Al-L >> *Al-R, because /3/ --> [0(01)], not *[(01)0]: *Al-L >> *Lps, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-L >> Prs, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-L >> Parse-2, because /5/ --> [00(01)0], not *[(01)(02)0]: *Al-L >> FtBin, because /2/ --> [0(1)], not *[(01)]: *Al-L >> Uni-L, because /2/ --> [0(1)], not *[(01)]: *Al-R >> Al-R, because /5/ --> [00(01)0], not *[000(01)]: *Al-R >> *Lps, because /5/ --> [00(01)0], not *[0(01)(02)]: *Al-R >> Prs, because /5/ --> [00(01)0], not *[0(01)(02)]: *Al-R >> Parse-2, because /5/ --> [00(01)0], not *[0(01)(02)]: *Al-R >> Str-R, because /5/ --> [00(01)0], not *[000(01)]: Arguments Derived from Transitivity of Domination *Al-L >> Al-R *Al-L >> Str-R Irreducible Set Arguments { Al-R, *Al-L, Uni-R, Str-R} > Str-L because 0(1) >> (1)0 { FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01) >> 0(1)(2) { FtBin, Uni-L, Uni-R} > *Al-R because 0(01) >> 0(1)0 { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Lps because 0(01) >> 0(1)0 { *Al-L, FtBin, Uni-L, Uni-R} > Str-L because 0(01)0 >> (1)0(2)0 { *Al-L, *Lps, Prs, Parse-2, FtBin, Uni-R} > Str-L because 0(01)0 >> (1)000 { *Al-L, FtBin, Uni-R} > Str-L because 00(01)0 >> (1)0(02)0 { FtBin, Uni-L, Uni-R} > *Lps because 00(01)0 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Prs because 00(01)0 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Parse-2 because 00(01)0 >> 0(1)(02)0 { *Al-L, FtBin, Uni-R} > Str-L because 00(01)0 >> (1)(02)00 { *Al-L, FtBin, Uni-L, Uni-R, *Clash} > Str-L because 00(01)0 >> (1)0(2)(2)0 { *Al-L, FtBin, Uni-L, Uni-R} > Str-L because 00(01)0 >> (1)0(2)00 { FtBin, Uni-L, Uni-R, *Clash} > Parse-2 because 00(01)0 >> 0(1)(2)(2)0 ------------------------------------------------------------------------------ OUTPUT SET #55: /2/ --> >0(1) (actual) /3/ --> >0(01) /4/ --> >00(01) /5/ --> >0(01)(02) Stratum #1 Align-R [= Al-R] *Align-L [= *Al-L] Unary-R [= Uni-R] Stress-R [= Str-R] *Clash [= *Clash] Stratum #2 Align-L [= Al-L] *Align-R [= *Al-R] *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] FtBin [= FtBin] Unary-L [= Uni-L] Stress-L [= Str-L] 55.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)(02)], not *[(01)00(2)]: *Al-L >> *Lps, because /4/ --> [00(01)], not *[(01)0(2)]: *Al-L >> Prs, because /4/ --> [00(01)], not *[(01)0(2)]: *Al-L >> Parse-2, because /4/ --> [00(01)], not *[(01)0(2)]: *Al-L >> FtBin, because /2/ --> [0(1)], not *[(01)]: *Al-L >> Uni-L, because /2/ --> [0(1)], not *[(01)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { *Al-L, FtBin, Uni-R, *Clash} > Str-L because 0(1) >> (1)(2) { Al-R, *Al-L, Uni-R, Str-R} > Str-L because 0(1) >> (1)0 { *Al-L, FtBin, Uni-R} > Str-L because 0(01) >> (1)(02) { Al-R, *Al-L, Str-R} > *Al-R because 00(01) >> (01)00 { Al-R, Str-R} > *Al-R because 00(01) >> 0(01)0 { Al-R, Str-R} > *Lps because 00(01) >> 0(01)0 { Al-R, Str-R} > Parse-2 because 00(01) >> 0(01)0 { FtBin, Uni-L, *Clash} > *Lps because 00(01) >> 0(01)(2) { FtBin, Uni-L, *Clash} > Prs because 00(01) >> 0(01)(2) { FtBin, Uni-L, *Clash} > Parse-2 because 00(01) >> 0(01)(2) { FtBin, Uni-L, Uni-R} > *Lps because 00(01) >> 0(1)(02) { FtBin, Uni-L, Uni-R} > Prs because 00(01) >> 0(1)(02) { FtBin, Uni-L, Uni-R} > Parse-2 because 00(01) >> 0(1)(02) { Al-R, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because 00(01) >> 0(1)(2)0 { *Al-L, FtBin, Uni-L, Uni-R} > Str-L because 00(01) >> (1)00(2) { Al-R, *Al-L, Str-R} > *Al-R because 0(01)(02) >> (01)(02)0 { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because 0(01)(02) >> 0(01)00 { *Al-L, FtBin, Uni-L, Uni-R, *Clash} > Str-L because 0(01)(02) >> (1)(2)0(02) { *Al-L, Prs, FtBin, Uni-L, Uni-R} > Str-L because 0(01)(02) >> (1)0(2)0(2) { Prs, FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)(02) >> 0(1)(2)0(2) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because 0(01)(02) >> 0(1)0(2)0 ------------------------------------------------------------------------------ OUTPUT SET #56: /2/ --> >0(1) (actual) /3/ --> >0(01) /4/ --> >0(01)(2) /5/ --> >0(01)(02) Stratum #1 Align-R [= Al-R] *Align-L [= *Al-L] Prs-2 [= Parse-2] Unary-R [= Uni-R] Stress-R [= Str-R] Stratum #2 Align-L [= Al-L] *Align-R [= *Al-R] *Lapse [= *Lps] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] Stress-L [= Str-L] *Clash [= *Clash] 56.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)(02)], not *[(01)(02)(2)]: *Al-L >> *Lps, because /5/ --> [0(01)(02)], not *[(01)(02)(2)]: *Al-L >> Prs, because /5/ --> [0(01)(02)], not *[(01)(02)(2)]: *Al-L >> FtBin, because /4/ --> [0(01)(2)], not *[(01)(02)]: *Al-L >> Uni-L, because /4/ --> [0(01)(2)], not *[(01)(02)]: *Al-L >> *Clash, because /4/ --> [0(01)(2)], not *[(01)0(2)]: Uni-R >> *Lps, because /4/ --> [0(01)(2)], not *[0(1)(02)]: Uni-R >> *Clash, because /4/ --> [0(01)(2)], not *[0(1)(02)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-R, *Al-L, Uni-R, Str-R} > Str-L because 0(1) >> (1)0 { *Al-L, FtBin, Uni-R} > Str-L because 0(01) >> (1)(02) { Al-R, Prs, Str-R} > *Al-R because 0(01)(2) >> 0(01)0 { Al-R, Prs, Str-R} > FtBin because 0(01)(2) >> 0(01)0 { Al-R, Prs, Str-R} > Uni-L because 0(01)(2) >> 0(01)0 { Al-R, Prs, Str-R} > *Clash because 0(01)(2) >> 0(01)0 { *Lps, Prs, Parse-2} > FtBin because 0(01)(2) >> 00(01) { *Lps, Prs, Parse-2} > Uni-L because 0(01)(2) >> 00(01) { *Lps, Prs, Parse-2} > *Clash because 0(01)(2) >> 00(01) { *Al-L, Uni-R} > Str-L because 0(01)(2) >> (1)0(02) { *Al-L, FtBin, Uni-L, Uni-R} > Str-L because 0(01)(2) >> (1)(2)0(2) { *Al-L, Prs, Parse-2, FtBin, Uni-R} > Str-L because 0(01)(2) >> (1)00(2) { Al-R, Prs, Parse-2, Uni-R, Str-R} > *Al-R because 0(01)(2) >> 0(1)00 { Al-R, *Al-L, Str-R} > *Al-R because 0(01)(02) >> (01)(02)0 { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because 0(01)(02) >> 0(01)00 { Al-R, *Al-L, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because 0(01)(02) >> (1)(2)(02)0 { *Al-L, FtBin, Uni-L, Uni-R, *Clash} > Str-L because 0(01)(02) >> (1)(2)0(02) { *Al-L, Prs, FtBin, Uni-L, Uni-R} > Str-L because 0(01)(02) >> (1)0(2)0(2) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because 0(01)(02) >> 0(1)(2)(2)0 { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because 0(01)(02) >> 0(1)0(2)0 ------------------------------------------------------------------------------ OUTPUT SET #57: /2/ --> >0(1) (actual) /3/ --> >0(01) /4/ --> >0(1)(02) /5/ --> >0(01)(02) Stratum #1 Align-R [= Al-R] *Align-L [= *Al-L] Prs-2 [= Parse-2] Stress-R [= Str-R] *Clash [= *Clash] Stratum #2 Align-L [= Al-L] *Align-R [= *Al-R] *Lapse [= *Lps] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] Stress-L [= Str-L] 57.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)(02)], not *[(1)0(2)0(2)]: *Al-L >> *Lps, because /5/ --> [0(01)(02)], not *[(1)0(2)0(2)]: *Al-L >> Prs, because /5/ --> [0(01)(02)], not *[(1)(02)(02)]: *Al-L >> FtBin, because /4/ --> [0(1)(02)], not *[(01)(02)]: *Al-L >> Uni-L, because /4/ --> [0(1)(02)], not *[(1)0(02)]: *Al-L >> Uni-R, because /4/ --> [0(1)(02)], not *[(01)0(2)]: *Al-L >> Str-L, because /5/ --> [0(01)(02)], not *[(1)0(2)0(2)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Lps because 0(01) >> 0(1)0 { Al-R, *Lps, Prs, Str-R} > *Al-R because 0(1)(02) >> 0(01)0 { Al-R, *Lps, Prs, Str-R} > FtBin because 0(1)(02) >> 0(01)0 { Al-R, *Lps, Prs, Str-R} > Uni-L because 0(1)(02) >> 0(01)0 { Al-R, *Lps, Prs, Str-R} > Uni-R because 0(1)(02) >> 0(01)0 { *Lps, Prs, Parse-2} > FtBin because 0(1)(02) >> 00(01) { *Lps, Prs, Parse-2} > Uni-L because 0(1)(02) >> 00(01) { *Lps, Prs, Parse-2} > Uni-R because 0(1)(02) >> 00(01) { Al-R, *Al-L, Str-R} > *Al-R because 0(1)(02) >> (1)(02)0 { *Lps, *Clash} > Uni-R because 0(1)(02) >> 0(01)(2) { Al-R, *Al-L, Str-R, *Clash} > *Al-R because 0(1)(02) >> (01)(2)0 { Al-R, *Al-L, Str-R} > *Al-R because 0(01)(02) >> (01)(02)0 { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because 0(01)(02) >> 00(01)0 { Al-R, *Al-L, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because 0(01)(02) >> (1)(2)(2)(2)0 { FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)(02) >> 0(1)(2)(2)(2) { Prs, FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)(02) >> 0(1)(2)0(2) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because 0(01)(02) >> 0(1)0(2)0 { Al-R, Prs, Parse-2, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because 0(01)(02) >> 00(1)(2)0 ------------------------------------------------------------------------------ OUTPUT SET #58: /2/ --> >0(1) (actual) /3/ --> >(01)(2) /4/ --> >(01)(02) /5/ --> >(01)(02)(2) Stratum #1 Align-R [= Al-R] *Lapse [= *Lps] Prs-2 [= Parse-2] Unary-R [= Uni-R] Stress-R [= Str-R] Stratum #2 *Align-L [= *Al-L] *Align-R [= *Al-R] Stress-L [= Str-L] *Clash [= *Clash] Stratum #3 Align-L [= Al-L] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] 58.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /2/ --> [0(1)], not *[(01)]: *Al-L >> Prs, because /2/ --> [0(1)], not *[(01)]: *Al-L >> FtBin, because /2/ --> [0(1)], not *[(01)]: *Al-L >> Uni-L, because /2/ --> [0(1)], not *[(01)]: *Lps >> *Al-L, because /5/ --> [(01)(02)(2)], not *[0(01)0(2)]: *Lps >> FtBin, because /5/ --> [(01)(02)(2)], not *[0(01)(02)]: *Lps >> Uni-L, because /5/ --> [(01)(02)(2)], not *[0(01)(02)]: *Lps >> *Clash, because /5/ --> [(01)(02)(2)], not *[0(01)0(2)]: Uni-R >> *Al-L, because /5/ --> [(01)(02)(2)], not *[0(1)0(2)(2)]: Uni-R >> Uni-L, because /5/ --> [(01)(02)(2)], not *[(1)(02)(02)]: Uni-R >> Str-L, because /5/ --> [(01)(02)(2)], not *[(1)(02)(02)]: Uni-R >> *Clash, because /5/ --> [(01)(02)(2)], not *[(1)(02)(02)]: Arguments Derived from Transitivity of Domination *Lps >> Al-L *Lps >> Prs Uni-R >> Al-L Uni-R >> Prs Uni-R >> FtBin Irreducible Set Arguments { Al-R, *Al-L, Uni-R, Str-R} > *Al-R because 0(1) >> (1)0 { Al-R, Prs, Str-R} > *Al-R because (01)(2) >> (01)0 { Al-R, Prs, Str-R} > FtBin because (01)(2) >> (01)0 { Al-R, Prs, Str-R} > Uni-L because (01)(2) >> (01)0 { Al-R, Prs, Str-R} > *Clash because (01)(2) >> (01)0 { Al-R, Prs, FtBin, Uni-R, Str-R} > *Al-R because (01)(02) >> (1)(02)0 { Al-R, *Lps, Prs, Parse-2, FtBin, Uni-R, Str-R} > *Al-R because (01)(02) >> (1)000 { Al-L, Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because (01)(02)(2) >> 00(01)0 { Al-L, Al-R, Prs, Uni-R, Str-R} > *Al-R because (01)(02)(2) >> 0(1)(02)0 { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because (01)(02)(2) >> (01)000 { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because (01)(02)(2) >> (1)(2)0(2)0 ------------------------------------------------------------------------------ OUTPUT SET #59: /2/ --> >0(1) (actual) /3/ --> >(1)(02) /4/ --> >(01)(02) /5/ --> >(1)(02)(02) Stratum #1 Align-R [= Al-R] *Lapse [= *Lps] Prs-2 [= Parse-2] Stress-R [= Str-R] *Clash [= *Clash] Stratum #2 *Align-R [= *Al-R] Unary-R [= Uni-R] Stress-L [= Str-L] Stratum #3 *Align-L [= *Al-L] Stratum #4 Align-L [= Al-L] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] 59.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /2/ --> [0(1)], not *[(01)]: *Al-L >> Prs, because /2/ --> [0(1)], not *[(01)]: *Al-L >> FtBin, because /2/ --> [0(1)], not *[(01)]: *Al-L >> Uni-L, because /2/ --> [0(1)], not *[(01)]: Uni-R >> *Al-L, because /4/ --> [(01)(02)], not *[0(1)0(2)]: Arguments Derived from Transitivity of Domination Uni-R >> Al-L Uni-R >> Prs Uni-R >> FtBin Uni-R >> Uni-L Irreducible Set Arguments { *Al-L, FtBin, Uni-R, *Clash} > Str-L because 0(1) >> (1)(2) { Al-R, *Al-L, Uni-R, Str-R} > *Al-R because 0(1) >> (1)0 { Al-R, *Al-L, Uni-R, Str-R} > Str-L because 0(1) >> (1)0 { Al-R, Prs, Str-L, Str-R} > *Al-R because (1)(02) >> (01)0 { Al-R, Prs, Str-L, Str-R} > FtBin because (1)(02) >> (01)0 { Al-R, Str-L, Str-R} > Uni-R because (1)(02) >> (01)0 { *Lps, Str-L} > *Al-L because (1)(02) >> 0(01) { Al-L, *Lps, Prs, Str-L} > FtBin because (1)(02) >> 0(01) { Str-L, *Clash} > Uni-R because (1)(02) >> (01)(2) { Str-L, *Clash} > *Al-L because (1)(02) >> 0(1)(2) { Al-R, Str-L, Str-R} > *Al-L because (1)(02) >> 0(1)0 { Al-R, *Lps, Str-R} > *Al-L because (01)(02) >> 0(01)0 { Al-L, Al-R, *Lps, Prs, Str-R} > *Al-R because (01)(02) >> 0(01)0 { *Lps, Parse-2} > *Al-L because (01)(02) >> 00(01) { Al-R, Prs, FtBin, Uni-R, Str-R} > *Al-R because (01)(02) >> (1)(02)0 { Al-R, Prs, FtBin, Uni-R, Str-R} > Str-L because (01)(02) >> (1)(02)0 { *Lps, Prs, FtBin, Uni-R} > Str-L because (01)(02) >> (1)0(02) { *Lps, *Clash} > *Al-L because (01)(02) >> 0(01)(2) { FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)(02) >> (1)(2)(2)(2) { Prs, FtBin, Uni-L, Uni-R, *Clash} > Str-L because (01)(02) >> (1)(2)0(2) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because (01)(02) >> (1)0(2)0 { *Lps, Prs, Str-L} > FtBin because (1)(02)(02) >> (01)0(02) { *Lps, Str-L} > Uni-R because (1)(02)(02) >> 0(01)(02) { Al-R, *Lps, Prs, Str-R} > *Al-R because (1)(02)(02) >> (1)0(02)0 { Al-R, Prs, Uni-L, Str-L, Str-R} > *Al-R because (1)(02)(02) >> (01)0(2)0 { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because (1)(02)(02) >> (1)0000 { *Lps, Parse-2, Str-L} > *Al-L because (1)(02)(02) >> 00(1)0(2) ------------------------------------------------------------------------------ OUTPUT SET #60: /2/ --> >0(1) (actual) /3/ --> >(1)(02) /4/ --> >(1)0(02) /5/ --> >(1)(02)(02) Stratum #1 Align-R [= Al-R] Prs-2 [= Parse-2] Stress-R [= Str-R] *Clash [= *Clash] Stratum #2 *Align-R [= *Al-R] Stress-L [= Str-L] Stratum #3 *Align-L [= *Al-L] *Lapse [= *Lps] Unary-R [= Uni-R] Stratum #4 Align-L [= Al-L] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] 60.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /2/ --> [0(1)], not *[(01)]: *Al-L >> Prs, because /2/ --> [0(1)], not *[(01)]: *Al-L >> FtBin, because /2/ --> [0(1)], not *[(01)]: *Al-L >> Uni-L, because /2/ --> [0(1)], not *[(01)]: Str-L >> *Al-L, because /5/ --> [(1)(02)(02)], not *[0(01)(02)]: Str-L >> *Lps, because /4/ --> [(1)0(02)], not *[(01)(02)]: Str-L >> Prs, because /4/ --> [(1)0(02)], not *[(01)(02)]: Str-L >> FtBin, because /5/ --> [(1)(02)(02)], not *[(01)0(02)]: Str-L >> Uni-R, because /5/ --> [(1)(02)(02)], not *[(01)0(02)]: *Clash >> *Lps, because /4/ --> [(1)0(02)], not *[(1)0(2)(2)]: *Clash >> Prs, because /4/ --> [(1)0(02)], not *[(1)(2)(2)(2)]: *Clash >> Str-L, because /2/ --> [0(1)], not *[(1)(2)]: Arguments Derived from Transitivity of Domination Str-L >> Al-L Str-L >> Uni-L *Clash >> Al-L *Clash >> *Al-L *Clash >> FtBin *Clash >> Uni-L *Clash >> Uni-R Irreducible Set Arguments { Al-R, Str-R} > Str-L because 0(1) >> (1)0 { Al-R, Prs, Str-L, Str-R} > *Al-R because (1)(02) >> (01)0 { Al-R, Prs, Parse-2, Str-L, Str-R} > *Al-R because (1)0(02) >> (01)00 { Al-R, Str-R} > *Al-R because (1)0(02) >> (1)(02)0 { Al-R, Str-R} > *Lps because (1)0(02) >> (1)(02)0 { Al-R, Uni-L, Str-L, Str-R, *Clash} > *Al-R because (1)0(02) >> (01)(2)0 { Al-R, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because (1)0(02) >> (1)(2)(2)0 { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because (1)0(02) >> (1)0(2)0 { Al-R, *Lps, Prs, Str-R} > *Al-R because (1)(02)(02) >> (1)0(02)0 { Al-R, Prs, Uni-L, Str-L, Str-R} > *Al-R because (1)(02)(02) >> (01)0(2)0 { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because (1)(02)(02) >> (1)0000 ------------------------------------------------------------------------------ OUTPUT SET #61: /2/ --> >0(1) (actual) /3/ --> >(1)(02) /4/ --> >0(1)(02) /5/ --> >(1)(02)(02) Stratum #1 Align-R [= Al-R] *Lapse [= *Lps] Prs-2 [= Parse-2] Stress-R [= Str-R] *Clash [= *Clash] Stratum #2 *Align-L [= *Al-L] *Align-R [= *Al-R] Stress-L [= Str-L] Stratum #3 Align-L [= Al-L] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] 61.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /4/ --> [0(1)(02)], not *[(01)0(2)]: *Al-L >> Prs, because /4/ --> [0(1)(02)], not *[(01)(02)]: *Al-L >> FtBin, because /4/ --> [0(1)(02)], not *[(01)(02)]: *Al-L >> Uni-L, because /4/ --> [0(1)(02)], not *[(01)(02)]: *Al-L >> Uni-R, because /4/ --> [0(1)(02)], not *[(01)0(2)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-R, *Al-L, Uni-R, Str-R} > *Al-R because 0(1) >> (1)0 { Al-R, Prs, Str-L, Str-R} > *Al-R because (1)(02) >> (01)0 { Al-R, Prs, Str-L, Str-R} > FtBin because (1)(02) >> (01)0 { Al-R, Prs, Str-L, Str-R} > Uni-R because (1)(02) >> (01)0 { *Lps, Str-L} > *Al-L because (1)(02) >> 0(01) { Al-L, *Lps, Prs, Str-L} > Uni-R because (1)(02) >> 0(01) { Uni-L, Str-L, *Clash} > Uni-R because (1)(02) >> (01)(2) { Al-R, Str-L, Str-R} > *Al-L because (1)(02) >> 0(1)0 { Al-R, *Lps, Prs, Str-R} > FtBin because 0(1)(02) >> 0(01)0 { Al-R, *Lps, Prs, Str-R} > Uni-L because 0(1)(02) >> 0(01)0 { Al-R, *Lps, Prs, Str-R} > Uni-R because 0(1)(02) >> 0(01)0 { *Lps, Prs, Parse-2} > FtBin because 0(1)(02) >> 00(01) { *Lps, Prs, Parse-2} > Uni-L because 0(1)(02) >> 00(01) { *Lps, Prs, Parse-2} > Uni-R because 0(1)(02) >> 00(01) { *Al-L, FtBin, *Clash} > Str-L because 0(1)(02) >> (1)(02)(2) { Al-R, *Al-L, Str-R} > *Al-R because 0(1)(02) >> (1)(02)0 { Al-R, *Al-L, Str-R} > Str-L because 0(1)(02) >> (1)(02)0 { *Al-L, *Lps} > Str-L because 0(1)(02) >> (1)0(02) { *Lps, *Clash} > Uni-R because 0(1)(02) >> 0(01)(2) { *Al-L, FtBin, Uni-L, Uni-R, *Clash} > Str-L because 0(1)(02) >> (1)0(2)(2) { Al-R, *Al-L, *Lps, Prs, Parse-2, Str-R} > Str-L because 0(1)(02) >> (1)000 { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because 0(1)(02) >> 00(1)0 { *Lps, Prs, Str-L} > FtBin because (1)(02)(02) >> (01)0(02) { *Lps, Prs, Str-L} > Uni-R because (1)(02)(02) >> (01)0(02) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because (1)(02)(02) >> (1)(2)(02)0 { Al-R, *Lps, Prs, Str-R} > *Al-R because (1)(02)(02) >> (1)0(02)0 { Al-R, Prs, Uni-L, Str-L, Str-R} > *Al-R because (1)(02)(02) >> (01)0(2)0 { Al-R, *Lps, Prs, Parse-2, FtBin, Uni-L, Uni-R, Str-R} > *Al-R because (1)(02)(02) >> (1)0(2)00 { Str-L, *Clash} > *Al-L because (1)(02)(02) >> 0(1)(2)(02) { *Lps, Str-L} > *Al-L because (1)(02)(02) >> 0(1)0(02) { *Lps, Parse-2, Str-L} > *Al-L because (1)(02)(02) >> 00(1)0(2) ------------------------------------------------------------------------------ OUTPUT SET #62: /2/ --> >0(1) (actual) /3/ --> >0(1)(2) /4/ --> >0(1)(02) /5/ --> >0(1)(02)(2) Stratum #1 Align-R [= Al-R] *Align-L [= *Al-L] *Lapse [= *Lps] Prs-2 [= Parse-2] Stress-R [= Str-R] Stratum #2 Align-L [= Al-L] *Align-R [= *Al-R] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] Stress-L [= Str-L] *Clash [= *Clash] 62.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(1)(02)(2)], not *[(1)0(2)0(2)]: *Al-L >> Prs, because /5/ --> [0(1)(02)(2)], not *[(1)(2)(2)(2)(2)]: *Al-L >> FtBin, because /5/ --> [0(1)(02)(2)], not *[(01)(2)(02)]: *Al-L >> Uni-L, because /5/ --> [0(1)(02)(2)], not *[(1)0(2)(02)]: *Al-L >> Uni-R, because /5/ --> [0(1)(02)(2)], not *[(01)(02)(2)]: *Al-L >> Str-L, because /5/ --> [0(1)(02)(2)], not *[(1)0(2)0(2)]: *Al-L >> *Clash, because /5/ --> [0(1)(02)(2)], not *[(1)0(2)0(2)]: *Lps >> FtBin, because /5/ --> [0(1)(02)(2)], not *[0(01)(02)]: *Lps >> Uni-L, because /5/ --> [0(1)(02)(2)], not *[0(01)(02)]: *Lps >> Uni-R, because /4/ --> [0(1)(02)], not *[0(01)(2)]: *Lps >> *Clash, because /5/ --> [0(1)(02)(2)], not *[0(01)(02)]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-R, Prs, Str-R} > FtBin because 0(1)(2) >> 0(1)0 { Al-R, Prs, Str-R} > Uni-L because 0(1)(2) >> 0(1)0 { Al-R, Prs, Str-R} > *Clash because 0(1)(2) >> 0(1)0 { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because 0(1)(02) >> 0(1)(2)0 { Al-R, *Al-L, Str-R, *Clash} > *Al-R because 0(1)(02) >> (01)(2)0 { Al-R, *Al-L, Str-R} > *Al-R because 0(1)(02)(2) >> (01)(02)0 { Al-R, *Al-L, Uni-R, Str-R} > *Al-R because 0(1)(02)(2) >> (1)(2)(02)0 { Al-R, Prs, Str-R} > *Al-R because 0(1)(02)(2) >> 0(1)(02)0 { Al-R, *Al-L, Prs, Str-R} > *Al-R because 0(1)(02)(2) >> (01)0(2)0 { Al-R, *Lps, Prs, Str-R} > *Al-R because 0(1)(02)(2) >> 0(01)(2)0 { Al-R, Prs, Uni-R, Str-R} > *Al-R because 0(1)(02)(2) >> 0(1)0(2)0 { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because 0(1)(02)(2) >> 000(1)0 ------------------------------------------------------------------------------ OUTPUT SET #63: /2/ --> >0(1) (actual) /3/ --> >0(1)0 /4/ --> >0(01)0 /5/ --> >0(01)00 Stratum #1 *Align-L [= *Al-L] *Clash [= *Clash] Stratum #2 Align-L [= Al-L] *Align-R [= *Al-R] Stress-L [= Str-L] Stratum #3 Align-R [= Al-R] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] Stress-R [= Str-R] Stratum #4 *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] 63.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(01)00], not *[(1)0000]: *Al-L >> *Al-R, because /2/ --> [0(1)], not *[(1)0]: *Al-L >> *Lps, because /5/ --> [0(01)00], not *[(1)00(2)0]: *Al-L >> Prs, because /5/ --> [0(01)00], not *[(1)(02)00]: *Al-L >> Parse-2, because /5/ --> [0(01)00], not *[(01)0(2)0]: *Al-L >> FtBin, because /3/ --> [0(1)0], not *[(01)0]: *Al-L >> Uni-L, because /3/ --> [0(1)0], not *[(1)00]: *Al-L >> Uni-R, because /3/ --> [0(1)0], not *[(01)0]: *Al-L >> Str-L, because /5/ --> [0(01)00], not *[(1)0000]: *Al-R >> Al-R, because /5/ --> [0(01)00], not *[0000(1)]: *Al-R >> *Lps, because /5/ --> [0(01)00], not *[00(1)0(2)]: *Al-R >> Prs, because /5/ --> [0(01)00], not *[00(1)(02)]: *Al-R >> Parse-2, because /5/ --> [0(01)00], not *[0(1)0(02)]: *Al-R >> FtBin, because /3/ --> [0(1)0], not *[0(01)]: *Al-R >> Uni-L, because /3/ --> [0(1)0], not *[0(01)]: *Al-R >> Uni-R, because /3/ --> [0(1)0], not *[00(1)]: *Al-R >> Str-R, because /5/ --> [0(01)00], not *[0000(1)]: Arguments Derived from Transitivity of Domination *Al-L >> Al-R *Al-L >> Str-R Irreducible Set Arguments { FtBin, Uni-L, Uni-R} > Prs because 0(01)00 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Parse-2 because 0(01)00 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R, *Clash} > Parse-2 because 0(01)00 >> 0(1)(2)(2)0 { FtBin, Uni-L, Uni-R} > *Lps because 0(01)00 >> 0(1)0(2)0 ------------------------------------------------------------------------------ OUTPUT SET #64: /2/ --> >0(1) (actual) /3/ --> >0(1)0 /4/ --> >0(01)0 /5/ --> >00(01)0 Stratum #1 *Align-L [= *Al-L] *Clash [= *Clash] Stratum #2 Align-L [= Al-L] *Align-R [= *Al-R] Stress-L [= Str-L] Stratum #3 Align-R [= Al-R] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] Stress-R [= Str-R] Stratum #4 *Lapse [= *Lps] Parse [= Prs] Prs-2 [= Parse-2] 64.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [00(01)0], not *[(1)0000]: *Al-L >> *Al-R, because /2/ --> [0(1)], not *[(1)0]: *Al-L >> *Lps, because /5/ --> [00(01)0], not *[(1)00(2)0]: *Al-L >> Prs, because /5/ --> [00(01)0], not *[(1)(02)00]: *Al-L >> Parse-2, because /5/ --> [00(01)0], not *[(01)0(2)0]: *Al-L >> FtBin, because /3/ --> [0(1)0], not *[(01)0]: *Al-L >> Uni-L, because /3/ --> [0(1)0], not *[(1)00]: *Al-L >> Uni-R, because /3/ --> [0(1)0], not *[(01)0]: *Al-L >> Str-L, because /5/ --> [00(01)0], not *[(1)0000]: *Al-R >> Al-R, because /5/ --> [00(01)0], not *[0000(1)]: *Al-R >> *Lps, because /5/ --> [00(01)0], not *[00(1)0(2)]: *Al-R >> Prs, because /5/ --> [00(01)0], not *[00(1)(02)]: *Al-R >> Parse-2, because /5/ --> [00(01)0], not *[0(1)0(02)]: *Al-R >> FtBin, because /3/ --> [0(1)0], not *[0(01)]: *Al-R >> Uni-L, because /3/ --> [0(1)0], not *[0(01)]: *Al-R >> Uni-R, because /3/ --> [0(1)0], not *[00(1)]: *Al-R >> Str-R, because /5/ --> [00(01)0], not *[0000(1)]: Arguments Derived from Transitivity of Domination *Al-L >> Al-R *Al-L >> Str-R Irreducible Set Arguments { FtBin, Uni-L, Uni-R} > Prs because 00(01)0 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R} > Parse-2 because 00(01)0 >> 0(1)(02)0 { FtBin, Uni-L, Uni-R, *Clash} > Parse-2 because 00(01)0 >> 0(1)(2)(2)0 { FtBin, Uni-L, Uni-R} > *Lps because 00(01)0 >> 0(1)0(2)0 ------------------------------------------------------------------------------ OUTPUT SET #65: /2/ --> >0(1) (actual) /3/ --> >0(1)0 /4/ --> >0(01)0 /5/ --> >0(1)(02)0 Stratum #1 *Align-L [= *Al-L] Prs-2 [= Parse-2] *Clash [= *Clash] Stratum #2 Align-L [= Al-L] *Align-R [= *Al-R] Stress-L [= Str-L] Stratum #3 Align-R [= Al-R] *Lapse [= *Lps] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] Stress-R [= Str-R] 65.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(1)(02)0], not *[(1)0(02)0]: *Al-L >> *Lps, because /4/ --> [0(01)0], not *[(1)0(2)0]: *Al-L >> Prs, because /4/ --> [0(01)0], not *[(1)(02)0]: *Al-L >> FtBin, because /5/ --> [0(1)(02)0], not *[(01)(02)0]: *Al-L >> Uni-L, because /5/ --> [0(1)(02)0], not *[(1)0(02)0]: *Al-L >> Uni-R, because /5/ --> [0(1)(02)0], not *[(01)(02)0]: *Al-L >> Str-L, because /5/ --> [0(1)(02)0], not *[(1)0(02)0]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-R, *Al-L, Uni-R, Str-R} > *Al-R because 0(1) >> (1)0 { *Al-R, *Lps} > Al-R because 0(1)0 >> 0(01) { *Al-R, *Lps} > Prs because 0(1)0 >> 0(01) { *Al-R, *Lps} > FtBin because 0(1)0 >> 0(01) { *Al-R, *Lps} > Uni-L because 0(1)0 >> 0(01) { *Al-R, *Lps} > Uni-R because 0(1)0 >> 0(01) { *Al-R, *Lps} > Str-R because 0(1)0 >> 0(01) { *Al-L, *Al-R, *Clash} > Str-R because 0(1)0 >> (01)(2) { *Al-L, *Al-R} > Str-R because 0(1)0 >> (1)(02) { *Al-R, FtBin, Uni-L, *Clash} > Al-R because 0(1)0 >> 0(1)(2) { *Al-R, FtBin, Uni-L, *Clash} > Prs because 0(1)0 >> 0(1)(2) { *Al-R, FtBin, Uni-L, *Clash} > Str-R because 0(1)0 >> 0(1)(2) { *Al-L, *Al-R} > Al-R because 0(01)0 >> (01)(02) { *Al-R, FtBin, Uni-L, Uni-R} > Al-R because 0(01)0 >> 0(1)(02) { *Al-R, FtBin, Uni-L, Uni-R} > Prs because 0(01)0 >> 0(1)(02) { *Al-R, FtBin, Uni-L, Uni-R} > Str-R because 0(01)0 >> 0(1)(02) { FtBin, Uni-L, Uni-R, *Clash} > *Lps because 0(01)0 >> 0(1)(2)0 { *Al-R, FtBin, Uni-L, Uni-R} > *Lps because 0(01)0 >> 0(1)0(2) { *Lps, Prs, Parse-2} > FtBin because 0(1)(02)0 >> 0(01)00 { *Lps, Prs, Parse-2} > Uni-L because 0(1)(02)0 >> 0(01)00 { *Lps, Prs, Parse-2} > Uni-R because 0(1)(02)0 >> 0(01)00 { *Al-L, *Al-R} > Al-R because 0(1)(02)0 >> (1)(02)(02) { *Al-L, *Al-R, FtBin, Uni-L, *Clash} > Str-R because 0(1)(02)0 >> (01)0(2)(2) { *Al-L, *Al-R, *Lps, FtBin, *Clash} > Str-R because 0(1)(02)0 >> (1)0(02)(2) { *Al-R, FtBin, Uni-L, Uni-R, *Clash} > Str-R because 0(1)(02)0 >> 0(1)(2)0(2) { *Al-R, *Lps, Parse-2, *Clash} > Str-R because 0(1)(02)0 >> 00(01)(2) { *Al-R, *Lps, Prs, Parse-2} > Str-R because 0(1)(02)0 >> 000(01) ------------------------------------------------------------------------------ OUTPUT SET #66: /2/ --> >0(1) (actual) /3/ --> >0(1)0 /4/ --> >0(1)(02) /5/ --> >0(1)(02)0 Stratum #1 *Align-L [= *Al-L] *Lapse [= *Lps] Prs-2 [= Parse-2] *Clash [= *Clash] Stratum #2 Align-L [= Al-L] Align-R [= Al-R] *Align-R [= *Al-R] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] Stress-L [= Str-L] Stress-R [= Str-R] 66.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(1)(02)0], not *[(01)0(2)0]: *Al-L >> Prs, because /5/ --> [0(1)(02)0], not *[(01)(02)0]: *Al-L >> FtBin, because /5/ --> [0(1)(02)0], not *[(01)(02)0]: *Al-L >> Uni-L, because /5/ --> [0(1)(02)0], not *[(01)(02)0]: *Al-L >> Uni-R, because /5/ --> [0(1)(02)0], not *[(01)(02)0]: There were no arguments based solely on transitivity of domination. Irreducible Set Arguments { Al-R, *Al-L, Uni-R, Str-R} > *Al-R because 0(1) >> (1)0 { *Al-R, *Lps} > Al-R because 0(1)0 >> 0(01) { *Al-R, *Lps} > Prs because 0(1)0 >> 0(01) { *Al-R, *Lps} > FtBin because 0(1)0 >> 0(01) { *Al-R, *Lps} > Uni-L because 0(1)0 >> 0(01) { *Al-R, *Lps} > Uni-R because 0(1)0 >> 0(01) { *Al-L, *Al-R} > Al-R because 0(1)0 >> (1)(02) { *Al-L, *Al-R} > Str-L because 0(1)0 >> (1)(02) { *Al-R, FtBin, Uni-L, *Clash} > Al-R because 0(1)0 >> 0(1)(2) { *Al-R, FtBin, Uni-L, *Clash} > Prs because 0(1)0 >> 0(1)(2) { *Al-R, FtBin, Uni-L, *Clash} > Str-R because 0(1)0 >> 0(1)(2) { *Al-L, *Al-R, FtBin} > Al-R because 0(1)0 >> (1)0(2) { Al-R, *Lps, Prs, Str-R} > *Al-R because 0(1)(02) >> 0(01)0 { Al-R, *Lps, Prs, Str-R} > FtBin because 0(1)(02) >> 0(01)0 { Al-R, *Lps, Prs, Str-R} > Uni-L because 0(1)(02) >> 0(01)0 { Al-R, *Lps, Prs, Str-R} > Uni-R because 0(1)(02) >> 0(01)0 { *Lps, Prs, Parse-2} > FtBin because 0(1)(02) >> 00(01) { *Lps, Prs, Parse-2} > Uni-L because 0(1)(02) >> 00(01) { *Al-L, FtBin, *Clash} > Str-L because 0(1)(02) >> (1)(02)(2) { Al-R, *Al-L, Str-R} > *Al-R because 0(1)(02) >> (1)(02)0 { Al-R, *Al-L, Str-R} > Str-L because 0(1)(02) >> (1)(02)0 { *Al-L, *Lps} > Str-L because 0(1)(02) >> (1)0(02) { *Lps, *Clash} > Uni-R because 0(1)(02) >> 0(01)(2) { Al-R, Prs, FtBin, Uni-L, Uni-R, Str-R, *Clash} > *Al-R because 0(1)(02) >> 0(1)(2)0 { Al-R, *Lps, Prs, Parse-2, Str-R} > *Al-R because 0(1)(02) >> 0(1)00 { *Lps, Prs, Parse-2} > Uni-R because 0(1)(02)0 >> 00(01)0 { *Al-L, *Al-R} > Al-R because 0(1)(02)0 >> (1)(02)(02) { *Al-L, *Al-R} > Str-R because 0(1)(02)0 >> (1)(02)(02) { *Al-L, FtBin, Uni-R, *Clash} > Str-L because 0(1)(02)0 >> (1)(2)(02)0 { *Al-L, *Lps} > Str-L because 0(1)(02)0 >> (1)0(02)0 { *Al-L, *Al-R, FtBin} > Str-R because 0(1)(02)0 >> (1)(02)0(2) { *Al-L, *Al-R, FtBin, Uni-R} > Str-R because 0(1)(02)0 >> (1)0(2)(02) { *Al-R, *Lps} > Str-R because 0(1)(02)0 >> 0(01)0(2) { *Al-R, FtBin, Uni-L, Uni-R, *Clash} > Str-R because 0(1)(02)0 >> 0(1)(2)(2)(2) { *Al-R, *Lps, Parse-2, *Clash} > Str-R because 0(1)(02)0 >> 00(01)(2) { *Al-R, *Lps, Prs, Parse-2} > Str-R because 0(1)(02)0 >> 000(01) ------------------------------------------------------------------------------ OUTPUT SET #67: /2/ --> >0(1) (actual) /3/ --> >0(1)0 /4/ --> >0(1)(2)0 /5/ --> >0(1)(02)0 Stratum #1 *Align-L [= *Al-L] *Lapse [= *Lps] Prs-2 [= Parse-2] Stratum #2 Align-L [= Al-L] *Align-R [= *Al-R] Stress-L [= Str-L] Stratum #3 Align-R [= Al-R] Parse [= Prs] FtBin [= FtBin] Unary-L [= Uni-L] Unary-R [= Uni-R] Stress-R [= Str-R] *Clash [= *Clash] 67.1. Ranking Arguments Direct Pairwise Arguments *Al-L >> Al-L, because /5/ --> [0(1)(02)0], not *[(1)0(2)(2)0]: *Al-L >> *Al-R, because /2/ --> [0(1)], not *[(1)0]: *Al-L >> Prs, because /5/ --> [0(1)(02)0], not *[(1)(2)(2)(2)0]: *Al-L >> FtBin, because /5/ --> [0(1)(02)0], not *[(01)(02)0]: *Al-L >> Uni-L, because /5/ --> [0(1)(02)0], not *[(01)(02)0]: *Al-L >> Uni-R, because /5/ --> [0(1)(02)0], not *[(01)(02)0]: *Al-L >> Str-L, because /5/ --> [0(1)(02)0], not *[(1)0(2)(2)0]: *Al-L >> *Clash, because /4/ --> [0(1)(2)0], not *[(1)0(2)0]: *Al-R >> Al-R, because /5/ --> [0(1)(02)0], not *[0(1)0(2)(2)]: *Al-R >> Prs, because /5/ --> [0(1)(02)0], not *[0(1)(2)(2)(2)]: *Al-R >> FtBin, because /4/ --> [0(1)(2)0], not *[0(1)(02)]: *Al-R >> Uni-L, because /4/ --> [0(1)(2)0], not *[0(1)(02)]: *Al-R >> Uni-R, because /4/ --> [0(1)(2)0], not *[0(1)0(2)]: *Al-R >> Str-R, because /5/ --> [0(1)(02)0], not *[0(1)0(2)(2)]: *Al-R >> *Clash, because /4/ --> [0(1)(2)0], not *[0(1)0(2)]: *Lps >> FtBin, because /4/ --> [0(1)(2)0], not *[0(01)0]: *Lps >> Uni-L, because /4/ --> [0(1)(2)0], not *[0(01)0]: *Lps >> Uni-R, because /4/ --> [0(1)(2)0], not *[0(01)0]: *Lps >> *Clash, because /4/ --> [0(1)(2)0], not *[0(01)0]: Arguments Derived from Transitivity of Domination *Al-L >> Al-R *Al-L >> Str-R There were no irreducible set arguments.