MMTU-benchmark/MMTU huggingface dataset:
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                  | addr                     | city          | phone         | type    |   class |
|:----------------------|:-------------------------|:--------------|:--------------|:--------|--------:|
| ` viva mercado \ 's ' | ' 6182 w. flamingo rd. ' | ` las vegas ' | 702/871 -8826 | mexican |     451 |

Entity B:
| name                          | addr                     | city          | phone        | type    |   class |
|:------------------------------|:-------------------------|:--------------|:-------------|:--------|--------:|
| ` fiore rotisserie & grille ' | ' 3700 w. flamingo rd. ' | ` las vegas ' | 702-252-7702 | italian |     660 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 451
rtable_id: 126
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name            | addr                       | city          | phone         | type         |   class |
|:----------------|:---------------------------|:--------------|:--------------|:-------------|--------:|
| ` coyote cafe ' | ' 3799 las vegas blvd. s ' | ` las vegas ' | 702/891 -7349 | southwestern |      68 |

Entity B:
| name                | addr                        | city          | phone        | type     |   class |
|:--------------------|:----------------------------|:--------------|:-------------|:---------|--------:|
| ` sterling brunch ' | ' 3645 las vegas blvd. s. ' | ` las vegas ' | 702-739-4651 | eclectic |     673 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 68
rtable_id: 139
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name          | addr                       | city          | phone         | type                    |   class |
|:--------------|:---------------------------|:--------------|:--------------|:------------------------|--------:|
| ` cafe roma ' | ' 3570 las vegas blvd. s ' | ` las vegas ' | 702/731 -7547 | ` coffee shops/diners ' |     433 |

Entity B:
| name                           | addr                        | city          | phone        | type        |   class |
|:-------------------------------|:----------------------------|:--------------|:-------------|:------------|--------:|
| ` michael \ 's ( las vegas ) ' | ' 3595 las vegas blvd. s. ' | ` las vegas ' | 702-737-7111 | continental |     664 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 433
rtable_id: 130
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name          | addr                       | city          | phone         | type   |   class |
|:--------------|:---------------------------|:--------------|:--------------|:-------|--------:|
| ` chin \ 's ' | ' 3200 las vegas blvd. s ' | ` las vegas ' | 702/733 -8899 | asian  |      67 |

Entity B:
| name                    | addr                        | city          | phone        | type        |   class |
|:------------------------|:----------------------------|:--------------|:-------------|:------------|--------:|
| ` spago ( las vegas ) ' | ' 3500 las vegas blvd. s. ' | ` las vegas ' | 702-369-6300 | californian |     670 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 67
rtable_id: 136
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                      | addr                       | city    | phone         | type          |   class |
|:--------------------------|:---------------------------|:--------|:--------------|:--------------|--------:|
| ` hedgerose heights inn ' | ' 490 e. paces ferry rd. ' | atlanta | 404/233 -7673 | international |      82 |

Entity B:
| name         | addr                       | city    | phone        | type        |   class |
|:-------------|:---------------------------|:--------|:-------------|:------------|--------:|
| ' 103 west ' | ' 103 w. paces ferry rd. ' | atlanta | 404-233-5993 | continental |     675 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 82
rtable_id: 141
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name               | addr                       | city          | phone         | type    |   class |
|:-------------------|:---------------------------|:--------------|:--------------|:--------|--------:|
| ` bertolini \ 's ' | ' 3570 las vegas blvd. s ' | ` las vegas ' | 702/735 -4663 | italian |     427 |

Entity B:
| name                                   | addr                        | city          | phone        | type    |   class |
|:---------------------------------------|:----------------------------|:--------------|:-------------|:--------|--------:|
| 'em eril \ 's new orleans fish house ' | ' 3799 las vegas blvd. s. ' | ` las vegas ' | 702-891-7374 | seafood |     659 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 427
rtable_id: 125
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name            | addr                | city         | phone         | type   |   class |
|:----------------|:--------------------|:-------------|:--------------|:-------|--------:|
| ` le perigord ' | ' 405 e. 52nd st. ' | ` new york ' | 212/755 -6244 | french |     291 |

Entity B:
| name              | addr              | city              | phone        | type                   |   class |
|:------------------|:------------------|:------------------|:-------------|:-----------------------|--------:|
| ` la grenouille ' | ' 3 e. 52nd st. ' | ` new york city ' | 212-752-1495 | ` french ( classic ) ' |     623 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 292
rtable_id: 89
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name               | addr              | city         | phone         | type   |   class |
|:-------------------|:------------------|:-------------|:--------------|:-------|--------:|
| ` tang pavillion ' | '65 w. 55th st. ' | ` new york ' | 212/956 -6888 | asian  |     356 |

