offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/reviews/oop--cce-polymorphic-dispatch-device-link.json

@@ -0,0 +1,247 @@
+{
+ "finding": "oop/cce-polymorphic-dispatch-device-link.f90",
+ "readers": [
+  {
+   "run": "run-20261113/batch-41",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "Declare target procedures with polymorphic dummies and a type-bound call are not prohibited, and the mapped objects are non-polymorphic type(sq)/type(rect). Dynamic dispatch needs the host-created type descriptor/vtable to be usable on the device; the specification does not say how polymorphic type information is made available there, so whether a conforming implementation must link this is not stated. Failure is a link-time missing runtime symbol."
+  },
+  {
+   "run": "run-20261113/batch-65",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 0,
+    "not_found": 1
+   },
+   "reasoning": "Both overriding bindings sq_area and rect_area have declare target, and area_of has declare target, which satisfies the rule on type-bound procedures accessed in a target region. The deferred binding and its abstract interface are not themselves declare target, and the spec says nothing on how dynamic dispatch through class(shape) is carried out on the device. Whether this satisfies the rule is unclear, so acceptance is not clearly required of a conforming compiler."
+  },
+  {
+   "run": "run-20261113b/batch-05",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "reasoning": "Type-bound procedures sq_area and rect_area appear in declare target; area_of dispatches through the deferred binding area of abstract shape, which has no body or declare target (only the abstract interface). Whether the deferred binding counts as accessed type-bound procedure needing declare target is not clear in the text. The variables are non-polymorphic non-allocatable and mappable. Dynamic dispatch on device needs implementation support that the spec only constrains through the declare target rule, so a link failure is arguably permitted."
+  },
+  {
+   "run": "run-v2-20261113/batch-03",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Type-bound procedures accessed in a target region must appear in declare target. The overriding procedures sq_area, rect_area and area_of have declare target, but the deferred binding area has an abstract interface area_if without it. The specification does not state how dynamic dispatch through the type is provided on the device, so whether a conforming compiler must link this is unclear.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-28",
+     "model": "claude-sonnet",
+     "batch_decoys": "missed",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 1,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    },
+    {
+     "run": "verify-20261113b/batch-02",
+     "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-107",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "All type-bound procedure implementations reached (sq_area, rect_area, area_of) have declare target. q and rr are non-polymorphic mapped variables. The deferred binding has only an interface, and the spec does not define device-side dynamic dispatch through class(shape) dummies, so whether the link failure is a required-accept case is not settled.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-34",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 1,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 3,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "d5fa2febece98e64573b4673ceea80ab6799b85e490b137e3033b41d250c51a4",
+ "instructions": "v2",
+ "verdict": "unconfirmed",
+ "why": "Independent readings are uncertain: The accessed binding area is deferred and its abstract interface has no body and no declare target; the overriders have it. The text does not say whether the deferred binding or the overriders count, nor does it define device-side dynamic dispatch. so a link failure is not shown to be a violation.",
+ "adjudicators": [
+  {
+   "run": "adj-20261113b/batch-01",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "reasoning": "Reading A's worry fails: the deferred binding has no body to place in a declare target directive; the accessed implementations sq_area and rect_area do appear in declare target, as does area_of, so the mappable-type rule is met. Reading B is right on legality. Nothing in the text says how a polymorphic type descriptor or dynamic dispatch is made available on the device, so whether a conforming implementation must link this is not stated."
+  },
+  {
+   "run": "adj-20261113b/batch-02",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "Reading A's doubt about the deferred binding fails: the rule is that type-bound procedures accessed in a target region must appear in declare target; the concrete bindings sq_area, rect_area and the caller area_of all do, and the deferred binding has no body. The mapped objects are non-polymorphic. No restriction forbids class dummies or dynamic dispatch in declare target procedures, so the link failure on a runtime symbol is an implementation defect. Moderate doubt since the specification does not describe polymorphic dispatch support."
+  },
+  {
+   "run": "adj-v2-20261113b/batch-06",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Reading A overstates legality: the only relevant rule is that all type-bound procedures accessed in a target region must appear in a declare target directive. The accessed binding area is deferred and its abstract interface has no body and no declare target; the overriders have it. The text does not say whether the deferred binding or the overriders count, nor does it define device-side dynamic dispatch. Reading B is right that this is unsettled; so a link failure is not shown to be a violation.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-14",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 2,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "adj-v2-20261113b/batch-11",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "uncertain",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 3,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "Both readings agree. The concrete bindings sq_area, rect_area and area_of carry declare target, but the deferred binding has only an abstract interface that cannot. The specification says nothing on device-side dynamic dispatch (type descriptors or binding tables) for class dummies, so neither legality nor a requirement to link can be established from the text.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-38",
+     "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
+     }
+    }
+   ]
+  }
+ ]
+}

