Datasets:

SybilGambleyyu
/

workbook-change-benchmark

Resource	What it makes measurable	Why it is not sufficient for change assurance
Modified EUSES	Injected formula faults and output-cell test decisions	It is fault-localization/testing data, not an explicit before/after review policy or dependency-impact contract.
VEnron	Recovered spreadsheet version history	The original work says version information is fragmented and uses recovered evolution groups; it does not publish a CI-oriented accept/review/block oracle for changes.
Enron Error Corpus discussion	A small collection of real faults and repairs	It is important evidence that real historical changes can be faults, but it targets fault recovery rather than broad change-review controls.
SpreadsheetBench	Real-world spreadsheet manipulation tasks	It evaluates producing or editing workbooks, not deciding whether a candidate change should pass a review gate.
Formula repair benchmark	Formula runtime-error repair	It evaluates repair generation and execution checks, not version comparison or conservative static impact.

Evidence of the workflow problem

Microsoft's Spreadsheet Inquire documentation describes cell-by-cell comparison, workbook analysis, and relationship diagrams, but the workflow is a desktop inspection rather than a portable policy gate. Commercial tools such as xltrail provide version history and component diffs. Their existence is useful confirmation that formula-level history matters, while it also leaves room for an open, reproducible way to evaluate policy and impact claims.

The spreadsheet-evolution literature describes a central review problem: a structural edit can rewrite many formulas even when intent is preserved, while a single formula or value change can alter model behaviour. The paper surfaced through this TU Delft copy explicitly calls out both effects. A benchmark must therefore include both clear regressions and benign-looking structural changes.

Design decision

The first release uses original generated workbooks instead of rehosting public corporate corpora. This provides unambiguous redistribution rights, directly observable ground truth, deterministic regeneration, and cases that include modern OOXML controls often absent from older .xls research datasets.

WCAB's result is intentionally narrower than a claim of Excel semantic equivalence. It provides checkable change facts and static dependency lower bounds. A tool that cannot handle a case must report a coverage gap; it cannot turn a missing observation into an "allow" result.

Structured-reference scope expansion

Microsoft documents that a structured reference combines a Table and column name, and that the reference adjusts when data is added to or removed from the Table. Its structured-reference guidance also shows formulas outside a Table that refer to Table data. This creates a change-review case that ordinary formula text comparison misses: the stored formula can remain unchanged while the Table's stored range grows. WCAB schema version 2 therefore adds a generated Table-expansion case that checks those observable facts without evaluating a formula or asserting a result value.

External-workbook link startup policy

Microsoft's workbook-link guidance documents startup choices for external workbook links, including always refreshing them, never refreshing them, and asking the user. The Open XML workbookPr specification identifies updateLinks as the stored behavior for updating external links when a workbook opens. This is distinct from a query, connection, or pivot refresh switch: an unchanged formula that refers to a separate workbook can start attempting an update solely because this workbook-wide policy changes.

WCAB 0.8 therefore preserves one original synthetic external-link formula and its local downstream consumer while changing only workbookPr/@updateLinks from never to always. The named source workbook is deliberately absent; the validator reads local OOXML and formula text only. It does not resolve the link, test source availability or trust, retrieve a value, or claim that Excel successfully recalculates the workbook.

External-workbook source relationships

Microsoft's workbook-link guidance documents Change source as a workflow for pointing existing workbook links to another source. The Open XML ExternalBook reference states that externalBook represents an external workbook supplying data to the current workbook, including a relationship to the supporting book path. This creates a separate review surface from a startup-refresh policy: a stored source can change while the visible external formula stays exactly the same.

WCAB 0.32 isolates that relationship graph in one original synthetic package. LinkedModel!B2 keeps ='[WCABSource.xlsx]Inputs'!$B$2, and Dashboard!B4=LinkedModel!$B$2 remains its direct local consumer. One workbook external-reference binding leads to one externalLink/externalBook declaration and its one externalLinkPath relationship. The formula, source-sheet name, relationship IDs/types, content type, and every package member except xl/externalLinks/_rels/externalLink1.xml.rels stay fixed; only its external Target moves from approved.example.invalid to review.example.invalid. The validator reads local OOXML only, never resolves, opens, fetches, authenticates to, trusts, refreshes, or calculates either source, and does not claim that any client updates a link or returns a value.

External-data source endpoints can move without changing visible cells

Microsoft's external-connection format documentation shows that a workbook connection can store provider, server, authentication, command, and refresh material outside ordinary cells. For web queries, the Open XML webPr reference identifies the stored URL and request controls. A source retarget can therefore be material to review even when imported saved values and local formulas look unchanged.

WCAB 0.37 isolates that declaration using one local relationship-backed web-query connection. Only its raw webPr/@url moves from approved.example.invalid to review.example.invalid; connection identity and refresh controls, relationship and content-type bindings, saved ImportedData!B2=100, the ImportedData!B2 → Summary!B2 → Dashboard!B4 formula path, calculation properties, and every other package member stay fixed. The validator reads local OOXML and compares xl/connections.xml after removing only the URL. It never opens, fetches, authenticates to, trusts, refreshes, or otherwise interacts with either endpoint, evaluates formulas, or claims a client result. The fixture also motivates FormulaFence's safe web_query_url category: it identifies the class of changed sensitive source material without emitting either endpoint, a command, a parameter, or a fingerprint.