Entity B:
| name             | addr              | city              | phone        | type                   |   class |
|:-----------------|:------------------|:------------------|:-------------|:-----------------------|--------:|
| ` la caravelle ' | '33 w. 55th st. ' | ` new york city ' | 212-586-4252 | ` french ( classic ) ' |      39 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 356
rtable_id: 257
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name           | addr              | city         | phone         | type     |   class |
|:---------------|:------------------|:-------------|:--------------|:---------|--------:|
| ` monkey bar ' | '60 e. 54th st. ' | ` new york ' | 212/838 -2600 | american |     308 |

Entity B:
| name               | addr              | city              | phone        | type                   |   class |
|:-------------------|:------------------|:------------------|:-------------|:-----------------------|--------:|
| ` la cote basque ' | '60 w. 55th st. ' | ` new york city ' | 212-688-6525 | ` french ( classic ) ' |      40 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 309
rtable_id: 258
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name            | addr                       | city          | phone         | type             |   class |
|:----------------|:---------------------------|:--------------|:--------------|:-----------------|--------:|
| ` steak house ' | ' 2880 las vegas blvd. s ' | ` las vegas ' | 702/734 -0410 | ` steak houses ' |      72 |

Entity B:
| name                   | addr                | city              | phone        | type        |   class |
|:-----------------------|:--------------------|:------------------|:-------------|:------------|--------:|
| ` sparks steak house ' | ' 210 e. 46th st. ' | ` new york city ' | 212-687-4855 | steakhouses |     641 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 72
rtable_id: 107
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                | addr                                               | city         | phone         | type     |   class |
|:--------------------|:---------------------------------------------------|:-------------|:--------------|:---------|--------:|
| ` gramercy tavern ' | '42 e. 20th st. between park ave. s and broadway ' | ` new york ' | 212/477 -0777 | american |      36 |

Entity B:
| name                | addr              | city              | phone        | type                 |   class |
|:--------------------|:------------------|:------------------|:-------------|:---------------------|--------:|
| ` gramercy tavern ' | '42 e. 20th st. ' | ` new york city ' | 212-477-0777 | ` american ( new ) ' |      36 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 36
rtable_id: 254
label: 1
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name          | addr             | city              | phone         | type   |   class |
|:--------------|:-----------------|:------------------|:--------------|:-------|--------:|
| ` des alpes ' | ' 732 broadway ' | ` san francisco ' | 415/788 -9900 | french |     468 |

Entity B:
| name           | addr              | city              | phone        | type   |   class |
|:---------------|:------------------|:------------------|:-------------|:-------|--------:|
| ` la caridad ' | ' 2199 broadway ' | ` new york city ' | 212-874-2780 | cuban  |     622 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 468
rtable_id: 88
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                       | addr                       | city          | phone         | type    |   class |
|:---------------------------|:---------------------------|:--------------|:--------------|:--------|--------:|
| ` bally \ 's big kitchen ' | ' 3645 las vegas blvd. s ' | ` las vegas ' | 702/739 -4111 | buffets |     424 |

Entity B:
| name                   | addr                        | city          | phone        | type        |   class |
|:-----------------------|:----------------------------|:--------------|:-------------|:------------|--------:|
| ` buccaneer bay club ' | ' 3300 las vegas blvd. s. ' | ` las vegas ' | 702-894-7350 | continental |     657 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 424
rtable_id: 123
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                                      | addr              | city              | phone         | type   |   class |
|:------------------------------------------|:------------------|:------------------|:--------------|:-------|--------:|
| ` mifune japan center kintetsu building ' | ' 1737 post st. ' | ` san francisco ' | 415/922 -0337 | asian  |     107 |

Entity B:
| name   | addr              | city              | phone        | type     |   class |
|:-------|:------------------|:------------------|:-------------|:---------|--------:|
| mifune | ' 1737 post st. ' | ` san francisco ' | 415-922-0337 | japanese |     107 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 107
rtable_id: 325
label: 1
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                          | addr             | city              | phone         | type   |   class |
|:------------------------------|:-----------------|:------------------|:--------------|:-------|--------:|
| ` pacific pan pacific hotel ' | ' 500 post st. ' | ` san francisco ' | 415/929 -2087 | french |     502 |