offload/_root/data/findings/reviews/oop--cce-section-of-element-component-overlap.json

@@ -0,0 +1,113 @@
+{
+ "finding": "oop/cce-section-of-element-component-overlap.f90",
+ "readers": [
+  {
+   "run": "run-20261113/batch-06",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "Mapping an array section of an allocatable component of an element of a derived-type array is a valid map list item. No rule is broken: v(2) is not otherwise mapped, the allocatable is not reallocated during the region, and the loop writes disjoint elements. The result (r1=2880, r2=2080) follows from tofrom copy-back. The Cray error about a host region overlapping a present region is an implementation defect."
+  },
+  {
+   "run": "run-20261113/batch-60",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "Mapping an array section of an allocatable component, v(2)%a(5:20), with tofrom is conforming. The iterations write disjoint elements, with no race. The runtime overlap error is a compiler or runtime defect. Sums 2880 and 2080 are as expected."
+  },
+  {
+   "run": "run-v2-20261113/batch-26",
+   "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": "Only the section v(2)%a(5:20) is mapped tofrom and the target region references only elements 5:20, so the restriction on referencing the whole array is not violated. The allocatable component is allocated before the construct and not reallocated during it. No overlapping maps exist on the construct. Expected sums: 2080+16*50=2880 for v(2), 2080 for v(1). The runtime error about a host region overlapping a present region is a compiler/runtime bug in handling the section of an allocatable component.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-56",
+     "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
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-93",
+   "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": "v(2)%a(5:20) is a single-part-ref-with-rank section of an allocated allocatable component; the last part-ref has a section subscript list, and v(2) is rank 0. No restriction is broken: the allocatable is not reallocated during the region, and the whole array is not referenced in a way the spec makes unspecified (only the mapped section is referenced). Nothing was present beforehand, so the 'overlap present region' runtime error is a compiler fault in mapping the descriptor. Sums 2880 and 2080 are determined.",
+   "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": 0,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "1114c2c5429591a4060e19916516bc18bb3860761b8c68534d36c7476644fdc6",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required."
+}

offload/_root/data/findings/reviews/oop--cce-select-type-guard-not-taken.json

@@ -0,0 +1,191 @@
+{
+ "finding": "oop/cce-select-type-guard-not-taken.f90",
+ "readers": [
+  {
+   "run": "run-20261112/batch-11",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "reasoning": "e1, e2, b0 are non-polymorphic, non-allocatable variables, so the polymorphic-allocatable map restrictions do not apply. bump is declare target, and select type on a class dummy is ordinary Fortran; the spec restricts nothing here. e1, e2, b0 are mapped tofrom, so updates must return to the host (r1=10, r2=100, r3=-1). Spec silent on device-side type descriptors, so some residual uncertainty, but nothing permits r1=0."
+  },
+  {
+   "run": "run-20261112/batch-22",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "reasoning": "The polymorphic dummy s is not a list item of any clause; map items e1, e2, b0 are nonpolymorphic. The only polymorphic restriction found concerns ALLOCATABLE polymorphic list items, which does not apply. bump is declare target and called from a target region, so e1%u=10, e2%v=100, b0%a=-1 are required. Observed r1=0 on the host-flag-0 run is a compiler error."
+  },
+  {
+   "run": "run-v2-20261113/batch-105",
+   "model": "claude-sonnet",
+   "instructions": "v2",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "uncertain",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "program": {
+    "ok": 2,
+    "not_found": 0,
+    "contradicted": 0
+   },
+   "reasoning": "The program uses Fortran 2003 CLASS dummies and SELECT TYPE inside a declare target procedure, with explicit tofrom maps of non-polymorphic actual variables, so static and dynamic types agree. No type-bound procedures are used. Nothing in the specification forbids this, and the expected values follow from the base language. The specification does not say how run-time type information is made available on the device, so whether it is required is not settled by the text.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-11",
+     "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-15",
+   "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": "e1, e2 and b0 are non-polymorphic, non-allocatable variables, so mapping them is legal. bump is a declare target procedure with a CLASS dummy and select type, which is base-language Fortran and has no OpenMP restriction. The expected values are fully determined, with no race and no unspecified behavior. Observed r1=0 and r2=0 is a wrong-answer compiler bug. The only polymorphic list-item restriction applies to ALLOCATABLE variables, and none is mapped.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-60",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 0,
+      "wrong_section": 1,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 2,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ],
+ "prior_art": [],
+ "external": [],
+ "program_sha": "2f9a62f0d763e74a8ab8c424f321cef23b10c1bdcc6166a09188f3711389a7f2",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "One independent reading was uncertain; 2 adjudicating readings that weighed both find the program legal and the result required: Both readings find the program legal. The only OpenMP polymorphism restrictions concern ALLOCATABLE polymorphic list items (map clause) or C++ types with mismatched static and dynamic types; none applies since e1, e2, b0 are non-polymorphic variables mapped tofrom. A declare target procedure with CLASS dummy and SELECT TYPE is plain Fortran, so the values are determined.",
+ "adjudicators": [
+  {
+   "run": "adj-v2-20261113/batch-03",
+   "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": "Both readings find the program legal. The only OpenMP polymorphism restrictions concern ALLOCATABLE polymorphic list items (map clause) or C++ types with mismatched static and dynamic types; none applies since e1, e2, b0 are non-polymorphic variables mapped tofrom. A declare target procedure with CLASS dummy and SELECT TYPE is plain Fortran, so the values are determined. Reading A's doubt about run-time type information is not grounded in any specification text; Reading B is right.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-49",
+     "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": "adj-v2-20261113/batch-08",
+   "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": "e1, e2 and b0 are non-polymorphic, non-allocatable variables mapped tofrom, so the map restrictions are met. The only polymorphic restriction found applies to ALLOCATABLE list items, and none appears. bump is a declare target procedure using CLASS and SELECT TYPE, which is Fortran 2003 and not in the list of unsupported features. The base language fixes r1=10, r2=100, r3=-1. Reading B is right; Reading A names no gap in the text. The observed r1=0 is a compiler bug.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-15",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 1,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 1,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  }
+ ]
+}

offload/_root/data/findings/reviews/oop--cce-udr-derived-type-unsupported.json

@@ -0,0 +1,132 @@
+{
+ "finding": "oop/cce-udr-derived-type-unsupported.f90",
+ "readers": [
+  {
+   "run": "run-20261113/batch-29",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 1,
+    "wrong_section": 0,
+    "not_found": 0
+   },
+   "reasoning": "The declare reduction is in the main program's specification part; the combiner calls vadd, which is a module procedure with an explicit interface, accessible by use association, and is declare target. The initializer sets omp_priv with a structure constructor. acc is a reduction list item in a combined target construct and is mapped tofrom. Sum of i is 2080 and of 2i is 4160. A conforming compiler must accept it; the refusal is a limitation, not a spec allowance."
+  },
+  {
+   "run": "run-20261113/batch-82",
+   "model": "claude-sonnet",
+   "batch_decoy": "caught",
+   "legal": "yes",
+   "result_required": "yes",
+   "quotes": {
+    "ok": 0,
+    "wrong_section": 1,
+    "not_found": 0
+   },
+   "reasoning": "declare reduction precedes its use in the same subprogram. The combiner and initializer reference vadd, which has an explicit interface (module procedure) and is declare target. The Fortran-specific restrictions on reduction identifiers are met. acc is a non-scalar and is mapped tofrom. A conforming compiler must compile the program. The refusal is a compiler limitation."
+  },
+  {
+   "run": "run-v2-20261113/batch-103",
+   "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": "The declare reduction precedes its use in the reduction clause, is in the program subprogram, and the combiner is an assignment statement using only omp_in and omp_out. vadd comes from a module, so it has an explicit interface, and it is declare target so the device can call it. The refusal of a user-defined reduction in a target construct is a compiler limitation; a conforming compiler must accept the program.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-34",
+     "model": "claude-sonnet",
+     "batch_decoys": "caught",
+     "refuted": false,
+     "false_claims": [],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 1,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 2,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    }
+   ]
+  },
+  {
+   "run": "run-v2-20261113/batch-33",
+   "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 reduction identifier vsum is declared before its use in the reduction clause for type v2. The combiner is an assignment statement, allowed by the combiner rules, and uses only omp_in and omp_out as variables; vadd is a function with a declare target directive. The initializer sets omp_priv. Result is 2080 and 4160. A conforming compiler must accept it.",
+   "verifications": [
+    {
+     "run": "verify-20261113/batch-04",
+     "model": "claude-sonnet",
+     "batch_decoys": "missed",
+     "refuted": true,
+     "false_claims": [
+      "The combiner may call vadd, since vadd is a function with a declare target directive."
+     ],
+     "quotes": {
+      "ok": 1,
+      "wrong_section": 0,
+      "not_found": 0
+     },
+     "program": {
+      "ok": 1,
+      "not_found": 0,
+      "contradicted": 0
+     }
+    },
+    {
+     "run": "verify-20261113b/batch-02",
+     "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": "368d90ac25e77b3ed80fda57ef7fd8df8dc7c9162b6b34ebb1576f91327e1d13",
+ "instructions": "v2",
+ "verdict": "confirmed",
+ "why": "2 independent readings find the program legal and the result required."
+}