Package-signature scope can change outside worksheet cells

The Open Packaging Conventions specification defines package relationships and digital-signature parts, while the W3C XML Signature specification distinguishes the Reference items in SignedInfo from the Reference items collected by a Manifest. A SignedInfo URI can therefore point to a local signature Object, while a separate Object/Manifest declaration names the package parts whose stated scope a reviewer needs to understand. Treating those two namespaces as interchangeable would turn a signature-local reference into an unsupported package-coverage claim.

WCAB 0.38 isolates this boundary with one structurally shaped package signature. Its root-to-origin and origin-to-signature relationships, origin/signature content types, one SignedInfo local-object reference, ordinary Controls!B10=12 and Controls!D10=B10*C10 context, calculation properties, and all package members except _xmlsignatures/sig1.xml remain fixed. Only one Object/Manifest/Reference/@URI moves from the direct workbook part to the direct worksheet part. The raw validator checks that bounded local declaration and compares the signature XML after erasing only that URI.

WCAB 0.39 adds the complementary relationship-selector boundary: the Manifest URI names the root relationships part and its XMLDSIG transform sequence is one OPC Relationships Transform immediately followed by XML C14N. Only its RelationshipReference/@SourceId changes, selecting the root office-document relationship before and the root signature-origin relationship after. A selector identifies a relationship entry rather than proving its target part was signed, and the redacted aggregate selector counts intentionally remain equal. The raw validator checks only that bounded local structure and compares the envelope after erasing the source ID. The digest and signature values in both fixtures are deliberately synthetic: neither package-signature case is a cryptographic verification, transform evaluation, certificate/identity check, trust-chain assessment, or package-consumer decision.

Legacy shared-workbook revision history persists outside ordinary cells

Microsoft's Open XML Headers reference describes revision history persisted in distinct headers and log files, with shared/tracking/history/retention/protection controls. Its WorkbookRevisionHeaderPart reference exposes linked revision-log parts, while the Revisions reference describes a log as a list of revisions made to a shared workbook. The old shared workbook feature is legacy, but that is exactly why persisted history can remain outside an ordinary cell/value/formula comparison.

WCAB 0.41 isolates a compact relationship-backed workbook-to-header-to-log graph. The header controls, synthetic author/timestamp/GUID, revision-record shape, content types, Controls!B10=12, Controls!D10=B10*C10, calculation properties, and every package member except xl/revisions/revisionLog1.xml remain fixed. Only one synthetic historic value changes. The raw validator checks that bounded local declaration and compares the log after erasing the private value. It does not publish historic values, cell locations, writer identity, timestamps, GUIDs, or relationship IDs; verify provenance or a writer; replay revisions; resolve conflicts; establish review/approval; authenticate or authorize a person; or claim workflow/client behavior.

External sources can hide in defined names without an externalLink part

Microsoft's workbook-link guidance explicitly identifies defined names as a location where workbook links may be used and gives a workflow for finding them. The Open XML DefinedNames reference places those expressions in the workbook-level name collection. This is a separate review surface from an externalLink relationship graph: an ordinary formula can stay fixed while the name it consumes changes its qualified source.

WCAB 0.33 therefore keeps Model!B2=ScenarioRate*2 and its direct Dashboard!B4=Model!$B$2 consumer unchanged while the local ScenarioRate definition moves from '[WCABApprovedSource.xlsx]Inputs'!$B$2 to '[WCABReviewSource.xlsx]Inputs'!$B$2. Its original compact fixture has no externalReferences declaration and no xl/externalLinks/ member; only xl/workbook.xml changes. The validator reads those local bytes and fixed formula context only. It never resolves, opens, fetches, authenticates to, trusts, refreshes, or calculates either synthetic source, and it does not claim that a client resolves the name or returns a value.

Named LAMBDAs are workbook-scoped formula programs, not ordinary cells

Microsoft's LAMBDA guidance describes naming a LAMBDA in Name Manager so it becomes a reusable custom function available throughout a workbook. Its names-in-formulas guidance also calls out defining reusable formulas with LET and LAMBDA. A cell-level formula diff can therefore leave an invocation unchanged while the callable formula body behind its friendly name changes.

WCAB 0.34 isolates that review surface in one original compact workbook. The only stored difference is the workbook-level ScenarioValue definition moving from =LAMBDA(rate,amount,rate*amount) to =LAMBDA(rate,amount,rate*(amount+10)). Inputs!B2=0.08, Inputs!B3=100, Model!B2=ScenarioValue(Inputs!B2,Inputs!B3), and Dashboard!B4=Model!$B$2 remain unchanged, as do calculation properties, workbook relationships, and every package member except xl/workbook.xml. The package has no external references or external-link part. The validator reads the stored definition and local ordinary formula paths only; it does not evaluate a LAMBDA, expand every named-formula dependency, calculate a result, infer client/version support, or claim a client recalculates, spills, or saves a value.

Table calculated-column masters can change outside worksheet cells

Microsoft's calculated-column guidance explains that a formula entered in one Excel Table column is filled through the column, and that later edits expand through the calculated column. In Open XML, calculatedColumnFormula is the tableColumn child that stores the formula used for each cell in that column. This is a stored formula program distinct from a worksheet <f> cell node and from a Table range change.