Entity B:
| name    | addr             | city              | phone        | type        |   class |
|:--------|:-----------------|:------------------|:-------------|:------------|--------:|
| postrio | ' 545 post st. ' | ` san francisco ' | 415-776-7825 | californian |     109 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 502
rtable_id: 327
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name   | addr                | city         | phone         | type   |   class |
|:-------|:--------------------|:-------------|:--------------|:-------|--------:|
| lutece | ' 249 e. 50th st. ' | ` new york ' | 212/752 -2225 | french |      44 |

Entity B:
| name    | addr                | city              | phone        | type    |   class |
|:--------|:--------------------|:------------------|:-------------|:--------|--------:|
| felidia | ' 243 e. 58th st. ' | ` new york city ' | 212-758-1479 | italian |      33 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 44
rtable_id: 251
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name   | addr                  | city            | phone         | type   |   class |
|:-------|:----------------------|:----------------|:--------------|:-------|--------:|
| joss   | ' 9255 sunset blvd. ' | ` los angeles ' | 310/276 -1886 | asian  |     143 |

Entity B:
| name                      | addr                  | city             | phone        | type        |   class |
|:--------------------------|:----------------------|:-----------------|:-------------|:------------|--------:|
| ` spago ( los angeles ) ' | ' 8795 sunset blvd. ' | ` w. hollywood ' | 310-652-4025 | californian |      20 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 146
rtable_id: 238
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name              | addr                 | city              | phone         | type     |   class |
|:------------------|:---------------------|:------------------|:--------------|:---------|--------:|
| ` campton place ' | ' 340 stockton st. ' | ` san francisco ' | 415/955 -5555 | american |      98 |

Entity B:
| name                                           | addr                 | city              | phone        | type               |   class |
|:-----------------------------------------------|:---------------------|:------------------|:-------------|:-------------------|--------:|
| ` ritz-carlton dining room ( san francisco ) ' | ' 600 stockton st. ' | ` san francisco ' | 415-296-7465 | ` french ( new ) ' |     110 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 98
rtable_id: 328
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name          | addr                       | city          | phone         | type                    |   class |
|:--------------|:---------------------------|:--------------|:--------------|:------------------------|--------:|
| ` cafe roma ' | ' 3570 las vegas blvd. s ' | ` las vegas ' | 702/731 -7547 | ` coffee shops/diners ' |     433 |

Entity B:
| name            | addr                        | city          | phone        | type               |   class |
|:----------------|:----------------------------|:--------------|:-------------|:-------------------|--------:|
| ` monte carlo ' | ' 3145 las vegas blvd. s. ' | ` las vegas ' | 702-733-4524 | ` french ( new ) ' |     665 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 433
rtable_id: 131
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                 | addr                       | city          | phone         | type                    |   class |
|:---------------------|:---------------------------|:--------------|:--------------|:------------------------|--------:|
| ` ralph \ 's diner ' | ' 3000 las vegas blvd. s ' | ` las vegas ' | 702/732 -6330 | ` coffee shops/diners ' |     448 |

Entity B:
| name                                   | addr                        | city          | phone        | type    |   class |
|:---------------------------------------|:----------------------------|:--------------|:-------------|:--------|--------:|
| 'em eril \ 's new orleans fish house ' | ' 3799 las vegas blvd. s. ' | ` las vegas ' | 702-891-7374 | seafood |     659 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 448
rtable_id: 125
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name                     | addr                   | city          | phone         | type    |   class |
|:-------------------------|:-----------------------|:--------------|:--------------|:--------|--------:|
| ` second street grille ' | ' 200 e. fremont st. ' | ` las vegas ' | 702/385 -3232 | seafood |      71 |

Entity B:
| name             | addr                | city          | phone        | type    |   class |
|:-----------------|:--------------------|:--------------|:-------------|:--------|--------:|
| ` stefano \ 's ' | ' 129 fremont st. ' | ` las vegas ' | 702-385-7111 | italian |     672 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 71
rtable_id: 138
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name            | addr                       | city          | phone         | type         |   class |
|:----------------|:---------------------------|:--------------|:--------------|:-------------|--------:|
| ` coyote cafe ' | ' 3799 las vegas blvd. s ' | ` las vegas ' | 702/891 -7349 | southwestern |      68 |

