offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/reviews/fuzz--2334-cce19.json

@@ -0,0 +1,113 @@
+{
+ "finding": "fuzz/2334-cce19.f90",
+ "readers": [
+  {
+   "run": "run-20261113/batch-25",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "Atomic statement has the form x = x operator expr; expr (a merge call on constants) does not reference r1b. An orphaned do inside target binds to the implicit parallel region; legal. r1b is firstprivate by default on target. A conforming compiler must accept it."
+  },
+  {
+   "run": "run-20261113/batch-73",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "Orphaned omp do inside target binds to the implicit one-thread team; legal. The atomic statement r1b = r1b * expr has form x = x op expr with * allowed and expr (merge of constants) not referencing x. r1b is implicitly firstprivate on target so host value stays -1 and the printed checksum is deterministic. A conforming compiler must compile it; the crash is a compiler bug."
+  },
+  {
+   "run": "run-v2-20261113/batch-100",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "The atomic statement r1b = r1b * merge(...) has the form x = x operator expr with * allowed, x scalar of intrinsic type, and expr a scalar expression that does not reference x. The do construct inside target binds to the implicit one-thread team, which is legal. r1b is implicitly firstprivate, so the atomic update is on a private copy and the program is race free. A conforming compiler must accept it, so the front end crash is a compiler defect.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-46",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-21",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "The do construct inside target without enclosing parallel binds to the implicit parallel region of a one-thread team, which is allowed. The atomic update r1b = r1b * merge(...) has x op expr with expr not referencing x; expr need not be atomic. The program is conforming, so a compiler must accept it; the crash is a compiler bug.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-03",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "e93f8cde09b0cd351f62ee0a02d3c0d1a1e72401b85649c72b6097406b4fea63",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required."
+}

offload/_root/data/findings/reviews/fuzz--591-cce19.json

@@ -0,0 +1,147 @@
+{
+ "finding": "fuzz/591-cce19.f90",
+ "readers": [
+  {
+   "run": "run-20261113/batch-35",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "reasoning": "The target contains only the teams construct, satisfying the nesting rule. nontemporal is allowed on simd, hence on the composite teams distribute simd; o1 need not be accessed. lastprivate(lp1) and private(t1) are valid, and all iterations assign the same value, so no race. Output is deterministic. The compiler crash on unhandled nontemporal context is a bug."
+  },
+  {
+   "run": "run-20261113/batch-83",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "nontemporal is permitted on simd and thus on the composite teams distribute simd; its list item may be an array and is only a hint. lastprivate and private are allowed there; lp1 is always 0, so the result is deterministic. teams is the only statement in target. The compiler crash is not permitted."
+  },
+  {
+   "run": "run-v2-20261113/batch-07",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 1,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "nontemporal is permitted on simd, and teams distribute simd is a combined construct that includes simd. Its list items may also appear in data-environment clauses or none. The program has no races (all writes store zero) and is conforming, so a compiler must accept it; an internal compiler error is a bug.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-29",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-65",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 1,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "nontemporal is allowed on simd, so it applies to the simd leaf of the combined construct; lp1 and t1 privatization clauses are fine. The program is conforming and must be compiled.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-04",
+     "model": "claude-sonnet",
+     "batch_decoys": "missed",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    },
+    {
+     "run": "verify-20261113b/batch-04",
+     "model": "claude-sonnet",
+     "batch_decoys": "missed",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 2,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    },
+    {
+     "run": "verify-20261113c/batch-01",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "43b41eb9b3ad3b200194c2e9650867038c66d84e11cbfbb31b5b1ff5cfb16f3b",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required."
+}

offload/_root/data/findings/reviews/fuzz--650-afar.json

@@ -0,0 +1,113 @@
+{
+ "finding": "fuzz/650-afar.f90",
+ "readers": [
+  {
+   "run": "run-20261112/batch-06",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "o1 is an allocatable array referenced in the target construct, hence implicitly mapped tofrom. Each (i,j) element is written by exactly one thread (distinct i per team iteration, distinct j per do iteration), so no race. The end directive of the combined loop construct is optional. After the region the host holds o1 values, so the checksum must be nonzero; 0 means the data was not copied back."
+  },
+  {
+   "run": "run-20261112/batch-19",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "o1 is an allocatable array, not a scalar, so it is implicitly mapped tofrom. Each distribute iteration i writes distinct row o1(i,:); the nested parallel with a worksharing loop over j has no race. Parallel inside teams distribute is permitted. Checksum must be nonzero; 0 means the copy-back or inner writes were lost."
+  },
+  {
+   "run": "run-v2-20261113/batch-57",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "o1 is a non-scalar referenced in the target construct with no explicit map and no defaultmap, so it is implicitly mapped tofrom and its values return to the host. Distinct (i,j) elements are written, so there is no race. Nested parallel with a worksharing do inside distribute is allowed. Checksum 0 is wrong.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-58",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 1,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-96",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "o1 is an allocatable array, not a scalar, so it is implicitly mapped tofrom on the target. Each (i,j) element is written by exactly one iteration, so there is no race; a parallel region nested in teams distribute is permitted and the allocatable array holds nonzero values after the region. A checksum of 0 means the writes were lost.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-60",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 1,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "af4c9b47a47c7e2e5c8a409c9be0d0598fe052f8ebca2619df80b268ffaa0ba7",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required."
+}

offload/_root/data/findings/reviews/fuzz--916-afar.json

@@ -0,0 +1,130 @@
+{
+ "finding": "fuzz/916-afar.f90",
+ "readers": [
+  {
+   "run": "run-20261113/batch-19",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "teams reduction(iand) with distribute, an inner parallel and a worksharing do reduction(iand) on the same shared (team-private) item is allowed; no firstprivate on distribute. Each o1(i,j) is written by one thread; the r1a combination is associative and deterministic. o1 is implicitly mapped tofrom. The GPU memory fault is a compiler/runtime defect."
+  },
+  {
+   "run": "run-20261113/batch-50",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "teams with reduction(iand) inside target, distribute, then parallel with a worksharing do reduction(iand) on r1a, which is shared in the parallel region. o1(i,j) writes are disjoint. Each team's initial thread updates its own private r1a. Result is deterministic (iand of 1..48 and 65535 is 0, o1 all 0) and the output is fixed. The GPU memory fault is a compiler or runtime defect. The loop-binding restriction on reduction applies only to the loop construct, which is absent. distribute region is strictly nested in teams, parallel is allowed in distribute."
+  },
+  {
+   "run": "run-v2-20261113/batch-110",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 3,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "teams reduction(iand) on r1a; inside, the parallel region shares r1a (the teams private copy) and the worksharing do reduction on r1a satisfies the rule that the item be shared in the binding parallel region. Each distribute iteration writes distinct o1(i,j); o1 is implicitly mapped tofrom. parallel and distribute may be nested in teams. Result is deterministic (and of 1..48 with 65535 = 0). The GPU memory fault is a compiler or runtime defect.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-28",
+     "model": "claude-sonnet",
+     "batch_decoys": "missed",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    },
+    {
+     "run": "verify-20261113b/batch-03",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 1,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-48",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 3,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "The teams reduction gives each team a private r1a. Inside the parallel region r1a is shared by that team's threads, as the worksharing reduction requires, and the inner do reduction combines the per-thread values. o1(i,j) writes are disjoint. No restriction on nested reductions or firstprivate is violated, so the result is deterministic and a GPU write fault is not permitted.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-46",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "3081e53aa95c8d6c05f36b4f45c08ca4386d687d1c11d4d54c6c9e35309045c9",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required."
+}

offload/_root/data/findings/reviews/fuzz--98-cce19.json

@@ -0,0 +1,113 @@
+{
+ "finding": "fuzz/98-cce19.f90",
+ "readers": [
+  {
+   "run": "run-20261112/batch-16",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "o1 has an explicit map(tofrom). defaultmap only sets the implicit attribute for variables without explicit ones, so o1 stays mapped tofrom and the assignments return to the host; checksum must be non-zero. Treating o1 as firstprivate (checksum 0) is wrong."
+  },
+  {
+   "run": "run-20261112/batch-28",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "o1 has an explicit map(tofrom) clause. defaultmap(firstprivate: aggregate) only governs implicit attributes, so the explicit map applies and the device writes o1 back. checksum 0 is wrong."
+  },
+  {
+   "run": "run-v2-20261113/batch-19",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "o1 has an explicit map(tofrom: o1), so defaultmap(firstprivate: aggregate), which only affects implicit attributes, does not apply to it. The device writes 1 to every element and copies it back, so the checksum is nonzero. A result of 0 means o1 was treated as firstprivate despite the explicit map.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-59",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-74",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "o1 appears in an explicit map(tofrom) clause, so its mapping is explicit. The defaultmap clause only gives implicit attributes for variables without explicit mapping. o1 is therefore mapped tofrom, all elements become 1, and the checksum is nonzero. The observed 0 is a compiler error.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-13",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 1,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "de4e99f619bf267f9ccdf428915bba4e071a3ad9eae24bfe87cd5afc81b54750",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required."
+}