WCAB 0.34 therefore keeps a local ScenarioLedger Table at Ledger!A1:C4, its worksheet-to-Table relationship, headers, ordinary Ledger!C2:C4 formulas, and Dashboard!B4=SUM(ScenarioLedger[Calculated amount]) fixed. Only the third Table column's raw calculatedColumnFormula text moves from A2*B2 to A2*(B2+1), so xl/tables/table1.xml is the sole changed package member. The validator follows that local binding and compares the Table part after erasing only the master text. It does not fill formulas, reconcile the master with stored row formulas, calculate a structured reference, infer a total, add a row, render a Table, open Excel, or claim client behavior.

Data Model relationships can change report filtering outside cell formulas

Microsoft's PowerPivot Model object guidance describes one workbook model containing tables and relationships, where a relationship connects a primary key to a foreign key and lets a user filter across multiple tables in a PivotTable or PivotChart. The Open XML dataModel declaration and modelRelationship type place that relationship separately from ordinary worksheet cell formulas. A worksheet diff can therefore miss a changed model key even if its visible cells and formulas remain stable.

WCAB 0.35 isolates one compact declaration whose relationship changes from SalesModel.CalendarKey → CalendarModel.DateKey to SalesModel.CalendarKey → CalendarModel.FiscalDateKey. Its two local source Tables, powerPivotData workbook relationship, .data content type, calculation properties, and fixed opaque xl/model/item.data payload remain unchanged; xl/workbook.xml is the sole changed package member. The raw validator reads only that declaration, its local package binding, and a digest of the opaque payload. It does not deserialize the Analysis Services stream, evaluate DAX, load or refresh a model, calculate or render a PivotTable or chart, infer model-to-cell impact, or claim Excel-client behavior.

XLM automatic-macro declarations remain a review surface

Microsoft's Excel 4.0 macro guidance states that Excel continues to support Excel 4.0 (XLM) macros and documents their security controls. Its XlRunAutoMacro reference names Auto_Open, Auto_Close, Auto_Activate, and Auto_Deactivate as the automatic macro events. This makes a stored automatic-macro binding materially different from an ordinary worksheet formula: a reviewer may need to see that the event's stored target changed even when the macro-sheet bytes did not.

WCAB 0.36 therefore uses a real macro-enabled .xlsm pair with one very-hidden XLM macro sheet and one workbook-scoped _xlnm.Auto_Open name. Only that raw defined-name text changes, from 'Macro Automation'!$A$1 to 'Macro Automation'!$A$2; the raw macro-sheet payload is byte-identical and contains only two static HALT() formula cells. Its macro-sheet relationship, content types, ordinary local formula context, calculation properties, and every other package member stay fixed. The fixture is designed to test review of a stored dispatch declaration, not macro execution: WCAB never opens Excel, enables or executes XLM code, parses or emulates instructions, resolves a dynamic name, inspects security/trust state, or claims an event dispatch result or client behavior.

Iterative calculation and intentional circular models

Microsoft's circular-reference guidance explains that iterative calculation can intentionally allow circular references in financial or engineering models, and that maximum iterations and maximum change bound that repeated calculation. Its calculation guidance likewise distinguishes a direct or indirect self-reference from a workbook where iteration has been enabled to calculate it. The Open XML calcPr specification defines the stored calculation-properties element and its iterate, iterateCount, and iterateDelta attributes.

WCAB 0.9 uses one small original direct self-reference whose formula text, input, and downstream local consumer do not change. The candidate changes only the stored iterate flag from false to true while retaining explicit 100 and 0.001 bounds. The fixture records a calculation-control change—not a numerical outcome. The validator does not calculate the circular model, assume that it converges, predict how many iterations occur, or assert a cached or business-correct result.

Precision as displayed and irreversible stored values

Microsoft's calculation and precision guidance distinguishes the values Excel stores from the values a number format displays. It warns that enabling calculation using displayed values permanently changes stored values to that displayed precision and cannot restore the prior underlying values. Its separate rounding-precision guidance also warns of cumulative calculation effects. The Open XML calcPr specification identifies fullPrecision as the stored calculation control.

That creates a review boundary that a formula or cell-value diff can miss: a package can retain a stored 10.005 input, a 0.00 format, and unchanged formulas while its calculation control moves from full precision to displayed precision. WCAB 0.10 therefore isolates raw fullPrecision=true to fullPrecision=false in an original synthetic pair. The validator confirms the stored metadata, input value, format, and formulas only. It does not open or save either workbook, emulate Excel, calculate a result, round a stored value, or assert any client will apply or persist the control.

Saved formula results without a visible precedent edit

Microsoft's SpreadsheetML formula guidance separates a formula's <f> expression from the <v> cached value based on the last calculation. Its CellValue reference also states that a formula-cell <v> stores the last calculated result. This is a distinct review surface: an ordinary formula or literal-value diff can stay silent when the saved result evidence has changed.

WCAB 0.11 therefore retains an original Inputs!B2=10, the direct Model!B2 = Inputs!$B$2*2 formula, stable calculation properties, and a local Dashboard!B4 consumer, while changing only Model!B2's raw numeric <v> from 20 to 25. The pair is deliberately not a claim that either value is correct, stale, tampered, or will be displayed after opening: volatile, external, and client-specific calculation behavior are out of scope. Its purpose is to make the saved-result discrepancy observable and reviewable.