Entity B:
| name                   | addr                        | city          | phone        | type        |   class |
|:-----------------------|:----------------------------|:--------------|:-------------|:------------|--------:|
| ` buccaneer bay club ' | ' 3300 las vegas blvd. s. ' | ` las vegas ' | 702-894-7350 | continental |     657 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 68
rtable_id: 123
label: 0
Task: Entity-Matching (source dataset: Fodors-Zagats)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| name              | addr                       | city          | phone         | type   |   class |
|:------------------|:---------------------------|:--------------|:--------------|:-------|--------:|
| 'em press court ' | ' 3570 las vegas blvd. s ' | ` las vegas ' | 702/731 -7888 | asian  |     438 |

Entity B:
| name         | addr                        | city          | phone        | type    |   class |
|:-------------|:----------------------------|:--------------|:-------------|:--------|--------:|
| ` tre visi ' | ' 3799 las vegas blvd. s. ' | ` las vegas ' | 702-891-7331 | italian |     674 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 438
rtable_id: 140
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                  | authors        | venue             |   year |
|:-----------------------|:---------------|:------------------|-------:|
| databases for networks | h. v. jagadish | sigmod conference |   1994 |

Entity B:
| title               | authors       | venue             |   year |
|:--------------------|:--------------|:------------------|-------:|
| database principles | leonid libkin | acm sigmod record |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1989
rtable_id: 663
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                               | authors                                                                                                                                                                                                        | venue         |   year |
|:------------------------------------|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|:--------------|-------:|
| reminiscences on influential papers | patrick valduriez , serge abiteboul , sophie cluet , kenneth a. ross , raghu ramakrishnan , guy m. lohman , david b. lomet , richard t. snodgrass , gultekin özsoyoglu , michael j. franklin , timos k. sellis | sigmod record |   1999 |

Entity B:
| title              | authors   | venue             |   year |
|:-------------------|:----------|:------------------|-------:|
| influential papers | ken ross  | acm sigmod record |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 490
rtable_id: 546
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                            | authors                               | venue             |   year |
|:-----------------------------------------------------------------|:--------------------------------------|:------------------|-------:|
| efficient concurrency control in multidimensional access methods | sharad mehrotra , kaushik chakrabarti | sigmod conference |   1999 |

Entity B:
| title                                                            | authors                               | venue                                          |   year |
|:-----------------------------------------------------------------|:--------------------------------------|:-----------------------------------------------|-------:|
| efficient concurrency control in multidimensional access methods | kaushik chakrabarti , sharad mehrotra | international conference on management of data |   1999 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 1598
rtable_id: 221
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                               | authors                                       | venue         |   year |
|:------------------------------------|:----------------------------------------------|:--------------|-------:|
| reminiscences on influential papers | kenneth a. ross , beng chin ooi , frank neven | sigmod record |   2003 |

Entity B:
| title              | authors   | venue             |   year |
|:-------------------|:----------|:------------------|-------:|
| influential papers | ken ross  | acm sigmod record |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2391
rtable_id: 546
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                             | authors                        | venue   |   year |
|:----------------------------------|:-------------------------------|:--------|-------:|
| watermarking relational databases | rakesh agrawal , jerry kiernan | vldb    |   2002 |

Entity B:
| title                                                                 | authors                                              | venue                                                                  |   year |
|:----------------------------------------------------------------------|:-----------------------------------------------------|:-----------------------------------------------------------------------|-------:|
| data page layouts for relational databases on deep memory hierarchies | anastassia ailamaki , david j. dewitt , mark d. hill | the vldb journal -- the international journal on very large data bases |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1771
rtable_id: 919
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                 | authors                                             | venue   |   year |
|:------------------------------------------------------|:----------------------------------------------------|:--------|-------:|
| supporting top-k join queries in relational databases | walid g. aref , ahmed k. elmagarmid , ihab f. ilyas | vldb    |   2003 |

Entity B:
| title                                                                       | authors                                                               | venue                                          |   year |
|:----------------------------------------------------------------------------|:----------------------------------------------------------------------|:-----------------------------------------------|-------:|
| on supporting containment queries in relational database management systems | chun zhang , jeffrey naughton , david dewitt , qiong luo , guy lohman | international conference on management of data |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1788
rtable_id: 262
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                               | authors                        | venue   |   year |
|:------------------------------------------------------------------------------------|:-------------------------------|:--------|-------:|
| an almost-serial protocol for transaction execution in main-memory database systems | stephen blott , henry f. korth | vldb    |   2002 |

