diff --git a/pkg/parser/grammar_parser.go b/pkg/parser/grammar_parser.go
index 3124b82..6e677b6 100644
--- a/pkg/parser/grammar_parser.go
+++ b/pkg/parser/grammar_parser.go
@@ -13,12 +13,31 @@
 type GrammarParser struct {
 	defaultFoundry string
 	defaultLayer   string
-	parser         *participle.Parser[Grammar]
+	tokenParser    *participle.Parser[TokenGrammar]
+	mappingParser  *participle.Parser[MappingGrammar]
 }
 
+// TokenGrammar represents a single token expression
+type TokenGrammar struct {
+	Token *TokenExpr `parser:"@@"`
+}
+
+// MappingGrammar represents a mapping rule
+type MappingGrammar struct {
+	Mapping *MappingRule `parser:"@@"`
+}
+
+/*
 // Grammar represents the root of our grammar
 type Grammar struct {
-	Token *TokenExpr `parser:"@@"`
+	Token   *TokenExpr   `parser:"  @@"`
+	Mapping *MappingRule `parser:"| @@"`
+}*/
+
+// MappingRule represents a mapping between two token expressions
+type MappingRule struct {
+	Upper *TokenExpr `parser:"@@"`
+	Lower *TokenExpr `parser:"'<>' @@"`
 }
 
 // TokenExpr represents a token expression in square brackets
@@ -86,27 +105,37 @@
 func NewGrammarParser(defaultFoundry, defaultLayer string) (*GrammarParser, error) {
 	lex := lexer.MustSimple([]lexer.SimpleRule{
 		{Name: "Ident", Pattern: `[a-zA-Z][a-zA-Z0-9_]*`},
-		{Name: "Punct", Pattern: `[\[\]()&\|=:/]`},
+		{Name: "Punct", Pattern: `[\[\]()&\|=:/]|<>`},
 		{Name: "Whitespace", Pattern: `\s+`},
 	})
 
-	parser, err := participle.Build[Grammar](
+	tokenParser, err := participle.Build[TokenGrammar](
 		participle.Lexer(lex),
 		participle.UseLookahead(2),
 		participle.Elide("Whitespace"),
 	)
 	if err != nil {
-		return nil, fmt.Errorf("failed to build parser: %w", err)
+		return nil, fmt.Errorf("failed to build token parser: %w", err)
+	}
+
+	mappingParser, err := participle.Build[MappingGrammar](
+		participle.Lexer(lex),
+		participle.UseLookahead(2),
+		participle.Elide("Whitespace"),
+	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to build mapping parser: %w", err)
 	}
 
 	return &GrammarParser{
 		defaultFoundry: defaultFoundry,
 		defaultLayer:   defaultLayer,
-		parser:         parser,
+		tokenParser:    tokenParser,
+		mappingParser:  mappingParser,
 	}, nil
 }
 
-// Parse parses a grammar string into an AST node
+// Parse parses a grammar string into an AST node (for backward compatibility)
 func (p *GrammarParser) Parse(input string) (ast.Node, error) {
 	// Remove extra spaces around operators to help the parser
 	input = strings.ReplaceAll(input, " & ", "&")
@@ -119,11 +148,15 @@
 	// Remove any extra spaces
 	input = strings.TrimSpace(input)
 
-	grammar, err := p.parser.ParseString("", input)
+	grammar, err := p.tokenParser.ParseString("", input)
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse grammar: %w", err)
 	}
 
+	if grammar.Token == nil {
+		return nil, fmt.Errorf("expected token expression, got mapping rule")
+	}
+
 	wrap, err := p.parseExpr(grammar.Token.Expr)
 	if err != nil {
 		return nil, err
@@ -131,6 +164,51 @@
 	return &ast.Token{Wrap: wrap}, nil
 }
 
+// ParseMapping parses a mapping rule string into a MappingResult
+func (p *GrammarParser) ParseMapping(input string) (*MappingResult, error) {
+	// Remove extra spaces around operators to help the parser
+	input = strings.ReplaceAll(input, " & ", "&")
+	input = strings.ReplaceAll(input, " | ", "|")
+	input = strings.ReplaceAll(input, " <> ", "<>")
+
+	// Add spaces around parentheses to help the parser
+	input = strings.ReplaceAll(input, "(", " ( ")
+	input = strings.ReplaceAll(input, ")", " ) ")
+
+	// Remove any extra spaces
+	input = strings.TrimSpace(input)
+
+	grammar, err := p.mappingParser.ParseString("", input)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse grammar: %w", err)
+	}
+
+	if grammar.Mapping == nil {
+		return nil, fmt.Errorf("expected mapping rule, got token expression")
+	}
+
+	upper, err := p.parseExpr(grammar.Mapping.Upper.Expr)
+	if err != nil {
+		return nil, err
+	}
+
+	lower, err := p.parseExpr(grammar.Mapping.Lower.Expr)
+	if err != nil {
+		return nil, err
+	}
+
+	return &MappingResult{
+		Upper: &ast.Token{Wrap: upper},
+		Lower: &ast.Token{Wrap: lower},
+	}, nil
+}
+
+// MappingResult represents the parsed mapping rule
+type MappingResult struct {
+	Upper *ast.Token
+	Lower *ast.Token
+}
+
 // parseExpr builds the AST from the parsed Expr
 func (p *GrammarParser) parseExpr(expr *Expr) (ast.Node, error) {
 	var operands []ast.Node
diff --git a/pkg/parser/grammar_parser_test.go b/pkg/parser/grammar_parser_test.go
index 62d16c0..f076ef0 100644
--- a/pkg/parser/grammar_parser_test.go
+++ b/pkg/parser/grammar_parser_test.go
@@ -74,12 +74,13 @@
 			parser, err := NewGrammarParser(tt.defaultFoundry, tt.defaultLayer)
 			require.NoError(t, err)
 
-			grammar, err := parser.parser.ParseString("", tt.input)
+			grammar, err := parser.tokenParser.ParseString("", tt.input)
 			if tt.expectError {
 				assert.Error(t, err)
 				return
 			}
 			require.NoError(t, err)
+			require.NotNil(t, grammar.Token, "Expected token expression")
 			assert.Equal(t, tt.expected, grammar.Token.Expr.First.Simple)
 		})
 	}