Workbook serial-date systems without a cell edit

Microsoft documents that Excel workbooks use either a 1900 or 1904 date system, and that the same stored serial differs by 1,462 days between those systems in its date-system guidance. The Open XML workbookPr reference stores date1904 and dateCompatibility as workbook controls, with defaults of false and true respectively. That makes an omitted control materially different from an arbitrary boolean parser: a comparator should normalize the specified defaults before deciding that a date-system change occurred.

WCAB 0.12 isolates that surface in an original synthetic pair. It makes both controls explicit, preserves a raw 45292 numeric serial and its yyyy-mm-dd custom format, and changes only date1904=false to true while dateCompatibility=true remains fixed. The validator reads local OOXML and style metadata only. It neither converts the serial nor asserts what date a client will display, and it does not calculate, open, or save a workbook.

Active AutoFilter criteria without a cell edit

Microsoft's filter guidance explains that AutoFilter shows the requested subset and hides the rest; a filtered subset can then be copied, charted, or printed. Its SUBTOTAL reference states that rows excluded by a filter are always excluded. Consequently, an active criterion can be review-material even when no formula text or stored cell value changes.

WCAB 0.13 records that control boundary in one original synthetic pair. The sole list criterion in Report!A1:B5 moves from North to South, while Report!D2=SUBTOTAL(109,B2:B5) and Dashboard!B4=Report!$D$2 remain unchanged. The raw validator checks the stored <autoFilter>, <filterColumn>, <filters>, and <filter> declaration plus the formula/dependency and package-member boundary. It does not apply a filter, calculate the subtotal, infer which rows a client shows, or claim a displayed, copied, charted, or printed result.

Named Sheet Views can alter a saved review lens without a cell edit

Microsoft's Sheet View guidance describes saved, customized filter and sort views for collaborative work, including switching among saved views. The MS-XLSX Named Sheet Views specification defines the stored collection as sort/filter settings for an AutoFilter on a specific worksheet. This is a separate review surface from the active worksheet AutoFilter: a reviewer can select a saved view without a formula or cell value having changed.

WCAB 0.26 keeps a no-criterion Report!A1:B5 base AutoFilter, the report rows, Report!D2=SUBTOTAL(109,B2:B5), and Dashboard!B4=Report!$D$2 fixed. A worksheet relationship binds that filter to one saved Named Sheet View; only its column-0 list criterion moves from North to South. The validator follows the local relationship, reconciles its stable filter ID and range to the base AutoFilter, compares the named-view part after removing only the terminal list value, and requires that part to be the sole package change. It does not activate, render, or apply the view; calculate a subtotal; infer visible rows; or claim a display or print outcome.

XML Maps can retarget a workbook's import/export contract without a cell edit

Microsoft's XML overview explains that XML Maps bind schema elements to worksheet cells or XML tables and are used to import and export mapped XML data. It distinguishes single-mapped cells from repeating XML tables, and describes XML Maps as the relationship between mapped cells and schema elements. The Excel XmlMap API likewise exposes Import and Export operations over a workbook XML map. That makes the raw mapping target—not only the current worksheet value—a material review surface for data-exchange templates.

WCAB 0.27 isolates that boundary in one original synthetic package. The Export!A1:B3 InvoiceLines XML table has one mapped Net amount column; only its raw xmlColumnPr/@xpath moves from a NetAmount to a TaxAmount path. The local XML Map, embedded XSD declaration, local file-binding metadata, stable Export!E2 single-cell mapping, table values, Export!D2=SUM(InvoiceLines[Net amount]), and Dashboard!B4=Export!$D$2 remain fixed. The validator follows only local workbook and worksheet relationships, compares the table part after erasing the XPath, and requires that table part to be the sole package change. It does not access a file, validate the schema, import or export XML, materialize data, calculate formulas, or claim a client result.

Office Web Add-in auto-show requests change workbook behavior outside cells

Microsoft's Excel auto-open task-pane guidance documents the webextension and taskpanes package parts used to associate a workbook with an Office Add-in. Its deployment caveat is important: an association is only honored when the referenced add-in is already installed, sideloaded, or deployed. The MS-OWEMXML specification defines the Office.AutoShowTaskpaneWithDocument extension property. A workbook can therefore acquire a stored request to show an add-in task pane without a worksheet-cell diff, and without the package containing an add-in manifest or payload.

WCAB 0.28 isolates that declaration in one original synthetic package. It has one local workbook-to-taskpane-to-web-extension relationship chain, one hidden locked task pane, and one synthetic FileSystem store reference. Its Office.AutoShowTaskpaneWithDocument value alone moves from false to true; the reference, IDs, task-pane layout, ordinary cells, calculation properties, and Inputs!B2 → Model!B2 → Dashboard!B4 formula context remain unchanged. The validator follows only local package relationships, compares the web-extension XML after erasing that value, and requires that part to be the sole package change. The fixture has no manifest payload or external relationship. It does not install, load, execute, or fetch an add-in or manifest, and it does not claim that any client opens a task pane or that the add-in accesses workbook cells.

Embedded OLE auto-load requests change workbook-open behavior outside cells

