offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/reviews/afar-clang-requires-device-safesync-hang.json

@@ -0,0 +1,191 @@
+{
+ "finding": "afar-clang-requires-device-safesync-hang.c",
+ "readers": [
+  {
+   "run": "run-20261113/batch-33",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "device_safesync is a requires clause in 6.0 with an optional argument; absent argument means true. A bare requires directive with it in a file with only main is conforming and must be accepted; a hang is a defect. Run behavior is unobservable."
+  },
+  {
+   "run": "run-20261113/batch-64",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "OpenMP 6.0 defines device_safesync as a requires clause with an optional constant logical argument; without one it means true. A file-scope requires directive with it is conforming and the program is otherwise trivial. A conforming 6.0 compiler must accept it; a hang is a compiler bug."
+  },
+  {
+   "run": "run-v2-20261113/batch-53",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "no",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 1,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "The requires directive with device_safesync is valid OpenMP 6.0 at file scope. But whether an implementation supports a requirement clause is implementation defined, and an unsupported requirement must lead to compile-time error termination. A conforming compiler may therefore refuse the program, so acceptance is not required, though a hang is still a poor way to refuse.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-15",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 3,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-69",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 1,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "device_safesync is a requires clause in 6.0 and without an argument means true. The directive is at file scope and conforming. A conforming compiler either supports it or diagnoses; hanging is neither.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-26",
+     "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": "396c1c25c59548ad60ebe122fbabbf809c0a6a3726724df0f6bb073e3b1cbc46",
+ "instructions": "v2",
+ "verdict": "contested",
+ "why": "An independent adjudicating reading finds the result not required: The directive is conforming, but support for a given requirement clause is implementation defined, and an implementation that does not support it must perform compile-time error termination. A compiler may thus refuse the program, so acceptance is not required.",
+ "adjudicators": [
+  {
+   "run": "adj-v2-20261113/batch-03",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "no",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 1,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "The directive is conforming, but support for a given requirement clause is implementation defined, and an implementation that does not support it must perform compile-time error termination. A compiler may thus refuse the program, so acceptance is not required. Reading B fails: the specification permits a diagnosis, though a hang is poor quality it is not a required-result violation under these rules.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-63",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 2,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "adj-v2-20261113/batch-08",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "no",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 1,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Reading B fails. The requires directive is at file scope and device_safesync is a requirement clause, so the program is legal. But the specification makes support for any requirement clause implementation defined, so a conforming compiler need not accept the program. Reading A is right. A hang is poor quality but the text does not oblige acceptance.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-54",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 2,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 1,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ]
+}

offload/_root/data/findings/reviews/afar-flang-firstprivate-map-two-targets.json

@@ -0,0 +1,130 @@
+{
+ "finding": "afar-flang-firstprivate-map-two-targets.f90",
+ "readers": [
+  {
+   "run": "run-20261113/batch-26",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "reasoning": "firstprivate(p1) and map(from: a) name different variables; p1 is not in any map clause on the first target. The second target maps p1 with map(to:) only. No variable appears in both clauses on one construct, so the diagnostic is wrong. a(i)=3 then +3 gives a(3)=6."
+  },
+  {
+   "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": "firstprivate(p1) and map(from: a) on the first target name different variables. p1 appears in map(to:) only on the second target, which has no firstprivate. No variable appears in both data-sharing and map on one construct, so the diagnostic is wrong. Result a(3)=3+3=6 is determined."
+  },
+  {
+   "run": "run-v2-20261113/batch-54",
+   "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": "p1 appears only in firstprivate on the first target; map(from: a) maps a, not p1. The second target maps p1 with map(to:) and has no firstprivate. The diagnosed clash does not occur in either construct. Both clause lists are permitted on target. a(i)=3 then +3 gives a(3)=6, so the refusal is a compiler error.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-70",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 2,
+      "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": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "The first target privatizes p1 by firstprivate and does not map it; the second maps p1 only. No variable appears in both clauses on one construct, so the program is legal and a(3)=3+3=6 is determined. The diagnostic misreads the program.",
+   "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": 2,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    },
+    {
+     "run": "verify-20261113b/batch-03",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 2,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "e3a00bcb484ff6d3a86b990be653c41b11badd3511d1f0cdbcb474b5687a10b8",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required."
+}

offload/_root/data/findings/reviews/afar-flang-loop-bind-teams-reduction.json

@@ -0,0 +1,126 @@
+{
+ "finding": "afar-flang-loop-bind-teams-reduction.f90",
+ "readers": [
+  {
+   "run": "run-20261113/batch-37",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "The loop construct allows a reduction clause; bind(teams) requires strict nesting in a teams region, which holds (target teams body). The only reduction restriction tied to bind(teams) makes behavior unspecified when the loop is NOT nested inside a teams construct; here it is nested. Iterations complete before the end of the teams region, so r=55 on the host. Rejecting the reduction clause is wrong."
+  },
+  {
+   "run": "run-20261113/batch-65",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "The loop construct accepts a reduction clause and a bind(teams) clause. The loop is strictly nested in the teams region of the combined target teams construct. The only reduction restriction on bind(teams) concerns a loop not nested inside a teams construct, which does not apply. No clause combination is prohibited, so a conforming compiler must accept the program, and the refusal is a compiler error."
+  },
+  {
+   "run": "run-20261113b/batch-02",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "The loop region is strictly nested in the teams region of the combined target teams, so binding teams is allowed. The only reduction restriction on bind(teams) applies when the loop is not nested inside a teams construct; here it is nested in one (leaf of target teams), so reduction behavior is defined. Reduction on a loop construct is allowed with the default modifier. r is shared in the teams region, so the combined value 55 is stored to r at the end of the teams region. Refusing the clause is therefore a compiler error."
+  },
+  {
+   "run": "run-v2-20261113/batch-101",
+   "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 loop region is strictly nested in the teams region of target teams, so bind(teams) is allowed. The reduction clause is listed among the loop construct clauses. The only restriction on reduction with bind(teams) makes behavior unspecified when the loop is not nested inside a teams construct, which does not apply here. A compiler may not reject the clause.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-62",
+     "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
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-31",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 3,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "The loop construct accepts a reduction clause. The bind(teams) restriction requires the loop to be strictly nested in a teams region, and it is, since target teams supplies the teams region. The unspecified-reduction rule applies only when the construct is not nested inside a teams construct; here it is nested in one. Nothing forbids reduction with bind(teams), so a conforming compiler must accept the program. The refusal message states a restriction the specification does not contain.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-49",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 2,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "d252e939cc282feba90cd2cedba749c9cd0f1a49a6a5048d1e162e55f6c481b5",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required."
+}

offload/_root/data/findings/reviews/afar-flang-task-reduction-max.json

@@ -0,0 +1,113 @@
+{
+ "finding": "afar-flang-task-reduction-max.f90",
+ "readers": [
+  {
+   "run": "run-20261113/batch-09",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 3,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "taskgroup accepts task_reduction and target accepts in_reduction; the target region is closely nested in the taskgroup, whose innermost matching item uses the same identifier max for the same list item r. max is a valid reduction identifier for an integer. The base variable of an in_reduction item on target is implicitly mapped tofrom,always. A conforming compiler must accept it."
+  },
+  {
+   "run": "run-20261113/batch-79",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "reasoning": "max is a valid Fortran reduction identifier (intrinsic procedure name list). target accepts in_reduction; the target task participates in the task reduction defined by the enclosing taskgroup task_reduction with the same identifier and matching list item r, and the target region is closely nested in the taskgroup. r is implicitly mapped tofrom,always. No race: the target task is not nowait. A conforming compiler must accept it; the reported 'no symbol max' error is a front-end defect."
+  },
+  {
+   "run": "run-v2-20261113/batch-34",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "max is an implicitly declared Fortran reduction identifier. The target task participates through in_reduction with the same identifier as the enclosing taskgroup task_reduction, and r is implicitly mapped tofrom always. The program is conforming, so rejecting max is a bug.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-65",
+     "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-84",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "max is a valid Fortran reduction identifier (intrinsic procedure name). task_reduction(max: r) on taskgroup and in_reduction(max: r) on the enclosed target task match on the same list item; r is an integer scalar. The target in_reduction item is implicitly mapped tofrom with always. The program conforms, so a conforming compiler must accept it; the refusal over 'max' is a compiler error.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-27",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 2,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "fc2af42ffb8b5c4e315c7f63750ff3d94452894925cd86e782d2159572dd4607",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required."
+}

offload/_root/data/findings/reviews/afar-flang-thread-limit-target-parallel-do.json

@@ -0,0 +1,113 @@
+{
+ "finding": "afar-flang-thread-limit-target-parallel-do.f90",
+ "readers": [
+  {
+   "run": "run-20261113/batch-09",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 3,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "thread_limit is a permitted clause on target in 5.2. Section 17.2 applies thread_limit on a combined construct to all leaf constructs that permit it, here target. Section 17.3 makes target parallel do a valid combined construct. The only combined-construct clause restrictions are copyin on target and nowait/in_reduction on parallel. The refusal is a compiler defect."
+  },
+  {
+   "run": "run-20261113/batch-68",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "target parallel do is a combined construct and thread_limit is a clause of target. Section 17.2 applies thread_limit to all leaf constructs that permit it, so it applies to target; the clause applies to at least one leaf. The program has no other violations, so refusing it is a bug."
+  },
+  {
+   "run": "run-v2-20261113/batch-114",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 2,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 1,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "thread_limit is a permitted clause of the target construct, and a combined construct accepts the clauses of its leaf constructs; thread_limit applies to every leaf construct permitting it, here target. So target parallel do thread_limit(8) is conforming and must be accepted.",
+   "verifications": [
+    {
+     "run": "verify-20261113/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
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-50",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 1,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "thread_limit is permitted on the target construct, a constituent of target parallel do, so a combined construct accepts it. The clause applies to all leaf constructs that permit it. The program is conforming and must be accepted.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-12",
+     "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": "a976bb9ebc50ad25fde4c5c9c103a6a27c5fb876fe5286f4b93e475befbe2f07",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required."
+}