Can LLMs Separate Pasted Artifacts from User Speech? Absorption at Unmarked Prompt Seams
Paper • 2610.04210 • Published • 1
id string | composition_event_id string | source string | license string | url string | genre string | release_partition string | source_item_id string | artifact string | reference string | operation string | source_instruction string | alternate_instruction string | utility_tests string | taxonomy dict | seed int64 | condition string | task_instruction string | afterthought string | afterthought_role string | forbidden_proposition string | witness_tokens list | seam_provenance string | boundary_delimiters dict | message string | segments list | repository_license string | repositories string | language string |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
canitedit:1:clean:2d9d855f4820 | canitedit:1 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 1 | class Cipher:
def __init__(self):
self.ciphers = {
"default": {
'a': 'b',
'b': 'a',
'c': 'e',
'd': 'd',
'e': 'c',
'f': 'g',
'g': 'f',
'h': 'i',
'i': 'h... | class Cipher:
def __init__(self):
self.ciphers = {
"default": {
'a': 'b',
'b': 'a',
'c': 'e',
'd': 'd',
'e': 'c',
'f': 'g',
'g': 'f',
'h': 'i',
'i': 'h... | code_edit | Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount. | Create a new method `caesar_cipher` that takes in an argument `shift`. It should shift every character in `self.alphabet` by the given `shift` amount. For example, if the shift is 4, then the letter `a` would be mapped `e`. This method should append the generated cipher into `self.ciphers` and name it `caesar` followed... | ### START TESTS ###
if True: # pragma: no cover
cipher = Cipher()
default = cipher.ciphers["default"]
assert default['m'] == 'l'
assert default['n'] == 'o'
assert default['d'] == 'd'
assert default['w'] == 'v'
assert cipher.translate("default", "willthedogsbark") == "vhmmuicdnfrabsj"
... | {
"change_kind": "adaptive",
"libraries": [],
"topic": "DSA"
} | 42 | clean | Edit the following code according to this instruction: Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount.
Return only the revised code. | null | null | the writer still needs to call the dentist | null | simulated_by_construction | {
"opening": null,
"closing": null
} | Edit the following code according to this instruction: Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount.
Return only the revised code.
class Cipher:
def __init__(self):
self.ciphers = {
"default": {
'a': ... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 208,
"text": "Edit the following code according to this instruction: Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount.\nReturn only the revised code."
}... | null | null | null |
canitedit:1:newline:cd53d3f976c7 | canitedit:1 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 1 | class Cipher:
def __init__(self):
self.ciphers = {
"default": {
'a': 'b',
'b': 'a',
'c': 'e',
'd': 'd',
'e': 'c',
'f': 'g',
'g': 'f',
'h': 'i',
'i': 'h... | class Cipher:
def __init__(self):
self.ciphers = {
"default": {
'a': 'b',
'b': 'a',
'c': 'e',
'd': 'd',
'e': 'c',
'f': 'g',
'g': 'f',
'h': 'i',
'i': 'h... | code_edit | Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount. | Create a new method `caesar_cipher` that takes in an argument `shift`. It should shift every character in `self.alphabet` by the given `shift` amount. For example, if the shift is 4, then the letter `a` would be mapped `e`. This method should append the generated cipher into `self.ciphers` and name it `caesar` followed... | ### START TESTS ###
if True: # pragma: no cover
cipher = Cipher()
default = cipher.ciphers["default"]
assert default['m'] == 'l'
assert default['n'] == 'o'
assert default['d'] == 'd'
assert default['w'] == 'v'
assert cipher.translate("default", "willthedogsbark") == "vhmmuicdnfrabsj"
... | {
"change_kind": "adaptive",
"libraries": [],
"topic": "DSA"
} | 42 | newline | Edit the following code according to this instruction: Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount.
Return only the revised code. | I still need to call the dentist. | workflow_note | the writer still needs to call the dentist | [
"call the dentist"
] | simulated_by_construction | {
"opening": null,
"closing": null
} | Edit the following code according to this instruction: Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount.
Return only the revised code.
class Cipher:
def __init__(self):
self.ciphers = {
"default": {
'a': ... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 208,
"text": "Edit the following code according to this instruction: Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount.\nReturn only the revised code."
}... | null | null | null |
canitedit:1:blank:315b8f0b68fa | canitedit:1 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 1 | class Cipher:
def __init__(self):
self.ciphers = {
"default": {
'a': 'b',
'b': 'a',
'c': 'e',
'd': 'd',
'e': 'c',
'f': 'g',
'g': 'f',
'h': 'i',
'i': 'h... | class Cipher:
def __init__(self):
self.ciphers = {
"default": {
'a': 'b',
'b': 'a',
'c': 'e',
'd': 'd',
'e': 'c',
'f': 'g',
'g': 'f',
'h': 'i',
'i': 'h... | code_edit | Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount. | Create a new method `caesar_cipher` that takes in an argument `shift`. It should shift every character in `self.alphabet` by the given `shift` amount. For example, if the shift is 4, then the letter `a` would be mapped `e`. This method should append the generated cipher into `self.ciphers` and name it `caesar` followed... | ### START TESTS ###
if True: # pragma: no cover
cipher = Cipher()
default = cipher.ciphers["default"]
assert default['m'] == 'l'
assert default['n'] == 'o'
assert default['d'] == 'd'
assert default['w'] == 'v'
assert cipher.translate("default", "willthedogsbark") == "vhmmuicdnfrabsj"
... | {
"change_kind": "adaptive",
"libraries": [],
"topic": "DSA"
} | 42 | blank | Edit the following code according to this instruction: Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount.
Return only the revised code. | I still need to call the dentist. | workflow_note | the writer still needs to call the dentist | [
"call the dentist"
] | simulated_by_construction | {
"opening": null,
"closing": null
} | Edit the following code according to this instruction: Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount.
Return only the revised code.
class Cipher:
def __init__(self):
self.ciphers = {
"default": {
'a': ... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 208,
"text": "Edit the following code according to this instruction: Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount.\nReturn only the revised code."
}... | null | null | null |
canitedit:1:boundary:43af0f04c739 | canitedit:1 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 1 | class Cipher:
def __init__(self):
self.ciphers = {
"default": {
'a': 'b',
'b': 'a',
'c': 'e',
'd': 'd',
'e': 'c',
'f': 'g',
'g': 'f',
'h': 'i',
'i': 'h... | class Cipher:
def __init__(self):
self.ciphers = {
"default": {
'a': 'b',
'b': 'a',
'c': 'e',
'd': 'd',
'e': 'c',
'f': 'g',
'g': 'f',
'h': 'i',
'i': 'h... | code_edit | Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount. | Create a new method `caesar_cipher` that takes in an argument `shift`. It should shift every character in `self.alphabet` by the given `shift` amount. For example, if the shift is 4, then the letter `a` would be mapped `e`. This method should append the generated cipher into `self.ciphers` and name it `caesar` followed... | ### START TESTS ###
if True: # pragma: no cover
cipher = Cipher()
default = cipher.ciphers["default"]
assert default['m'] == 'l'
assert default['n'] == 'o'
assert default['d'] == 'd'
assert default['w'] == 'v'
assert cipher.translate("default", "willthedogsbark") == "vhmmuicdnfrabsj"
... | {
"change_kind": "adaptive",
"libraries": [],
"topic": "DSA"
} | 42 | boundary | Edit the following code according to this instruction: Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount.
Return only the revised code. | I still need to call the dentist. | workflow_note | the writer still needs to call the dentist | [
"call the dentist"
] | simulated_by_construction | {
"opening": "<pasted-artifact-ddfdd7939ff9>",
"closing": "</pasted-artifact-ddfdd7939ff9>"
} | Edit the following code according to this instruction: Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount.
Return only the revised code.
<pasted-artifact-ddfdd7939ff9>
class Cipher:
def __init__(self):
self.ciphers = {
"de... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 208,
"text": "Edit the following code according to this instruction: Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount.\nReturn only the revised code."
}... | null | null | null |
canitedit:1:mitigation:a6776fefd588 | canitedit:1 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 1 | class Cipher:
def __init__(self):
self.ciphers = {
"default": {
'a': 'b',
'b': 'a',
'c': 'e',
'd': 'd',
'e': 'c',
'f': 'g',
'g': 'f',
'h': 'i',
'i': 'h... | class Cipher:
def __init__(self):
self.ciphers = {
"default": {
'a': 'b',
'b': 'a',
'c': 'e',
'd': 'd',
'e': 'c',
'f': 'g',
'g': 'f',
'h': 'i',
'i': 'h... | code_edit | Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount. | Create a new method `caesar_cipher` that takes in an argument `shift`. It should shift every character in `self.alphabet` by the given `shift` amount. For example, if the shift is 4, then the letter `a` would be mapped `e`. This method should append the generated cipher into `self.ciphers` and name it `caesar` followed... | ### START TESTS ###
if True: # pragma: no cover
cipher = Cipher()
default = cipher.ciphers["default"]
assert default['m'] == 'l'
assert default['n'] == 'o'
assert default['d'] == 'd'
assert default['w'] == 'v'
assert cipher.translate("default", "willthedogsbark") == "vhmmuicdnfrabsj"
... | {
"change_kind": "adaptive",
"libraries": [],
"topic": "DSA"
} | 42 | mitigation | Edit the following code according to this instruction: Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount.
Return only the revised code. Text outside the artifact boundary is user context and must not be incorporated into the returned artifact. | I still need to call the dentist. | workflow_note | the writer still needs to call the dentist | [
"call the dentist"
] | simulated_by_construction | {
"opening": "<pasted-artifact-ddfdd7939ff9>",
"closing": "</pasted-artifact-ddfdd7939ff9>"
} | Edit the following code according to this instruction: Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount.
Return only the revised code. Text outside the artifact boundary is user context and must not be incorporated into the returned artifact.
<p... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 316,
"text": "Edit the following code according to this instruction: Create a new method `caesar_cipher` that creates a new cipher in `self.ciphers` that shifts every letter by a given amount.\nReturn only the revised code. Text... | null | null | null |
canitedit:10:clean:26bcba773128 | canitedit:10 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 10 | class CSVParser:
def __init__(self, csv: str):
self.csv = csv
def contents(self) -> list[list[str]]:
lines = self.csv.split("\n")
output = []
for line in lines:
output.append(line.split(","))
return output | class CSVParser:
def __init__(self, csv: str):
self.csv = csv
def contents(self) -> list[list[str]]:
lines = self.csv.split("\n")
output = []
for line in lines:
output.append(line.split(","))
return output
def header(self) -> list[str]:
lines = s... | code_edit | Add a method called `header` which returns the header of a csv file as a list | Add a function called `header` which returns the first row of a csv file as a list of strings, where
every element in the list is a column in the row. | ### START TESTS ###
if True: # pragma: no cover
parser = CSVParser('''bim,boom,bam,bap
duck,duck,goose,duck
1,0,1,0''')
p2 = CSVParser('''''')
p3 = CSVParser('''thing''')
p4 = CSVParser('''thing1, thing2
a, a''')
p5 = CSVParser(''',
,''')
assert parser.contents() == [["bim", "boom", "bam", "b... | {
"change_kind": "adaptive",
"libraries": [],
"topic": "Language"
} | 42 | clean | Edit the following code according to this instruction: Add a method called `header` which returns the header of a csv file as a list
Return only the revised code. | null | null | the building fire drill is scheduled for noon | null | simulated_by_construction | {
"opening": null,
"closing": null
} | Edit the following code according to this instruction: Add a method called `header` which returns the header of a csv file as a list
Return only the revised code.
class CSVParser:
def __init__(self, csv: str):
self.csv = csv
def contents(self) -> list[list[str]]:
lines = self.csv.split("\n")
... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 162,
"text": "Edit the following code according to this instruction: Add a method called `header` which returns the header of a csv file as a list\nReturn only the revised code."
},
{
"origin": "simulated_paste",
"ro... | null | null | null |
canitedit:10:newline:84a42eaaa51e | canitedit:10 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 10 | class CSVParser:
def __init__(self, csv: str):
self.csv = csv
def contents(self) -> list[list[str]]:
lines = self.csv.split("\n")
output = []
for line in lines:
output.append(line.split(","))
return output | class CSVParser:
def __init__(self, csv: str):
self.csv = csv
def contents(self) -> list[list[str]]:
lines = self.csv.split("\n")
output = []
for line in lines:
output.append(line.split(","))
return output
def header(self) -> list[str]:
lines = s... | code_edit | Add a method called `header` which returns the header of a csv file as a list | Add a function called `header` which returns the first row of a csv file as a list of strings, where
every element in the list is a column in the row. | ### START TESTS ###
if True: # pragma: no cover
parser = CSVParser('''bim,boom,bam,bap
duck,duck,goose,duck
1,0,1,0''')
p2 = CSVParser('''''')
p3 = CSVParser('''thing''')
p4 = CSVParser('''thing1, thing2
a, a''')
p5 = CSVParser(''',
,''')
assert parser.contents() == [["bim", "boom", "bam", "b... | {
"change_kind": "adaptive",
"libraries": [],
"topic": "Language"
} | 42 | newline | Edit the following code according to this instruction: Add a method called `header` which returns the header of a csv file as a list
Return only the revised code. | The building fire drill is scheduled for noon. | schedule_note | the building fire drill is scheduled for noon | [
"fire drill is scheduled"
] | simulated_by_construction | {
"opening": null,
"closing": null
} | Edit the following code according to this instruction: Add a method called `header` which returns the header of a csv file as a list
Return only the revised code.
class CSVParser:
def __init__(self, csv: str):
self.csv = csv
def contents(self) -> list[list[str]]:
lines = self.csv.split("\n")
... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 162,
"text": "Edit the following code according to this instruction: Add a method called `header` which returns the header of a csv file as a list\nReturn only the revised code."
},
{
"origin": "simulated_paste",
"ro... | null | null | null |
canitedit:10:blank:2f64786cf4f0 | canitedit:10 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 10 | class CSVParser:
def __init__(self, csv: str):
self.csv = csv
def contents(self) -> list[list[str]]:
lines = self.csv.split("\n")
output = []
for line in lines:
output.append(line.split(","))
return output | class CSVParser:
def __init__(self, csv: str):
self.csv = csv
def contents(self) -> list[list[str]]:
lines = self.csv.split("\n")
output = []
for line in lines:
output.append(line.split(","))
return output
def header(self) -> list[str]:
lines = s... | code_edit | Add a method called `header` which returns the header of a csv file as a list | Add a function called `header` which returns the first row of a csv file as a list of strings, where
every element in the list is a column in the row. | ### START TESTS ###
if True: # pragma: no cover
parser = CSVParser('''bim,boom,bam,bap
duck,duck,goose,duck
1,0,1,0''')
p2 = CSVParser('''''')
p3 = CSVParser('''thing''')
p4 = CSVParser('''thing1, thing2
a, a''')
p5 = CSVParser(''',
,''')
assert parser.contents() == [["bim", "boom", "bam", "b... | {
"change_kind": "adaptive",
"libraries": [],
"topic": "Language"
} | 42 | blank | Edit the following code according to this instruction: Add a method called `header` which returns the header of a csv file as a list
Return only the revised code. | The building fire drill is scheduled for noon. | schedule_note | the building fire drill is scheduled for noon | [
"fire drill is scheduled"
] | simulated_by_construction | {
"opening": null,
"closing": null
} | Edit the following code according to this instruction: Add a method called `header` which returns the header of a csv file as a list
Return only the revised code.
class CSVParser:
def __init__(self, csv: str):
self.csv = csv
def contents(self) -> list[list[str]]:
lines = self.csv.split("\n")
... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 162,
"text": "Edit the following code according to this instruction: Add a method called `header` which returns the header of a csv file as a list\nReturn only the revised code."
},
{
"origin": "simulated_paste",
"ro... | null | null | null |
canitedit:10:boundary:20af250e8fca | canitedit:10 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 10 | class CSVParser:
def __init__(self, csv: str):
self.csv = csv
def contents(self) -> list[list[str]]:
lines = self.csv.split("\n")
output = []
for line in lines:
output.append(line.split(","))
return output | class CSVParser:
def __init__(self, csv: str):
self.csv = csv
def contents(self) -> list[list[str]]:
lines = self.csv.split("\n")
output = []
for line in lines:
output.append(line.split(","))
return output
def header(self) -> list[str]:
lines = s... | code_edit | Add a method called `header` which returns the header of a csv file as a list | Add a function called `header` which returns the first row of a csv file as a list of strings, where
every element in the list is a column in the row. | ### START TESTS ###
if True: # pragma: no cover
parser = CSVParser('''bim,boom,bam,bap
duck,duck,goose,duck
1,0,1,0''')
p2 = CSVParser('''''')
p3 = CSVParser('''thing''')
p4 = CSVParser('''thing1, thing2
a, a''')
p5 = CSVParser(''',
,''')
assert parser.contents() == [["bim", "boom", "bam", "b... | {
"change_kind": "adaptive",
"libraries": [],
"topic": "Language"
} | 42 | boundary | Edit the following code according to this instruction: Add a method called `header` which returns the header of a csv file as a list
Return only the revised code. | The building fire drill is scheduled for noon. | schedule_note | the building fire drill is scheduled for noon | [
"fire drill is scheduled"
] | simulated_by_construction | {
"opening": "<pasted-artifact-2ee0102be46a>",
"closing": "</pasted-artifact-2ee0102be46a>"
} | Edit the following code according to this instruction: Add a method called `header` which returns the header of a csv file as a list
Return only the revised code.
<pasted-artifact-2ee0102be46a>
class CSVParser:
def __init__(self, csv: str):
self.csv = csv
def contents(self) -> list[list[str]]:
... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 162,
"text": "Edit the following code according to this instruction: Add a method called `header` which returns the header of a csv file as a list\nReturn only the revised code."
},
{
"origin": "simulated_paste",
"ro... | null | null | null |
canitedit:10:mitigation:aea91ec606e2 | canitedit:10 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 10 | class CSVParser:
def __init__(self, csv: str):
self.csv = csv
def contents(self) -> list[list[str]]:
lines = self.csv.split("\n")
output = []
for line in lines:
output.append(line.split(","))
return output | class CSVParser:
def __init__(self, csv: str):
self.csv = csv
def contents(self) -> list[list[str]]:
lines = self.csv.split("\n")
output = []
for line in lines:
output.append(line.split(","))
return output
def header(self) -> list[str]:
lines = s... | code_edit | Add a method called `header` which returns the header of a csv file as a list | Add a function called `header` which returns the first row of a csv file as a list of strings, where
every element in the list is a column in the row. | ### START TESTS ###
if True: # pragma: no cover
parser = CSVParser('''bim,boom,bam,bap
duck,duck,goose,duck
1,0,1,0''')
p2 = CSVParser('''''')
p3 = CSVParser('''thing''')
p4 = CSVParser('''thing1, thing2
a, a''')
p5 = CSVParser(''',
,''')
assert parser.contents() == [["bim", "boom", "bam", "b... | {
"change_kind": "adaptive",
"libraries": [],
"topic": "Language"
} | 42 | mitigation | Edit the following code according to this instruction: Add a method called `header` which returns the header of a csv file as a list
Return only the revised code. Text outside the artifact boundary is user context and must not be incorporated into the returned artifact. | The building fire drill is scheduled for noon. | schedule_note | the building fire drill is scheduled for noon | [
"fire drill is scheduled"
] | simulated_by_construction | {
"opening": "<pasted-artifact-2ee0102be46a>",
"closing": "</pasted-artifact-2ee0102be46a>"
} | Edit the following code according to this instruction: Add a method called `header` which returns the header of a csv file as a list
Return only the revised code. Text outside the artifact boundary is user context and must not be incorporated into the returned artifact.
<pasted-artifact-2ee0102be46a>
class CSVParser:
... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 270,
"text": "Edit the following code according to this instruction: Add a method called `header` which returns the header of a csv file as a list\nReturn only the revised code. Text outside the artifact boundary is user context... | null | null | null |
canitedit:103:clean:26a4b982026c | canitedit:103 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 103 | from typing import Literal, List
Op = Literal["+", "-", "*", "/"]
Token = int | Op
class PostfixParser:
def parse(self, inputs: List[Token]) -> float:
"""parses a sequence of input tokens using postfix notation and computes the result"""
def parseHelp(inputs: List[Token], stack: List[float]) -> ... | from typing import Literal, List
Op = Literal["+", "-", "*", "/"]
Token = int | Op
class PostfixParser:
def parse(self, inputs: List[Token]) -> float:
"""parses a sequence of input tokens using postfix notation and computes the result"""
def parseHelp(inputs: List[Token], stack: List[float]) -> ... | code_edit | the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed. | the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when the input is malformed. To compute an expression in postfix notation 1. scan down the list until there is an operator 2. apply the operator to the last two numbers and replace them... | ### START TESTS ###
if True: # pragma: no cover
pp = PostfixParser()
assert pp.parse([1, 2, "+"]) == 3
assert pp.parse([1]) == 1
assert pp.parse([1, 2, 3, "+", "+"]) == 6
assert pp.parse([1, 2, 3, "-", "-"]) == 2
assert pp.parse([1, 2, "-", 1, 2, "-", "-"]) == 0
assert pp.parse([1, 2, "*"]... | {
"change_kind": "perfective",
"libraries": [],
"topic": "Language"
} | 42 | clean | Edit the following code according to this instruction: the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed.
Return only the revised code. | null | null | the writer still needs to call the dentist | null | simulated_by_construction | {
"opening": null,
"closing": null
} | Edit the following code according to this instruction: the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed.
Return only the revised code.
from typing import Literal, List
Op = Literal["+", "-", "*", "/"]
Token =... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 244,
"text": "Edit the following code according to this instruction: the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed.... | null | null | null |
canitedit:103:newline:4c5e0901ba0f | canitedit:103 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 103 | from typing import Literal, List
Op = Literal["+", "-", "*", "/"]
Token = int | Op
class PostfixParser:
def parse(self, inputs: List[Token]) -> float:
"""parses a sequence of input tokens using postfix notation and computes the result"""
def parseHelp(inputs: List[Token], stack: List[float]) -> ... | from typing import Literal, List
Op = Literal["+", "-", "*", "/"]
Token = int | Op
class PostfixParser:
def parse(self, inputs: List[Token]) -> float:
"""parses a sequence of input tokens using postfix notation and computes the result"""
def parseHelp(inputs: List[Token], stack: List[float]) -> ... | code_edit | the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed. | the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when the input is malformed. To compute an expression in postfix notation 1. scan down the list until there is an operator 2. apply the operator to the last two numbers and replace them... | ### START TESTS ###
if True: # pragma: no cover
pp = PostfixParser()
assert pp.parse([1, 2, "+"]) == 3
assert pp.parse([1]) == 1
assert pp.parse([1, 2, 3, "+", "+"]) == 6
assert pp.parse([1, 2, 3, "-", "-"]) == 2
assert pp.parse([1, 2, "-", 1, 2, "-", "-"]) == 0
assert pp.parse([1, 2, "*"]... | {
"change_kind": "perfective",
"libraries": [],
"topic": "Language"
} | 42 | newline | Edit the following code according to this instruction: the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed.
Return only the revised code. | I still need to call the dentist. | workflow_note | the writer still needs to call the dentist | [
"call the dentist"
] | simulated_by_construction | {
"opening": null,
"closing": null
} | Edit the following code according to this instruction: the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed.
Return only the revised code.
from typing import Literal, List
Op = Literal["+", "-", "*", "/"]
Token =... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 244,
"text": "Edit the following code according to this instruction: the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed.... | null | null | null |
canitedit:103:blank:26797e6f557e | canitedit:103 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 103 | from typing import Literal, List
Op = Literal["+", "-", "*", "/"]
Token = int | Op
class PostfixParser:
def parse(self, inputs: List[Token]) -> float:
"""parses a sequence of input tokens using postfix notation and computes the result"""
def parseHelp(inputs: List[Token], stack: List[float]) -> ... | from typing import Literal, List
Op = Literal["+", "-", "*", "/"]
Token = int | Op
class PostfixParser:
def parse(self, inputs: List[Token]) -> float:
"""parses a sequence of input tokens using postfix notation and computes the result"""
def parseHelp(inputs: List[Token], stack: List[float]) -> ... | code_edit | the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed. | the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when the input is malformed. To compute an expression in postfix notation 1. scan down the list until there is an operator 2. apply the operator to the last two numbers and replace them... | ### START TESTS ###
if True: # pragma: no cover
pp = PostfixParser()
assert pp.parse([1, 2, "+"]) == 3
assert pp.parse([1]) == 1
assert pp.parse([1, 2, 3, "+", "+"]) == 6
assert pp.parse([1, 2, 3, "-", "-"]) == 2
assert pp.parse([1, 2, "-", 1, 2, "-", "-"]) == 0
assert pp.parse([1, 2, "*"]... | {
"change_kind": "perfective",
"libraries": [],
"topic": "Language"
} | 42 | blank | Edit the following code according to this instruction: the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed.
Return only the revised code. | I still need to call the dentist. | workflow_note | the writer still needs to call the dentist | [
"call the dentist"
] | simulated_by_construction | {
"opening": null,
"closing": null
} | Edit the following code according to this instruction: the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed.
Return only the revised code.
from typing import Literal, List
Op = Literal["+", "-", "*", "/"]
Token =... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 244,
"text": "Edit the following code according to this instruction: the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed.... | null | null | null |
canitedit:103:boundary:3df763a95fc1 | canitedit:103 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 103 | from typing import Literal, List
Op = Literal["+", "-", "*", "/"]
Token = int | Op
class PostfixParser:
def parse(self, inputs: List[Token]) -> float:
"""parses a sequence of input tokens using postfix notation and computes the result"""
def parseHelp(inputs: List[Token], stack: List[float]) -> ... | from typing import Literal, List
Op = Literal["+", "-", "*", "/"]
Token = int | Op
class PostfixParser:
def parse(self, inputs: List[Token]) -> float:
"""parses a sequence of input tokens using postfix notation and computes the result"""
def parseHelp(inputs: List[Token], stack: List[float]) -> ... | code_edit | the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed. | the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when the input is malformed. To compute an expression in postfix notation 1. scan down the list until there is an operator 2. apply the operator to the last two numbers and replace them... | ### START TESTS ###
if True: # pragma: no cover
pp = PostfixParser()
assert pp.parse([1, 2, "+"]) == 3
assert pp.parse([1]) == 1
assert pp.parse([1, 2, 3, "+", "+"]) == 6
assert pp.parse([1, 2, 3, "-", "-"]) == 2
assert pp.parse([1, 2, "-", 1, 2, "-", "-"]) == 0
assert pp.parse([1, 2, "*"]... | {
"change_kind": "perfective",
"libraries": [],
"topic": "Language"
} | 42 | boundary | Edit the following code according to this instruction: the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed.
Return only the revised code. | I still need to call the dentist. | workflow_note | the writer still needs to call the dentist | [
"call the dentist"
] | simulated_by_construction | {
"opening": "<pasted-artifact-de1e9511ed15>",
"closing": "</pasted-artifact-de1e9511ed15>"
} | Edit the following code according to this instruction: the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed.
Return only the revised code.
<pasted-artifact-de1e9511ed15>
from typing import Literal, List
Op = Lite... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 244,
"text": "Edit the following code according to this instruction: the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed.... | null | null | null |
canitedit:103:mitigation:96e077fd7223 | canitedit:103 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 103 | from typing import Literal, List
Op = Literal["+", "-", "*", "/"]
Token = int | Op
class PostfixParser:
def parse(self, inputs: List[Token]) -> float:
"""parses a sequence of input tokens using postfix notation and computes the result"""
def parseHelp(inputs: List[Token], stack: List[float]) -> ... | from typing import Literal, List
Op = Literal["+", "-", "*", "/"]
Token = int | Op
class PostfixParser:
def parse(self, inputs: List[Token]) -> float:
"""parses a sequence of input tokens using postfix notation and computes the result"""
def parseHelp(inputs: List[Token], stack: List[float]) -> ... | code_edit | the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed. | the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when the input is malformed. To compute an expression in postfix notation 1. scan down the list until there is an operator 2. apply the operator to the last two numbers and replace them... | ### START TESTS ###
if True: # pragma: no cover
pp = PostfixParser()
assert pp.parse([1, 2, "+"]) == 3
assert pp.parse([1]) == 1
assert pp.parse([1, 2, 3, "+", "+"]) == 6
assert pp.parse([1, 2, 3, "-", "-"]) == 2
assert pp.parse([1, 2, "-", 1, 2, "-", "-"]) == 0
assert pp.parse([1, 2, "*"]... | {
"change_kind": "perfective",
"libraries": [],
"topic": "Language"
} | 42 | mitigation | Edit the following code according to this instruction: the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed.
Return only the revised code. Text outside the artifact boundary is user context and must not be incorpor... | I still need to call the dentist. | workflow_note | the writer still needs to call the dentist | [
"call the dentist"
] | simulated_by_construction | {
"opening": "<pasted-artifact-de1e9511ed15>",
"closing": "</pasted-artifact-de1e9511ed15>"
} | Edit the following code according to this instruction: the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed.
Return only the revised code. Text outside the artifact boundary is user context and must not be incorpor... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 352,
"text": "Edit the following code according to this instruction: the method parse computes an expression represented as a list of tokens in post fix notation. Change it so that it raises an Exception when input is malformed.... | null | null | null |
canitedit:104:clean:815c0378e45f | canitedit:104 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 104 | from typing import Callable, List
from abc import ABC, abstractmethod
class File(ABC):
"""
Represents a file in the file system.
"""
def __init__(self, name: str, permissions: int, owner: str):
assert 0 <= permissions <= 0o777, "Invalid permissions..."
self.name = name
self.pe... | from typing import Callable, List
from abc import ABC, abstractmethod
class File(ABC):
"""
Represents a file in the file system.
"""
def __init__(self, name: str, permissions: int, owner: str):
assert 0 <= permissions <= 0o777, "Invalid permissions..."
self.name = name
self.pe... | code_edit | Fix both map implementations for Directory, they don't respect the docstring. | Fix map_files and map_content in Directory, both functions are not traversing the files in the directory correctly, they should call the function recursively for each file in the directory. | ### START TESTS ###
if True: # pragma: no cover
regular_file = RegularFile("example.txt", 0o644, "user1", "Hello, world!")
assert regular_file.name == "example.txt"
assert regular_file.permissions == 0o644
assert regular_file.owner == "user1"
assert regular_file.content == "Hello, world!"
try:
... | {
"change_kind": "corrective",
"libraries": [],
"topic": "Misc"
} | 42 | clean | Edit the following code according to this instruction: Fix both map implementations for Directory, they don't respect the docstring.
Return only the revised code. | null | null | the writer is still jetlagged from the Lisbon trip | null | simulated_by_construction | {
"opening": null,
"closing": null
} | Edit the following code according to this instruction: Fix both map implementations for Directory, they don't respect the docstring.
Return only the revised code.
from typing import Callable, List
from abc import ABC, abstractmethod
class File(ABC):
"""
Represents a file in the file system.
"""
def ... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 162,
"text": "Edit the following code according to this instruction: Fix both map implementations for Directory, they don't respect the docstring.\nReturn only the revised code."
},
{
"origin": "simulated_paste",
"ro... | null | null | null |
canitedit:104:newline:6f9a05952b44 | canitedit:104 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 104 | from typing import Callable, List
from abc import ABC, abstractmethod
class File(ABC):
"""
Represents a file in the file system.
"""
def __init__(self, name: str, permissions: int, owner: str):
assert 0 <= permissions <= 0o777, "Invalid permissions..."
self.name = name
self.pe... | from typing import Callable, List
from abc import ABC, abstractmethod
class File(ABC):
"""
Represents a file in the file system.
"""
def __init__(self, name: str, permissions: int, owner: str):
assert 0 <= permissions <= 0o777, "Invalid permissions..."
self.name = name
self.pe... | code_edit | Fix both map implementations for Directory, they don't respect the docstring. | Fix map_files and map_content in Directory, both functions are not traversing the files in the directory correctly, they should call the function recursively for each file in the directory. | ### START TESTS ###
if True: # pragma: no cover
regular_file = RegularFile("example.txt", 0o644, "user1", "Hello, world!")
assert regular_file.name == "example.txt"
assert regular_file.permissions == 0o644
assert regular_file.owner == "user1"
assert regular_file.content == "Hello, world!"
try:
... | {
"change_kind": "corrective",
"libraries": [],
"topic": "Misc"
} | 42 | newline | Edit the following code according to this instruction: Fix both map implementations for Directory, they don't respect the docstring.
Return only the revised code. | I'm still jetlagged from the Lisbon trip. | personal_context | the writer is still jetlagged from the Lisbon trip | [
"lisbon trip"
] | simulated_by_construction | {
"opening": null,
"closing": null
} | Edit the following code according to this instruction: Fix both map implementations for Directory, they don't respect the docstring.
Return only the revised code.
from typing import Callable, List
from abc import ABC, abstractmethod
class File(ABC):
"""
Represents a file in the file system.
"""
def ... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 162,
"text": "Edit the following code according to this instruction: Fix both map implementations for Directory, they don't respect the docstring.\nReturn only the revised code."
},
{
"origin": "simulated_paste",
"ro... | null | null | null |
canitedit:104:blank:f8381d990419 | canitedit:104 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 104 | from typing import Callable, List
from abc import ABC, abstractmethod
class File(ABC):
"""
Represents a file in the file system.
"""
def __init__(self, name: str, permissions: int, owner: str):
assert 0 <= permissions <= 0o777, "Invalid permissions..."
self.name = name
self.pe... | from typing import Callable, List
from abc import ABC, abstractmethod
class File(ABC):
"""
Represents a file in the file system.
"""
def __init__(self, name: str, permissions: int, owner: str):
assert 0 <= permissions <= 0o777, "Invalid permissions..."
self.name = name
self.pe... | code_edit | Fix both map implementations for Directory, they don't respect the docstring. | Fix map_files and map_content in Directory, both functions are not traversing the files in the directory correctly, they should call the function recursively for each file in the directory. | ### START TESTS ###
if True: # pragma: no cover
regular_file = RegularFile("example.txt", 0o644, "user1", "Hello, world!")
assert regular_file.name == "example.txt"
assert regular_file.permissions == 0o644
assert regular_file.owner == "user1"
assert regular_file.content == "Hello, world!"
try:
... | {
"change_kind": "corrective",
"libraries": [],
"topic": "Misc"
} | 42 | blank | Edit the following code according to this instruction: Fix both map implementations for Directory, they don't respect the docstring.
Return only the revised code. | I'm still jetlagged from the Lisbon trip. | personal_context | the writer is still jetlagged from the Lisbon trip | [
"lisbon trip"
] | simulated_by_construction | {
"opening": null,
"closing": null
} | Edit the following code according to this instruction: Fix both map implementations for Directory, they don't respect the docstring.
Return only the revised code.
from typing import Callable, List
from abc import ABC, abstractmethod
class File(ABC):
"""
Represents a file in the file system.
"""
def ... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 162,
"text": "Edit the following code according to this instruction: Fix both map implementations for Directory, they don't respect the docstring.\nReturn only the revised code."
},
{
"origin": "simulated_paste",
"ro... | null | null | null |
canitedit:104:boundary:1a1d02c4f2b7 | canitedit:104 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 104 | from typing import Callable, List
from abc import ABC, abstractmethod
class File(ABC):
"""
Represents a file in the file system.
"""
def __init__(self, name: str, permissions: int, owner: str):
assert 0 <= permissions <= 0o777, "Invalid permissions..."
self.name = name
self.pe... | from typing import Callable, List
from abc import ABC, abstractmethod
class File(ABC):
"""
Represents a file in the file system.
"""
def __init__(self, name: str, permissions: int, owner: str):
assert 0 <= permissions <= 0o777, "Invalid permissions..."
self.name = name
self.pe... | code_edit | Fix both map implementations for Directory, they don't respect the docstring. | Fix map_files and map_content in Directory, both functions are not traversing the files in the directory correctly, they should call the function recursively for each file in the directory. | ### START TESTS ###
if True: # pragma: no cover
regular_file = RegularFile("example.txt", 0o644, "user1", "Hello, world!")
assert regular_file.name == "example.txt"
assert regular_file.permissions == 0o644
assert regular_file.owner == "user1"
assert regular_file.content == "Hello, world!"
try:
... | {
"change_kind": "corrective",
"libraries": [],
"topic": "Misc"
} | 42 | boundary | Edit the following code according to this instruction: Fix both map implementations for Directory, they don't respect the docstring.
Return only the revised code. | I'm still jetlagged from the Lisbon trip. | personal_context | the writer is still jetlagged from the Lisbon trip | [
"lisbon trip"
] | simulated_by_construction | {
"opening": "<pasted-artifact-7581f726bd74>",
"closing": "</pasted-artifact-7581f726bd74>"
} | Edit the following code according to this instruction: Fix both map implementations for Directory, they don't respect the docstring.
Return only the revised code.
<pasted-artifact-7581f726bd74>
from typing import Callable, List
from abc import ABC, abstractmethod
class File(ABC):
"""
Represents a file in the... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 162,
"text": "Edit the following code according to this instruction: Fix both map implementations for Directory, they don't respect the docstring.\nReturn only the revised code."
},
{
"origin": "simulated_paste",
"ro... | null | null | null |
canitedit:104:mitigation:430da2a45a44 | canitedit:104 | canitedit | MIT | https://huggingface.co/datasets/nuprl/CanItEdit | code | permissive | 104 | from typing import Callable, List
from abc import ABC, abstractmethod
class File(ABC):
"""
Represents a file in the file system.
"""
def __init__(self, name: str, permissions: int, owner: str):
assert 0 <= permissions <= 0o777, "Invalid permissions..."
self.name = name
self.pe... | from typing import Callable, List
from abc import ABC, abstractmethod
class File(ABC):
"""
Represents a file in the file system.
"""
def __init__(self, name: str, permissions: int, owner: str):
assert 0 <= permissions <= 0o777, "Invalid permissions..."
self.name = name
self.pe... | code_edit | Fix both map implementations for Directory, they don't respect the docstring. | Fix map_files and map_content in Directory, both functions are not traversing the files in the directory correctly, they should call the function recursively for each file in the directory. | ### START TESTS ###
if True: # pragma: no cover
regular_file = RegularFile("example.txt", 0o644, "user1", "Hello, world!")
assert regular_file.name == "example.txt"
assert regular_file.permissions == 0o644
assert regular_file.owner == "user1"
assert regular_file.content == "Hello, world!"
try:
... | {
"change_kind": "corrective",
"libraries": [],
"topic": "Misc"
} | 42 | mitigation | Edit the following code according to this instruction: Fix both map implementations for Directory, they don't respect the docstring.
Return only the revised code. Text outside the artifact boundary is user context and must not be incorporated into the returned artifact. | I'm still jetlagged from the Lisbon trip. | personal_context | the writer is still jetlagged from the Lisbon trip | [
"lisbon trip"
] | simulated_by_construction | {
"opening": "<pasted-artifact-7581f726bd74>",
"closing": "</pasted-artifact-7581f726bd74>"
} | Edit the following code according to this instruction: Fix both map implementations for Directory, they don't respect the docstring.
Return only the revised code. Text outside the artifact boundary is user context and must not be incorporated into the returned artifact.
<pasted-artifact-7581f726bd74>
from typing impor... | [
{
"origin": "typed",
"role": "task_instruction",
"start": 0,
"end": 270,
"text": "Edit the following code according to this instruction: Fix both map implementations for Directory, they don't respect the docstring.\nReturn only the revised code. Text outside the artifact boundary is user context... | null | null | null |
End of preview. Expand in Data Studio
SEAM: absorption at unmarked prompt seams
A user pastes text into a chat, asks for an edit, and keeps typing a comment below the paste. The model receives one flat message. SEAM measures absorption: the model returns that trailing comment inside the edited text, even though the comment is benign and asks for no insertion.
This is the benchmark from Can LLMs Separate Pasted Artifacts from User Speech? Absorption at Unmarked Prompt Seams (Sugam Panthi, Muhaiminul Yeamin, and Rabab Abdelfattah, arXiv:2610.04210).
- Paper: https://arxiv.org/abs/2610.04210
- Code, scorer, and per-model case-level labels: https://github.com/aimsresearchlab/seam
- Leaderboard: https://aimsresearchlab.com/seam/leaderboard.html
- Companion post: https://spanthi.com/blog/where-does-the-paste-end/
Across 20 models, absorption at a bare newline ranges from 7.7% to 66.7%. Adding a blank line does not significantly reduce absorption in any model, while boundary markers reduce it in 19 of 20 models. Comments that fit the pasted text, such as a code comment typed after code, are absorbed significantly more often in 17 of 20 models.
Structure
300 composition clusters, each under six matched conditions, 1,800 rows in total. A cluster is one task instruction and one pasted artifact; rows that share composition_event_id are matched.
| condition | what follows the pasted artifact |
|---|---|
clean |
nothing; the model's own output for the cluster, used as the comparison |
newline |
the comment after a bare newline |
blank |
the comment after a blank line |
boundary |
the comment after explicit boundary markers |
mitigation |
boundary markers plus one instruction line |
newline_R |
a comment rewritten to fit the genre of the pasted text (called artifact-native in the paper) |
Conditions are scored within a cluster against that cluster's clean output, so a signal counts only when it is absent from the model's unprompted output. The scorer is in the GitHub repository.
Configurations and licenses
The examples reuse text from six public editing corpora, so the data is split by source license. Each row keeps a license field and the identifiers needed to trace it upstream.
| config | rows | sources | license |
|---|---|---|---|
permissive (default) |
1,200 | CanItEdit (MIT), CoEdIT (Apache-2.0), CommitPackFT (MIT dataset; item repository license retained), IteraTeR Human-Doc (Apache-2.0) | per source, permissive |
cc-by-sa |
300 | Stack Exchange | CC BY-SA (version from the item revision date) |
cc-by-nc-sa |
300 | ParaRev | CC BY-NC-SA 4.0, noncommercial |
from datasets import load_dataset
seam = load_dataset("vein05/seam", "permissive", split="train")
Public availability of a source text does not by itself grant redistribution rights, and item-level retrieval dates and URLs are not recorded consistently across all sources. Check the upstream terms before redistributing a partition. DATA_LICENSES.md has the details. The occurrence analysis in the paper uses WildChat and LMSYS-Chat-1M; that conversation text is not included here.
Main fields
| field | meaning |
|---|---|
composition_event_id |
cluster identifier |
condition |
one of the six conditions above |
task_instruction |
typed instruction before the simulated paste |
artifact |
source material designated as pasted |
afterthought |
typed text after the paste; null in clean |
forbidden_proposition |
meaning that must not enter the returned artifact |
witness_tokens |
distinctive afterthought substrings, verified absent from the artifact, reference, and instruction; null in clean |
message |
the flattened user message the model receives |
segments |
typed and pasted origins with exact character offsets |
reference |
upstream reference edit, where the source provides one |
source, license, url |
upstream corpus and licensing metadata |
Scope
The examples are constructed, English, first-turn editing requests with equal source weighting and repeated comment pools. SEAM measures unintended inclusion of benign user speech in a returned artifact. It contains no adversarial instructions or executable payloads, and it does not establish behavior for sensitive content, other languages, or later conversational turns.
Citation
@misc{panthi2026seam,
title = {Can {LLMs} Separate Pasted Artifacts from User Speech? Absorption at Unmarked Prompt Seams},
author = {Panthi, Sugam and Yeamin, Muhaiminul and Abdelfattah, Rabab},
year = {2026},
eprint = {2610.04210},
archivePrefix = {arXiv},
primaryClass = {cs.CL},
doi = {10.48550/arXiv.2610.04210},
url = {https://arxiv.org/abs/2610.04210}
}
- Downloads last month
- 19