Microsoft's OLEObject.AutoLoad reference defines the property as whether an OLE object is automatically loaded when its workbook opens. It defaults to false for new OLE objects, Microsoft advises against setting it true for most object types, and explicitly distinguishes ActiveX controls, which ignore the property because they always load. The Open XML OleObject.AutoLoad reference records the same stored autoLoad schema boolean, while the OleObject element reference defines its relationship identifier as the pointer to object-persistence data. That creates a material review surface independent of a cell diff, without requiring a benchmark to launch an object server.

WCAB 0.29 isolates that declaration in one original synthetic package. It has one worksheet oleObject declaration, one standard internal OLE relationship, and one fixed opaque ASCII payload under a synthetic unregistered ProgID. Its autoLoad value alone moves from false to true; its relationship, content type, bytes, ordinary cells, calculation properties, and Inputs!B2 → Model!B2 → Dashboard!B4 formula context remain fixed. The validator follows only that local relationship, compares worksheet XML after erasing autoLoad, verifies the fixed opaque bytes without deserializing them, and requires the worksheet part to be the sole package change. The fixture has no linked target, ActiveX control, object presentation, macro, or external relationship. It does not deserialize, open, render, execute, register, or invoke an object server, and it does not claim that an object loads successfully.

QueryTable refresh requests are distinct from connection refresh controls

Microsoft's QueryTable.RefreshOnFileOpen reference defines the property as whether a QueryTable is refreshed whenever its workbook opens. The Open XML QueryTable reference lists the raw refreshOnLoad attribute alongside the table's connection ID and other refresh controls. This is a material review surface separate from a workbook connection's own refreshOnLoad setting: a stored table-level request can change without a normal cell, formula, connection-control, or package relationship diff.

WCAB 0.30 isolates that declaration in one original synthetic package. It has one ImportedData worksheet-to-QueryTable relationship, one fixed internal workbook-to-connections relationship, and one reserved example.invalid web-query URL. Its QueryTable refreshOnLoad value alone moves from false to true; the connection's own refreshOnLoad=false, QueryTable controls, relationships, content types, saved ImportedData!B2=100 cell, and ImportedData!B2 → Summary!B2 → Dashboard!B4 formula context remain fixed. The validator follows only those local OOXML parts, compares the QueryTable XML after erasing refreshOnLoad, and requires that QueryTable part to be the sole package difference. The fixture has no credentials, query result, table range, or external OOXML relationship. It does not open a connection, fetch a URL, refresh a query, materialize rows, calculate a workbook, or claim that a client refreshes successfully.

Worksheet cell hyperlink targets can change outside ordinary cell content

Microsoft's Hyperlink.Address reference defines the address as the target document's string address, while its Hyperlinks collection reference shows that a worksheet range can own a hyperlink. In the Open XML Hyperlink reference, the worksheet's x:hyperlink/@r:id is the relationship identifier that expresses that target location; the same element separately documents local location, display, and tooltip attributes. A cell's displayed value can therefore remain fixed while its relationship-backed external destination changes.

WCAB 0.31 isolates that review surface in one original synthetic package. Inputs!B2 retains the visible text Open vendor portal, one plain worksheet hyperlink declaration, no local location/display/tooltip fields, and the local Inputs!B2 → Summary!B2 → Dashboard!B4 formula context. The sole package difference is xl/worksheets/_rels/sheet1.xml.rels: its one external standard hyperlink relationship keeps the same ID, type, and TargetMode=External but its Target moves from approved.example.invalid to review.example.invalid. The validator reads only the local package parts, compares the relationship XML after erasing Target, and requires that relationship part to be the sole package difference. It does not resolve, open, fetch, visit, execute, calculate, or otherwise interact with either target, and does not claim that a client follows one.

PivotTable cache refresh requests without a cell edit

Microsoft documents an option to refresh PivotTable data when a workbook opens, and its PivotTable overview explains that PivotTables keep a cache that can be shared. The Open XML PivotCacheDefinition reference identifies refreshOnLoad as the stored instruction for whether an application refreshes that cache when the workbook opens. This leaves a material review surface outside worksheet-cell diffs: the request can change without a formula, source value, or stored display value changing.

WCAB 0.14 isolates this control in an original synthetic package with one local worksheet cache. Source!A1:B5 binds through a raw PivotCache/PivotTable relationship graph to Report!A1:B2; its stored Report!B2 is directly referenced by Dashboard!B4. The pair changes only pivotCacheDefinition/@refreshOnLoad from false to true. The raw validator checks the relationship binding, source declaration, stored report/dashboard cells, and package-member isolation. It does not open Excel, refresh data, calculate or render the PivotTable, infer a new report result, or claim that a client honors the setting.

PivotTable aggregation without a cell edit

Microsoft's PivotTable layout guidance describes moving fields into the Values area and changing their settings, while the Open XML DataField.Subtotal reference identifies subtotal as the stored data-consolidate function. A report can therefore switch from Sum to Average without changing a source cell, cached record, worksheet formula, or saved PivotTable display value.

WCAB 0.16 isolates that declaration in an original local package. It retains the Source!A1:B5 cache binding, Report!A1:B2 PivotTable location, all cache records, stored Report!B2, and Dashboard!B4=Report!$B$2; only the sole dataFields/dataField/@subtotal moves from sum to average. The raw validator follows the local relationship graph and compares the PivotTable part after removing that one attribute. It does not open Excel, refresh data, calculate or render the PivotTable, infer a changed display value, or claim client behavior.