@@ -216,3 +217,98 @@
 		})
 	}
 }
+
+func TestMappingRules(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected *MappingResult
+		wantErr  bool
+	}{
+		{
+			name:  "Simple PIDAT mapping",
+			input: "[PIDAT] <> [opennlp/p=PIDAT & opennlp/p=AdjType:Pdt]",
+			expected: &MappingResult{
+				Upper: &ast.Token{
+					Wrap: &ast.Term{
+						Key:   "PIDAT",
+						Match: ast.MatchEqual,
+					},
+				},
+				Lower: &ast.Token{
+					Wrap: &ast.TermGroup{
+						Relation: ast.AndRelation,
+						Operands: []ast.Node{
+							&ast.Term{
+								Foundry: "opennlp",
+								Layer:   "p",
+								Key:     "PIDAT",
+								Match:   ast.MatchEqual,
+							},
+							&ast.Term{
+								Foundry: "opennlp",
+								Layer:   "p",
+								Key:     "AdjType",
+								Value:   "Pdt",
+								Match:   ast.MatchEqual,
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			name:  "PAV mapping",
+			input: "[PAV] <> [ADV & PronType:Dem]",
+			expected: &MappingResult{
+				Upper: &ast.Token{
+					Wrap: &ast.Term{
+						Key:   "PAV",
+						Match: ast.MatchEqual,
+					},
+				},
+				Lower: &ast.Token{
+					Wrap: &ast.TermGroup{
+						Relation: ast.AndRelation,
+						Operands: []ast.Node{
+							&ast.Term{
+								Key:   "ADV",
+								Match: ast.MatchEqual,
+							},
+							&ast.Term{
+								Key:   "PronType",
+								Value: "Dem",
+								Match: ast.MatchEqual,
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			name:    "Invalid mapping syntax",
+			input:   "[PAV] -> [ADV]",
+			wantErr: true,
+		},
+		{
+			name:    "Missing closing bracket",
+			input:   "[PAV <> [ADV]",
+			wantErr: true,
+		},
+	}
+
+	parser, err := NewGrammarParser("", "")
+	assert.NoError(t, err)
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := parser.ParseMapping(tt.input)
+			if tt.wantErr {
+				assert.Error(t, err)
+				return
+			}
+			assert.NoError(t, err)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}