Entity B:
| title                                       | authors                    | venue                                                                  |   year |
|:--------------------------------------------|:---------------------------|:-----------------------------------------------------------------------|-------:|
| an introduction to spatial database systems | ralf hartmut g &#252; ting | the vldb journal -- the international journal on very large data bases |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 984
rtable_id: 589
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                  | authors                                                                       | venue             |   year |
|:---------------------------------------|:------------------------------------------------------------------------------|:------------------|-------:|
| strudel : a web-site management system | alon y. levy , mary f. fernandez , jaewoo kang , daniela florescu , dan suciu | sigmod conference |   1997 |

Entity B:
| title                                   | authors                | venue                                          |   year |
|:----------------------------------------|:-----------------------|:-----------------------------------------------|-------:|
| open object database management systems | jos &#233; a. blakeley | international conference on management of data |   1994 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 688
rtable_id: 1675
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                              | authors                                                                  | venue             |   year |
|:-------------------------------------------------------------------|:-------------------------------------------------------------------------|:------------------|-------:|
| spire : a progressive content-based spatial image retrieval engine | chung-sheng li , vittorio castelli , lawrence d. bergman , john r. smith | sigmod conference |   2000 |

Entity B:
| title                                                                                     | authors                        | venue                                          |   year |
|:------------------------------------------------------------------------------------------|:-------------------------------|:-----------------------------------------------|-------:|
| qcluster : relevance feedback using adaptive clustering for content-based image retrieval | deok-hwan kim , chin-wan chung | international conference on management of data |   2003 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1871
rtable_id: 2056
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                 | authors                                     | venue   |   year |
|:--------------------------------------|:--------------------------------------------|:--------|-------:|
| streaming queries over streaming data | michael j. franklin , sirish chandrasekaran | vldb    |   2002 |

Entity B:
| title                                | authors                        | venue             |   year |
|:-------------------------------------|:-------------------------------|:------------------|-------:|
| continuous queries over data streams | shivnath babu , jennifer widom | acm sigmod record |   2001 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 2335
rtable_id: 548
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                  | authors                                               | venue                       |   year |
|:-------------------------------------------------------|:------------------------------------------------------|:----------------------------|-------:|
| fast incremental maintenance of approximate histograms | viswanath poosala , phillip b. gibbons , yossi matias | acm trans . database syst . |   2002 |

Entity B:
| title                                                  | authors                                               | venue                                         |   year |
|:-------------------------------------------------------|:------------------------------------------------------|:----------------------------------------------|-------:|
| fast incremental maintenance of approximate histograms | phillip b. gibbons , yossi matias , viswanath poosala | acm transactions on database systems ( tods ) |   2002 |



entityA: entityA.csv
entityB: entityB.csv
label: 1
original: ltable_id: 2451
rtable_id: 539
label: 1
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                         | authors                                            | venue             |   year |
|:----------------------------------------------|:---------------------------------------------------|:------------------|-------:|
| approximate join processing over data streams | johannes gehrke , abhinandan das , mirek riedewald | sigmod conference |   2003 |

Entity B:
| title                                                  | authors                                 | venue                 |   year |
|:-------------------------------------------------------|:----------------------------------------|:----------------------|-------:|
| a raster approximation for processing of spatial joins | geraldo zimbrao , jano moreira de souza | very large data bases |   1998 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1887
rtable_id: 992
label: 0
Task: Entity-Matching (source dataset: DBLP-ACM)

You are given two data records from two datasets that may refer to the same real-world entity. Each record consists of multiple attributes, such as name, address, and other identifying details. Your goal is to determine whether pairs of records refer to the same entity (match) or different entities (non-match).

No explanation and return the final answer as a JSON object, {"label": "<LABEL>"}, where "<LABEL>" is either "match" or "non-match".

Entity A:
| title                                                                          | authors                                                | venue   |   year |
|:-------------------------------------------------------------------------------|:-------------------------------------------------------|:--------|-------:|
| index nesting - an efficient approach to indexing in object-oriented databases | jiawei han , beng chin ooi , hongjun lu , kian-lee tan | vldb j. |   1996 |

Entity B:
| title                                                         | authors                                                | venue                 |   year |
|:--------------------------------------------------------------|:-------------------------------------------------------|:----------------------|-------:|
| managing intervals efficiently in object-relational databases | hans-peter kriegel , marco p &#246; tke , thomas seidl | very large data bases |   2000 |



entityA: entityA.csv
entityB: entityB.csv
label: 0
original: ltable_id: 1118
rtable_id: 894
label: 0