PivotTable Slicer selection without a cell edit

Microsoft's PivotTable filtering guidance documents that Slicers filter PivotTables and make their current filtering state visible. The Office Open XML Slicer Cache Part specification records each cache item with an x index and stores selection with s=1. That makes a Slicer-cache selection a review surface outside ordinary cell and formula diffs.

WCAB 0.17 isolates that state in an original local package. It retains the Source!A1:B5 cache binding, Report!A1:B2 PivotTable location, cache records, stored Report!B2, and Dashboard!B4=Report!$B$2; only the selected Slicer cache item moves from index 0 (North) to index 1 (South). The raw validator follows the local workbook-to-Slicer-cache-to-PivotCache/PivotTable graph and compares the Slicer cache after removing only selection state. It creates no visual Slicer or drawing, does not apply the filter, refresh data, calculate or render a PivotTable, infer a report value, or claim client behavior.

Power Query definitions without a worksheet edit

Microsoft's Power Query overview explains that transformations are recorded and can be edited as M source. Its query-management guidance also makes clear that a query can load to a worksheet, the Data Model, or stay connection-only. The Power Query M language reference and Excel.CurrentWorkbook show why a local Excel Table can be a query source without an external service. That creates a high-value review surface: a query definition can materially change while all ordinary cells and any saved output remain unchanged.

WCAB 0.18 isolates a small, deterministic version of that boundary. It creates one generated SourceData Table at Source!A1:B5 and stores one connection-only M formula in a compact Data Mashup custom-XML part. The only semantic difference is Table.SelectRows changing its Region literal from North to South; the table, worksheet cells, formula-free dashboard text, metadata, permissions, and calculation properties stay fixed. The validator follows the package-root custom-XML relationship and parses only the generated, bounded envelope. It does not claim general Power Query support, execute M, apply a filter, refresh a query, materialize a result, calculate a workbook, infer returned rows, or predict client behavior.

Scenario Manager alternate inputs without a worksheet edit

Microsoft's Scenario Manager guidance defines a Scenario as a saved set of values that can be substituted into a worksheet, distinguishes changing cells from formula result cells, and supports scenario protection. It also explains that a scenario can hold up to 32 changing-cell values. The Open XML inputCells reference identifies the stored cell reference, cached value, deletion state, and display-only number format within a scenario. This puts material alternate assumptions in a raw worksheet control declaration rather than in the visible grid that an ordinary cell diff usually compares.

WCAB 0.19 deliberately uses one selected, locked scenario with two inputs so the changed value can be audited without expanding the case into scenario application or numerical evaluation.

WCAB 0.19 keeps visible Inputs!B2=0.1, Inputs!B3=125, Inputs!D2=B2*B3, and Dashboard!B4=Inputs!$D$2 fixed while a raw Scenario Manager inputCells/@val record for B2 moves from 0.08 to 0.16. The scenario's selection, protection, comment/user, summary reference, second input, and number-format metadata also remain fixed. The validator reads only the generated raw OOXML and checks the local formula path as a lower bound if a client applies the scenario. It does not show or apply a scenario, calculate a model, create a scenario summary, infer a result, or claim client behavior.

What-If Data Table input references without a formula edit

Microsoft's Data Table guidance defines one- and two-variable What-If Data Tables and distinguishes their row and column input cells. The Open XML CellFormula reference identifies a t="dataTable" master formula and its ref, r1, r2, dt2D, and dtr controls. Excel's calculation-performance guidance also notes that Data Tables trigger repeated recalculation and use a special calculation path. A review system therefore needs to notice a changed input reference even when ordinary cells and ordinary formula text do not change.

WCAB 0.20 isolates a column-oriented one-variable declaration in an original three-sheet workbook. The generated Sensitivity!D3 master has t="dataTable", ref="D3:D5", ca="1", and r1="B2"; the candidate changes only r1 to B3. Sensitivity!D2=Model!$B$2, input grid C3:C5, both possible local input values, Model!B2, Dashboard!B4, and all calculation properties stay fixed. The raw validator accepts only this compact shape and compares the worksheet after removing the single r1 value. It does not substitute an input, calculate the table or workbook, infer an output, interpret a circular dependency, or claim Excel-client behavior.

List data-validation sources without a cell edit

Microsoft's Excel data-validation API guidance describes list validation as a rule with formula fields, and the Open XML Formula1 reference states that the stored field can be a formula, constant, or list series. The MS-XLSX data-validation formula specification likewise defines formula1 and formula2 as validation formulas. A list-source declaration can therefore change the set of future permitted entries while the current input and any ordinary formula remain fixed.

This is also a practical comparison blind spot: one Excel reviewer described data-validation comparison as difficult in a Microsoft Tech Community discussion. That report is not treated as a broad measurement claim; it motivates an open, inspectable case with a precise raw OOXML boundary instead.

WCAB 0.21 keeps a single Inputs!B2 list validation, its error/prompt/dropdown controls, both Lists source columns, the current Draft input, calculation properties, Model!B2=Inputs!$B$2, and Dashboard!B4=Model!$B$2 fixed. Only the raw list formula1 moves from =Lists!$A$2:$A$4 to =Lists!$B$2:$B$4. The validator reads the generated raw declaration and ordinary direct formula path only. It does not evaluate a source formula, determine a future input's validity, accept or reject an input, calculate a workbook, or claim behavior from any Excel client.

Conditional-formatting thresholds without a cell edit

Microsoft's Open XML conditional-formatting guidance describes conditional formats as worksheet-level rules applied when a condition is true. Its cellIs example stores the comparison operator and a formula threshold inside cfRule; the MS-XLSX conditional-formatting formula specification likewise identifies cfRule formula elements as conditional-formatting formulas. A stored threshold can therefore change the visual exception criterion without a cell-value or ordinary-formula edit.

That boundary is relevant to review rather than merely to visual polish: ICAEW's spreadsheet-review guidance describes conditional formatting as part of spreadsheet review, while a comparison product can explicitly focus on entered values and formulas in its workbook comparison description. Those sources do not establish a population-wide coverage measurement; they motivate a small, inspectable rule-level case that distinguishes a changed criterion from an executed or rendered outcome.

WCAB 0.22 keeps one Operations!B2:B4 cellIs rule's target, priority, greaterThan operator, differential red fill, and stored 10, 75, and 120 metrics fixed. Only its raw formula threshold moves from 100 to 50. The validator compares the worksheet after erasing that one formula and requires the Operations worksheet to be the only changed package member. It does not evaluate the rule, decide which cells an Excel client formats, calculate a workbook, or claim client behavior.

Number formats can hide or reinterpret a value without a cell edit

Microsoft's percentage-format guidance explains that applying a percentage format to a stored decimal changes its display scale, while its hide/display guidance documents the custom ;;; format for hiding values on a worksheet. The MS-OI29500 numFmt notes likewise describe custom number formats and percentage formatting at the SpreadsheetML level. The stored format code is therefore a review surface that can change even while a cell's numeric value and formula text do not.

This is not merely cosmetic in a serious review workflow. ICAEW's spreadsheet review report lists display errors—including a percentage shown with integer formatting—as a review concern. Those sources do not establish a rendered outcome for a particular client, locale, or column width; they motivate a narrow, stored-metadata case rather than a screenshot-based assertion.

WCAB 0.23 keeps one Operations!B2 style index, raw 0.125 numeric value, neighboring =B2 formula, calculation properties, and every package member except xl/styles.xml fixed. Only its referenced custom numFmt/@formatCode moves from 0.0%;[Red](0.0%);- to ;;;. The validator follows the direct cell style to that one custom number-format record, compares styles XML after erasing only its code, and never renders, locale-resolves, calculates, or claims what an Excel client displays.

Error-checking suppressions can hide a review prompt without a formula edit

Microsoft's formula-error guidance states that an ignored error does not appear in subsequent error checks until the user resets ignored errors. The same guidance documents the rule for formulas that omit cells in a region: an adjacent, nonblank cell outside the referenced range can produce an error indicator. Microsoft's Office 2010 MS-XLSX ignoredErrors specification documents the stored extension form for per-range ignored-error declarations. Together, those sources identify an editable warning surface separate from an ordinary formula, result, or workbook-wide preference.

The useful benchmark boundary is intentionally smaller than a claim that a particular Excel client will display a triangle or that a formula is wrong. WCAB 0.24 keeps Operations!B2=10, B3=20, B4=30, B5=SUM(B2:B3), and C5=B5 fixed. Only one standard ignoredErrors/ignoredError record with sqref="B5" and formulaRange="1" is added. The validator removes that one declaration when comparing worksheet XML and requires the Operations worksheet to be the sole changed package member. It does not evaluate the formula, predict an Excel warning or indicator, decide whether suppression is justified, change application-level error checking, calculate, or claim client behavior.

Workbook-structure protection can change operational controls without a cell edit

Microsoft's Protect a workbook guidance states that protecting workbook structure controls adding, moving, deleting, hiding, unhiding, and renaming worksheets, and distinguishes that control from file and worksheet protection. Its password is optional. The Office Open XML workbookProtection specification identifies the stored workbook-level protection element. Those sources motivate a narrow review case for a governance setting that ordinary cell diffs can miss, without mistaking it for encryption or access control.

WCAB 0.25 keeps a hidden ReviewControls sheet and Inputs!D2=B2*C2 formula fixed while its raw workbookProtection/@lockStructure moves exactly from 1 to 0. The validator strips only that attribute when comparing xl/workbook.xml, requires that member to be the sole package difference, and checks the stable hidden sheet and formula context. It does not test a password, encryption, authentication, authorization, whether a hidden sheet becomes exposed, or an Excel client's sheet-operation behavior.

Sheet-protection sort permission can change without a cell edit

Microsoft's Protect a worksheet guidance lists Sort among the actions that can be permitted on a protected worksheet, while distinguishing worksheet protection from file protection. The Open XML SheetProtection reference defines the stored element and action attributes. This motivates a narrow governance-review case: a permission can change while every cell and formula is identical.

WCAB 0.33 retains Controls!D2=B2*C2, its direct Dashboard!B4=Controls!$D$2 consumer, enabled sheet protection, every other action lock, styles, and calculation properties. It changes only raw sheetProtection/@sort from 1 (locked) to 0 (permitted), leaving xl/worksheets/sheet1.xml as the sole package difference. The validator records that exact stored transition; it does not test a password, encryption, authentication, authorization, editable ranges, a client sort operation, a permission decision, or an output value.

Protected-range descriptors are stored review material, not access proof

ISO/IEC 29500's securityDescriptor example places one or more account descriptors as nested children of protectedRange. The standard's text describes these as accounts that may edit a range without providing the range password, while noting that the descriptor format is application-defined. The Open XML SDK's ProtectedRange reference also lists the nested child; separately, the Office 2010 extension's ProtectedRange surface documents an attribute-shaped variant. These sources make the document representation a legitimate review surface, but not a reason to infer identity, authentication, authorization, encryption, or enforcement by a given client.

WCAB 0.42 therefore uses only the standard nested child form. It keeps the protected sheet, locked Controls!B2:B2 target, legacy verifier, range name, formulas, calculation properties, and all other package members fixed while one synthetic child text changes. The raw validator verifies both synthetic texts privately and proves the worksheet-only package boundary. The public truth contract omits those texts, the range name, and the verifier so adapters can be scored on redacted material-change evidence rather than exposed account data.

Worksheet-control macro assignments can change without a cell edit

Microsoft's control-button guidance documents that Form and ActiveX controls can run a workbook macro when clicked. That makes a stored control-to-macro assignment review-material independently of the worksheet cells a button happens to sit beside. It does not require a benchmark to package or execute VBA: the security-relevant review boundary is already present in the local declaration.

WCAB 0.44.1 isolates a compact relationship-bound Form-control declaration. The baseline and candidate retain one worksheet control, its direct control-properties relationship and Office 2010 properties part, content type, ordinary Controls!B2=12 input, Controls!D2=B2*C2 formula, direct Dashboard!B4=Controls!$D$2 consumer, calculation properties, and every other package member. Only the private inline control macro assignment differs in xl/worksheets/sheet1.xml. The validator reads only this bounded local OOXML shape and compares the worksheets after removing that one attribute. It keeps the control identity, shape ID, macro names, relationship ID, and raw XML private; it does not load a control, inspect or execute VBA, resolve a macro, authenticate a user, evaluate permissions, invoke an Office client, or claim an event-dispatch result.

Sensitivity-label metadata is a package review surface, not an enforcement result

Microsoft's Sensitivity Label Information Part specification defines a package-root classificationlabels relationship targeting an application/xml part whose root is labelList. The LabelInfo stream specification documents the standard label-list shape, while the LabelInfo versus custom document properties note describes the older reserved custom-property representation. Those sources establish a real persisted review surface, but they do not justify inferring a label lookup, effective policy, encryption state, user permission, identity, or Office/SharePoint/OneDrive enforcement result from one local package diff.

WCAB therefore uses one generated standards-form envelope: docProps/custom.xml has a bound Sensitivity property and seven MSIP_Label_<GUID>_* properties; the package root has one bound LabelInfo relationship and docMetadata/LabelInfo.xml labelList part. Only the synthetic MIP Name value changes. The raw validator checks the identifiers, values, relationships, content types, and LabelInfo element privately; public truth publishes only counts, safe member boundaries, and fixed formula context. The case is scored as stored-metadata change detection, never as label resolution, policy evaluation, permission checking, client behavior, or service enforcement.

Chart series sources without a worksheet edit

Microsoft's chart-series guidance states that a user can change a series' values in the Select Data dialog without changing the worksheet data. The Open XML NumberReference definition captures the numeric-series reference in the chart part. That leaves a material review surface that cell and formula diffs can miss: a dashboard chart can point at another local range while every worksheet cell remains identical.

WCAB 0.15 isolates that stored binding in an original single-chart package. A chart anchored at Dashboard!D2 retains its host relationship, title reference, category reference, source cells, and all non-chart package members. Only its c:ser/c:val/c:numRef/c:f formula moves from Source!$B$2:$B$4 to Source!$C$2:$C$4. The validator follows the local worksheet-to-drawing-to- chart relationship chain and compares raw chart XML after removing the declared formula text. It does not calculate a source, refresh chart data, render a chart, infer a visible difference, or claim that an Excel client honors the stored source reference.

Array-formula semantics

Microsoft's dynamic-array versus legacy-CSE guidance distinguishes a dynamic array entered in one anchor cell from a legacy CSE formula entered across a fixed range. It also documents that dynamic arrays resize as source data changes while legacy CSE ranges do not. That creates a change-review concern beyond formula text: retaining the same array-capable formula and currently stored range can still change editability, resizing, and spill-blocker behavior.

WCAB 0.7 therefore uses a small original LEN array formula rather than a private workbook or a calculated result. The candidate adds the compact OOXML cell-metadata binding used by dynamic-array writers, while the validator checks only the stored mode, formula text, and range. It deliberately does not calculate the array, predict a future spill extent, or assert client-version compatibility.

Evidence scoring without a false-positive fiction

The NIST static-analysis methodology defines precision as reported true findings divided by all reported findings, and recall as reported true findings divided by all known findings. WCAB's truth is intentionally not a complete list of every difference in a workbook: it declares review-relevant facts plus coverage boundaries. Calling every unlisted tool observation a false positive would therefore misrepresent the oracle. Version 0.3 adds a normalized adapter protocol that measures recall of declared facts, analyzed coverage, and reference-policy agreement, while preserving unrecognized observations for review instead of forcing a precision claim.