# Reports and developer tools

Choose a defined job, inspect its input and result example, then review its available payment options. Each is a one-time job with private result access for 30 days. Save a downloaded copy.

## Preemptive Release and Deadline Plan

Service ID: `preemptive-release-deadline-plan`. USD 9.00 per job.

Reconcile job completion lateness with an interruptible release-and-deadline schedule. Earliest-deadline single server; events split/resume jobs; objective is maximum signed completion lateness. Excludes setup and preemption cost. Declared supplied-record scheduling model. Integer time and cost units are caller-defined and must be consistent. At most two independent records and eight jobs per record, with stricter operation/mode search admission where needed; exact bounded enumeration, no probabilistic estimate, live dispatch or equipment control. Report compares the supplied recorded objective with the computed objective, including infeasible claims. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=preemptive-release-deadline-plan) · [Technical reference](https://people.orie.cornell.edu/shmoys/or6335/ch3.pdf)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "jobs": [
        {
          "duration": 4,
          "release": 0,
          "due": 6
        },
        {
          "duration": 1,
          "release": 1,
          "due": 2
        }
      ],
      "reportedObjective": 0
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/feasible": true,
  "/records/0/objective": 0,
  "/records/0/claimMatches": true
}
```

## Maximum On-Time Job Subset

Service ID: `maximum-on-time-job-subset`. USD 9.00 per job.

Identify the largest group of jobs that can finish by their due dates. All jobs available at zero; one nonpreemptive machine; objective is admitted count. Omitted jobs have no scheduled interval. Declared supplied-record scheduling model. Integer time and cost units are caller-defined and must be consistent. At most two independent records and eight jobs per record, with stricter operation/mode search admission where needed; exact bounded enumeration, no probabilistic estimate, live dispatch or equipment control. Report compares the supplied recorded objective with the computed objective, including infeasible claims. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=maximum-on-time-job-subset) · [Technical reference](https://www2.eecs.berkeley.edu/Pubs/TechRpts/1983/6344.html)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "jobs": [
        {
          "duration": 4,
          "due": 4
        },
        {
          "duration": 2,
          "due": 5
        },
        {
          "duration": 1,
          "due": 6
        }
      ],
      "reportedObjective": 2
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/feasible": true,
  "/records/0/objective": 2,
  "/records/0/claimMatches": true
}
```

## Precedence Maximum Lateness Plan

Service ID: `precedence-maximum-lateness-plan`. USD 9.00 per job.

Reconcile the least possible maximum lateness when jobs have prerequisites. One machine, all available at zero; exact topological-order search, signed lateness. No setups or release dates. Declared supplied-record scheduling model. Integer time and cost units are caller-defined and must be consistent. At most two independent records and eight jobs per record, with stricter operation/mode search admission where needed; exact bounded enumeration, no probabilistic estimate, live dispatch or equipment control. Report compares the supplied recorded objective with the computed objective, including infeasible claims. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=precedence-maximum-lateness-plan) · [Technical reference](https://pyjobshop.org/stable/)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "jobs": [
        {
          "duration": 2,
          "due": 3
        },
        {
          "duration": 1,
          "due": 1
        }
      ],
      "precedence": [
        {
          "before": 0,
          "after": 1
        }
      ],
      "reportedObjective": 2
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/feasible": true,
  "/records/0/objective": 2,
  "/records/0/claimMatches": true
}
```

## No-Wait Flow Shop Plan

Service ID: `no-wait-flowshop-plan`. USD 9.00 per job.

Plan a minimum-finish flow shop where each job moves between stages without waiting. Common permutation across two to four stages; no setup/release dates. Objective is makespan. Declared supplied-record scheduling model. Integer time and cost units are caller-defined and must be consistent. At most two independent records and eight jobs per record, with stricter operation/mode search admission where needed; exact bounded enumeration, no probabilistic estimate, live dispatch or equipment control. Report compares the supplied recorded objective with the computed objective, including infeasible claims. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=no-wait-flowshop-plan) · [Technical reference](https://pyjobshop.org/stable/examples/permutation_flow_shop.html)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "durations": [
        [
          2,
          3
        ],
        [
          3,
          1
        ]
      ],
      "reportedObjective": 6
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/feasible": true,
  "/records/0/objective": 6,
  "/records/0/claimMatches": true
}
```

## Blocking Flow Shop Plan

Service ID: `blocking-flowshop-plan`. USD 9.00 per job.

Plan a minimum-finish flow shop with no storage between stages. Upstream resource stays occupied until downstream acceptance, even after processing ends. Plan end records processing finish; downstream start witnesses blocking release. Declared supplied-record scheduling model. Integer time and cost units are caller-defined and must be consistent. At most two independent records and eight jobs per record, with stricter operation/mode search admission where needed; exact bounded enumeration, no probabilistic estimate, live dispatch or equipment control. Report compares the supplied recorded objective with the computed objective, including infeasible claims. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=blocking-flowshop-plan) · [Technical reference](https://pyjobshop.org/stable/examples/permutation_flow_shop.html)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "durations": [
        [
          2,
          3
        ],
        [
          3,
          1
        ]
      ],
      "reportedObjective": 6
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/feasible": true,
  "/records/0/objective": 6,
  "/records/0/claimMatches": true
}
```

## Unrelated Machine Assignment Plan

Service ID: `unrelated-machine-assignment-plan`. USD 9.00 per job.

Assign jobs to machines with different processing times to reduce the final completion time. One nonpreemptive operation per job, all available at zero; zero matrix entries mean forbidden assignments. Declared supplied-record scheduling model. Integer time and cost units are caller-defined and must be consistent. At most two independent records and eight jobs per record, with stricter operation/mode search admission where needed; exact bounded enumeration, no probabilistic estimate, live dispatch or equipment control. Report compares the supplied recorded objective with the computed objective, including infeasible claims. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=unrelated-machine-assignment-plan) · [Technical reference](https://pyjobshop.org/stable/)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "durations": [
        [
          3,
          1
        ],
        [
          2,
          4
        ],
        [
          2,
          2
        ]
      ],
      "reportedObjective": 3
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/feasible": true,
  "/records/0/objective": 3,
  "/records/0/claimMatches": true
}
```

## Machine Break Calendar Plan

Service ID: `machine-break-calendar-plan`. USD 9.00 per job.

Fit jobs around declared machine closures and reconcile the final finish time. One nonpreemptive machine, supplied releases and disjoint closure windows; no interrupted operation across breaks. Declared supplied-record scheduling model. Integer time and cost units are caller-defined and must be consistent. At most two independent records and eight jobs per record, with stricter operation/mode search admission where needed; exact bounded enumeration, no probabilistic estimate, live dispatch or equipment control. Report compares the supplied recorded objective with the computed objective, including infeasible claims. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=machine-break-calendar-plan) · [Technical reference](https://pyjobshop.org/stable/)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "jobs": [
        {
          "duration": 3,
          "release": 0
        },
        {
          "duration": 1,
          "release": 0
        }
      ],
      "breaks": [
        {
          "start": 2,
          "end": 4
        }
      ],
      "reportedObjective": 7
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/feasible": true,
  "/records/0/objective": 7,
  "/records/0/claimMatches": true
}
```

## Open Shop Operation Plan

Service ID: `open-shop-operation-plan`. USD 9.00 per job.

Plan a shortest finish when jobs may visit their required machines in any order. No job or machine can execute two operations at once; all jobs available at zero, no setups. Declared supplied-record scheduling model. Integer time and cost units are caller-defined and must be consistent. At most two independent records and eight jobs per record, with stricter operation/mode search admission where needed; exact bounded enumeration, no probabilistic estimate, live dispatch or equipment control. Report compares the supplied recorded objective with the computed objective, including infeasible claims. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=open-shop-operation-plan) · [Technical reference](https://pyjobshop.org/stable/)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "durations": [
        [
          2,
          1
        ],
        [
          1,
          2
        ]
      ],
      "reportedObjective": 3
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/feasible": true,
  "/records/0/objective": 3,
  "/records/0/claimMatches": true
}
```

## Hybrid Flow Shop Assignment Plan

Service ID: `hybrid-flowshop-assignment-plan`. USD 9.00 per job.

Choose parallel stage machines and processing order for a two-stage shop. All jobs available at zero; one operation at each stage, no setup or release constraints. Objective is makespan. Declared supplied-record scheduling model. Integer time and cost units are caller-defined and must be consistent. At most two independent records and eight jobs per record, with stricter operation/mode search admission where needed; exact bounded enumeration, no probabilistic estimate, live dispatch or equipment control. Report compares the supplied recorded objective with the computed objective, including infeasible claims. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=hybrid-flowshop-assignment-plan) · [Technical reference](https://pyjobshop.org/stable/)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "durations": [
        [
          2,
          2
        ],
        [
          2,
          2
        ]
      ],
      "firstStageMachines": 2,
      "secondStageMachines": 1,
      "reportedObjective": 6
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/feasible": true,
  "/records/0/objective": 6,
  "/records/0/claimMatches": true
}
```

## Assembly Join Completion Plan

Service ID: `assembly-join-completion-plan`. USD 9.00 per job.

Plan preparation and assembly work while respecting component joins. One preparation and one assembly station; each assembly waits for every supplied component; all operations mandatory. Declared supplied-record scheduling model. Integer time and cost units are caller-defined and must be consistent. At most two independent records and eight jobs per record, with stricter operation/mode search admission where needed; exact bounded enumeration, no probabilistic estimate, live dispatch or equipment control. Report compares the supplied recorded objective with the computed objective, including infeasible claims. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=assembly-join-completion-plan) · [Technical reference](https://pyjobshop.org/stable/)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "components": [
        2,
        1
      ],
      "assemblies": [
        {
          "duration": 3,
          "components": [
            0,
            1
          ]
        }
      ],
      "reportedObjective": 6
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/feasible": true,
  "/records/0/objective": 6,
  "/records/0/claimMatches": true
}
```

## Consumable Resource Start Plan

Service ID: `consumable-resource-start-plan`. USD 9.00 per job.

Reconcile a serial work plan with material withdrawals and replenishment events. Material is consumed at job start and does not renew at completion. Objective is final finish time; insufficient total material returns infeasible. Declared supplied-record scheduling model. Integer time and cost units are caller-defined and must be consistent. At most two independent records and eight jobs per record, with stricter operation/mode search admission where needed; exact bounded enumeration, no probabilistic estimate, live dispatch or equipment control. Report compares the supplied recorded objective with the computed objective, including infeasible claims. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=consumable-resource-start-plan) · [Technical reference](https://pyjobshop.org/stable/)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "jobs": [
        {
          "duration": 2,
          "consumption": 2
        },
        {
          "duration": 1,
          "consumption": 1
        }
      ],
      "initialStock": 1,
      "replenishments": [
        {
          "at": 3,
          "quantity": 2
        }
      ],
      "reportedObjective": 5
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/feasible": true,
  "/records/0/objective": 5,
  "/records/0/claimMatches": true
}
```

## Interval Order Batch Release Plan

Service ID: `interval-order-batch-release-plan`. USD 9.00 per job.

Group serial work into batches to reduce total order completion time. Batch duration is one setup plus summed processing; all members finish together after their latest release. No batch capacity or compatibility inference. Declared supplied-record scheduling model. Integer time and cost units are caller-defined and must be consistent. At most two independent records and eight jobs per record, with stricter operation/mode search admission where needed; exact bounded enumeration, no probabilistic estimate, live dispatch or equipment control. Report compares the supplied recorded objective with the computed objective, including infeasible claims. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=interval-order-batch-release-plan) · [Technical reference](https://pyjobshop.org/stable/)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "jobs": [
        {
          "duration": 2,
          "release": 0
        },
        {
          "duration": 1,
          "release": 0
        }
      ],
      "setup": 2,
      "reportedObjective": 10
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/feasible": true,
  "/records/0/objective": 10,
  "/records/0/claimMatches": true
}
```

## Perishable Completion Window Plan

Service ID: `perishable-completion-window-plan`. USD 9.00 per job.

Select the most valuable work that fits supplied release and finish windows. One nonpreemptive machine; unfinished or late jobs are omitted; objective is admitted total value. Declared supplied-record scheduling model. Integer time and cost units are caller-defined and must be consistent. At most two independent records and eight jobs per record, with stricter operation/mode search admission where needed; exact bounded enumeration, no probabilistic estimate, live dispatch or equipment control. Report compares the supplied recorded objective with the computed objective, including infeasible claims. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=perishable-completion-window-plan) · [Technical reference](https://pyjobshop.org/stable/)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "jobs": [
        {
          "duration": 3,
          "release": 0,
          "due": 3,
          "value": 2
        },
        {
          "duration": 1,
          "release": 0,
          "due": 2,
          "value": 5
        }
      ],
      "reportedObjective": 5
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/feasible": true,
  "/records/0/objective": 5,
  "/records/0/claimMatches": true
}
```

## Paired Crew Task Plan

Service ID: `paired-crew-task-plan`. USD 9.00 per job.

Choose approved worker pairs and synchronize their task intervals. One supplied pair per job; both workers are occupied together; minimize makespan. No inferred suitability or qualifications. Declared supplied-record scheduling model. Integer time and cost units are caller-defined and must be consistent. At most two independent records and eight jobs per record, with stricter operation/mode search admission where needed; exact bounded enumeration, no probabilistic estimate, live dispatch or equipment control. Report compares the supplied recorded objective with the computed objective, including infeasible claims. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=paired-crew-task-plan) · [Technical reference](https://pyjobshop.org/stable/)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "jobs": [
        {
          "duration": 2,
          "pairs": [
            [
              0,
              1
            ]
          ]
        },
        {
          "duration": 1,
          "pairs": [
            [
              1,
              2
            ]
          ]
        }
      ],
      "workers": 3,
      "reportedObjective": 3
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/feasible": true,
  "/records/0/objective": 3,
  "/records/0/claimMatches": true
}
```

## Precedence Unit Slot Plan

Service ID: `precedence-unit-slot-plan`. USD 9.00 per job.

Place unit-length prerequisite tasks into the fewest parallel time slots. Fixed number of identical processors; no releases or setup times. Every task is mandatory. Declared supplied-record scheduling model. Integer time and cost units are caller-defined and must be consistent. At most two independent records and eight jobs per record, with stricter operation/mode search admission where needed; exact bounded enumeration, no probabilistic estimate, live dispatch or equipment control. Report compares the supplied recorded objective with the computed objective, including infeasible claims. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=precedence-unit-slot-plan) · [Technical reference](https://pyjobshop.org/stable/)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "jobs": [
        {
          "id": "A"
        },
        {
          "id": "B"
        },
        {
          "id": "C"
        }
      ],
      "precedence": [
        {
          "before": 0,
          "after": 2
        },
        {
          "before": 1,
          "after": 2
        }
      ],
      "processors": 2,
      "reportedObjective": 2
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/feasible": true,
  "/records/0/objective": 2,
  "/records/0/claimMatches": true
}
```

## Multi-Mode Project Budget Plan

Service ID: `multimode-project-budget-plan`. USD 9.00 per job.

Choose activity duration and cost options that meet a project budget. All activities mandatory; precedence only, unlimited simultaneous ready work; minimize final finish. No renewable resource ceiling. Declared supplied-record scheduling model. Integer time and cost units are caller-defined and must be consistent. At most two independent records and eight jobs per record, with stricter operation/mode search admission where needed; exact bounded enumeration, no probabilistic estimate, live dispatch or equipment control. Report compares the supplied recorded objective with the computed objective, including infeasible claims. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=multimode-project-budget-plan) · [Technical reference](https://pyjobshop.org/stable/)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "jobs": [
        {
          "modes": [
            {
              "duration": 3,
              "cost": 1
            },
            {
              "duration": 1,
              "cost": 3
            }
          ]
        },
        {
          "modes": [
            {
              "duration": 2,
              "cost": 1
            }
          ]
        }
      ],
      "precedence": [
        {
          "before": 0,
          "after": 1
        }
      ],
      "budget": 4,
      "reportedObjective": 3
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/feasible": true,
  "/records/0/objective": 3,
  "/records/0/claimMatches": true
}
```

## Pickup and Delivery Precedence Route Plan

Service ID: `pickup-delivery-precedence-route-plan`. USD 9.00 per job.

Plan a least-cost depot tour that respects paired pickups and deliveries. One capacity-limited vehicle, directed supplied costs; each pickup precedes its own delivery. No road/timetable inference. Declared supplied-record scheduling model. Integer time and cost units are caller-defined and must be consistent. At most two independent records and eight jobs per record, with stricter operation/mode search admission where needed; exact bounded enumeration, no probabilistic estimate, live dispatch or equipment control. Report compares the supplied recorded objective with the computed objective, including infeasible claims. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=pickup-delivery-precedence-route-plan) · [Technical reference](https://developers.google.com/optimization/routing/pickup_delivery)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "costs": [
        [
          0,
          1,
          3
        ],
        [
          1,
          0,
          1
        ],
        [
          3,
          1,
          0
        ]
      ],
      "pairs": [
        {
          "pickup": 1,
          "delivery": 2,
          "quantity": 2
        }
      ],
      "capacity": 2,
      "reportedObjective": 5
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/feasible": true,
  "/records/0/objective": 5,
  "/records/0/claimMatches": true
}
```

## Poset Width and Antichain Witness API

Service ID: `poset-width-antichain-witness`. USD 1.00 per job.

Find the largest mutually independent task set and an equally sized chain partition. Unit-weight DAG, transitive comparability; outputs are antichain and chain witnesses, not order counts. Exact finite supplied graph model. Node order is supplied order; tie choices use node or edge indices. At most twelve vertices and sixty-six edges unless a stricter service profile applies. Integer weights are exact within the input profile. No network access, account change or live routing. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=poset-width-antichain-witness) · [Technical reference](https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.dag.antichains.html)

Example input:

```json
{
  "nodes": [
    "A",
    "B",
    "C"
  ],
  "edges": [
    {
      "from": "A",
      "to": "B",
      "weight": 1
    },
    {
      "from": "A",
      "to": "C",
      "weight": 1
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/width": 2,
  "/antichain": [
    "B",
    "C"
  ],
  "/chains": [
    [
      "A",
      "B"
    ],
    [
      "C"
    ]
  ]
}
```

## Chordal Elimination Certificate API

Service ID: `chordal-elimination-certificate`. USD 1.00 per job.

Determine whether a conflict graph admits a perfect elimination order. Return that order or a chordless induced cycle; unit-weight undirected graph, no fill edges added. Exact finite supplied graph model. Node order is supplied order; tie choices use node or edge indices. At most twelve vertices and sixty-six edges unless a stricter service profile applies. Integer weights are exact within the input profile. No network access, account change or live routing. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=chordal-elimination-certificate) · [Technical reference](https://networkx.org/documentation/stable/reference/algorithms/chordal.html)

Example input:

```json
{
  "nodes": [
    "A",
    "B",
    "C"
  ],
  "edges": [
    {
      "from": "A",
      "to": "B",
      "weight": 1
    },
    {
      "from": "B",
      "to": "C",
      "weight": 1
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/chordal": true,
  "/eliminationOrder": [
    "A",
    "B",
    "C"
  ],
  "/chordlessCycle": []
}
```

## K Shortest Loopless Paths API

Service ID: `k-shortest-loopless-paths`. USD 1.00 per job.

Return ranked route alternatives without repeating a vertex. Directed nonnegative integer costs; enumerate all paths within eight vertices and return the first k with deterministic ties. Exact finite supplied graph model. Node order is supplied order; tie choices use node or edge indices. At most twelve vertices and sixty-six edges unless a stricter service profile applies. Integer weights are exact within the input profile. No network access, account change or live routing. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=k-shortest-loopless-paths) · [Technical reference](https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.simple_paths.shortest_simple_paths.html)

Example input:

```json
{
  "nodes": [
    "A",
    "B",
    "C"
  ],
  "edges": [
    {
      "from": "A",
      "to": "B",
      "weight": 1
    },
    {
      "from": "B",
      "to": "C",
      "weight": 1
    }
  ],
  "source": "A",
  "target": "C",
  "k": 2
}
```

Selected expected result fields:

```json
{
  "/paths": [
    {
      "nodes": [
        "A",
        "B",
        "C"
      ],
      "weight": 2
    }
  ],
  "/availablePathCount": 1
}
```

## Triangle Truss Decomposition API

Service ID: `triangle-truss-decomposition`. USD 1.00 per job.

Identify links supported by progressively denser triangle groups. Unit-weight simple undirected graph; output each edge's maximum k-truss level. Exact finite supplied graph model. Node order is supplied order; tie choices use node or edge indices. At most twelve vertices and sixty-six edges unless a stricter service profile applies. Integer weights are exact within the input profile. No network access, account change or live routing. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=triangle-truss-decomposition) · [Technical reference](https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.core.k_truss.html)

Example input:

```json
{
  "nodes": [
    "A",
    "B",
    "C"
  ],
  "edges": [
    {
      "from": "A",
      "to": "B",
      "weight": 1
    },
    {
      "from": "B",
      "to": "C",
      "weight": 1
    },
    {
      "from": "A",
      "to": "C",
      "weight": 1
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/levels": [
    3,
    3,
    3
  ]
}
```

## Global Weighted Edge Cut API

Service ID: `global-weighted-edge-cut`. USD 1.00 per job.

Find the least total link capacity that separates a supplied network. Undirected nonnegative weights; no balanced-size constraint, disconnected graphs return a zero cut. Exact finite supplied graph model. Node order is supplied order; tie choices use node or edge indices. At most twelve vertices and sixty-six edges unless a stricter service profile applies. Integer weights are exact within the input profile. No network access, account change or live routing. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=global-weighted-edge-cut) · [Technical reference](https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.connectivity.stoerwagner.stoer_wagner.html)

Example input:

```json
{
  "nodes": [
    "A",
    "B",
    "C"
  ],
  "edges": [
    {
      "from": "A",
      "to": "B",
      "weight": 1
    },
    {
      "from": "B",
      "to": "C",
      "weight": 1
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/weight": 1,
  "/left": [
    "A"
  ],
  "/right": [
    "B",
    "C"
  ],
  "/crossingEdges": [
    0
  ]
}
```

## Minimum Feedback Vertex Removal API

Service ID: `minimum-feedback-vertex-removal`. USD 1.00 per job.

Choose the least-cost vertices whose removal breaks every directed cycle. Unit edge weights, supplied nonnegative vertex costs; return a topological order for retained vertices. Exact finite supplied graph model. Node order is supplied order; tie choices use node or edge indices. At most twelve vertices and sixty-six edges unless a stricter service profile applies. Integer weights are exact within the input profile. No network access, account change or live routing. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=minimum-feedback-vertex-removal) · [Technical reference](https://r.igraph.org/reference/feedback_vertex_set.html)

Example input:

```json
{
  "nodes": [
    "A",
    "B",
    "C"
  ],
  "edges": [
    {
      "from": "A",
      "to": "B",
      "weight": 1
    },
    {
      "from": "B",
      "to": "C",
      "weight": 1
    },
    {
      "from": "C",
      "to": "A",
      "weight": 1
    }
  ],
  "vertexCosts": [
    2,
    1,
    3
  ]
}
```

Selected expected result fields:

```json
{
  "/cost": 1,
  "/removed": [
    "B"
  ],
  "/retainedOrder": [
    "C",
    "A"
  ]
}
```

## Minimum Odd Cycle Transversal API

Service ID: `minimum-odd-cycle-transversal`. USD 1.00 per job.

Find the fewest vertices to remove so a conflict graph can use two groups. Unit-weight undirected graph; return deletion set and retained bipartite coloring. Exact finite supplied graph model. Node order is supplied order; tie choices use node or edge indices. At most twelve vertices and sixty-six edges unless a stricter service profile applies. Integer weights are exact within the input profile. No network access, account change or live routing. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=minimum-odd-cycle-transversal) · [Technical reference](https://arxiv.org/abs/2007.14514)

Example input:

```json
{
  "nodes": [
    "A",
    "B",
    "C"
  ],
  "edges": [
    {
      "from": "A",
      "to": "B",
      "weight": 1
    },
    {
      "from": "B",
      "to": "C",
      "weight": 1
    },
    {
      "from": "C",
      "to": "A",
      "weight": 1
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/removed": [
    "A"
  ],
  "/colors": [
    -1,
    0,
    1
  ]
}
```

## Graph Geodesic Convex Hull API

Service ID: `graph-geodesic-convex-hull`. USD 1.00 per job.

Expand seed vertices until every shortest path between included vertices stays inside the set. Unit-weight undirected graph; return the first closure round for each added vertex. Exact finite supplied graph model. Node order is supplied order; tie choices use node or edge indices. At most twelve vertices and sixty-six edges unless a stricter service profile applies. Integer weights are exact within the input profile. No network access, account change or live routing. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=graph-geodesic-convex-hull) · [Technical reference](https://doc.sagemath.org/html/en/reference/graphs/sage/graphs/convexity_properties.html)

Example input:

```json
{
  "nodes": [
    "A",
    "B",
    "C"
  ],
  "edges": [
    {
      "from": "A",
      "to": "B",
      "weight": 1
    },
    {
      "from": "B",
      "to": "C",
      "weight": 1
    }
  ],
  "seeds": [
    "A",
    "C"
  ]
}
```

Selected expected result fields:

```json
{
  "/hull": [
    "A",
    "B",
    "C"
  ],
  "/addedRound": [
    0,
    1,
    0
  ]
}
```

## Graph Minimum Resolving Landmarks API

Service ID: `graph-minimum-resolving-landmarks`. USD 1.00 per job.

Choose the fewest landmarks that distinguish every vertex by distance. Connected unit-weight undirected graph; return unique distance signatures. Exact finite supplied graph model. Node order is supplied order; tie choices use node or edge indices. At most twelve vertices and sixty-six edges unless a stricter service profile applies. Integer weights are exact within the input profile. No network access, account change or live routing. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=graph-minimum-resolving-landmarks) · [Technical reference](https://arxiv.org/abs/2206.15424)

Example input:

```json
{
  "nodes": [
    "A",
    "B",
    "C"
  ],
  "edges": [
    {
      "from": "A",
      "to": "B",
      "weight": 1
    },
    {
      "from": "B",
      "to": "C",
      "weight": 1
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/landmarks": [
    "A"
  ],
  "/signatures": [
    [
      0
    ],
    [
      1
    ],
    [
      2
    ]
  ]
}
```

## Graph Treedepth Elimination Forest API

Service ID: `graph-treedepth-elimination-forest`. USD 1.00 per job.

Build a minimum-height hierarchy that contains every graph edge in its ancestor closure. Unit-weight undirected graph; return parent indices and forest height. Exact finite supplied graph model. Node order is supplied order; tie choices use node or edge indices. At most twelve vertices and sixty-six edges unless a stricter service profile applies. Integer weights are exact within the input profile. No network access, account change or live routing. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=graph-treedepth-elimination-forest) · [Technical reference](https://arxiv.org/abs/1401.7540)

Example input:

```json
{
  "nodes": [
    "A",
    "B",
    "C"
  ],
  "edges": [
    {
      "from": "A",
      "to": "B",
      "weight": 1
    },
    {
      "from": "B",
      "to": "C",
      "weight": 1
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/height": 2,
  "/parent": [
    1,
    -1,
    1
  ]
}
```

## Tree Path Traffic Aggregation API

Service ID: `tree-path-traffic-aggregation`. USD 1.00 per job.

Add origin-destination quantities to every link along their unique tree paths. Nonnegative integer quantities, undirected tree; supplied edge weights do not change the unique path. Exact finite supplied graph model. Node order is supplied order; tie choices use node or edge indices. At most twelve vertices and sixty-six edges unless a stricter service profile applies. Integer weights are exact within the input profile. No network access, account change or live routing. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=tree-path-traffic-aggregation) · [Technical reference](https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.simple_paths.all_simple_paths.html)

Example input:

```json
{
  "nodes": [
    "A",
    "B",
    "C"
  ],
  "edges": [
    {
      "from": "A",
      "to": "B",
      "weight": 1
    },
    {
      "from": "B",
      "to": "C",
      "weight": 1
    }
  ],
  "demands": [
    {
      "from": "A",
      "to": "C",
      "quantity": 3
    },
    {
      "from": "B",
      "to": "C",
      "quantity": 2
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/loads": [
    3,
    5
  ],
  "/paths": [
    [
      0,
      1
    ],
    [
      1
    ]
  ]
}
```

## Tree Terminal Multicut API

Service ID: `tree-terminal-multicut`. USD 1.00 per job.

Choose least-cost tree links that separate every requested terminal pair. Undirected tree, nonnegative integer edge costs; return an intersecting cut witness for each pair. Exact finite supplied graph model. Node order is supplied order; tie choices use node or edge indices. At most twelve vertices and sixty-six edges unless a stricter service profile applies. Integer weights are exact within the input profile. No network access, account change or live routing. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=tree-terminal-multicut) · [Technical reference](https://arxiv.org/abs/2205.10105)

Example input:

```json
{
  "nodes": [
    "A",
    "B",
    "C"
  ],
  "edges": [
    {
      "from": "A",
      "to": "B",
      "weight": 1
    },
    {
      "from": "B",
      "to": "C",
      "weight": 1
    }
  ],
  "pairs": [
    {
      "from": "A",
      "to": "C"
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/cost": 1,
  "/cutEdges": [
    0
  ],
  "/pairWitnesses": [
    [
      0
    ]
  ]
}
```

## Difference Constraint Feasibility API

Service ID: `difference-constraint-feasibility`. USD 1.00 per job.

Reconcile relative upper-bound constraints or return a contradictory cycle. Solve x[to]-x[from] <= bound with signed integer bounds across every component. Exact finite supplied graph model. Node order is supplied order; tie choices use node or edge indices. At most twelve vertices and sixty-six edges unless a stricter service profile applies. Integer weights are exact within the input profile. No network access, account change or live routing. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=difference-constraint-feasibility) · [Technical reference](https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.shortest_paths.weighted.bellman_ford_predecessor_and_distance.html)

Example input:

```json
{
  "nodes": [
    "A",
    "B"
  ],
  "constraints": [
    {
      "from": "A",
      "to": "B",
      "bound": 2
    },
    {
      "from": "B",
      "to": "A",
      "bound": -1
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/feasible": true,
  "/potentials": [
    -1,
    0
  ],
  "/cycleConstraintIndices": [],
  "/cycleBound": null
}
```

## Bipartite Minimum Edge Cover API

Service ID: `bipartite-minimum-edge-cover`. USD 1.00 per job.

Choose the fewest relationships that touch every supplied item on both sides. Unit-weight graph with explicit bipartition; isolated vertices return an obstruction. Exact finite supplied graph model. Node order is supplied order; tie choices use node or edge indices. At most twelve vertices and sixty-six edges unless a stricter service profile applies. Integer weights are exact within the input profile. No network access, account change or live routing. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=bipartite-minimum-edge-cover) · [Technical reference](https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.covering.min_edge_cover.html)

Example input:

```json
{
  "nodes": [
    "A",
    "B",
    "C"
  ],
  "edges": [
    {
      "from": "A",
      "to": "B",
      "weight": 1
    },
    {
      "from": "B",
      "to": "C",
      "weight": 1
    }
  ],
  "left": [
    "A",
    "C"
  ]
}
```

Selected expected result fields:

```json
{
  "/feasible": true,
  "/coverEdges": [
    0,
    1
  ],
  "/isolated": [],
  "/matchingEdges": [
    0
  ]
}
```

## Minimum Spanning Forest Edge Roles API

Service ID: `minimum-spanning-forest-edge-roles`. USD 1.00 per job.

Identify links required, optional or excluded across all cheapest spanning forests. Undirected nonnegative integer edge costs; return a cheapest inclusion witness for every admitted edge. Exact finite supplied graph model. Node order is supplied order; tie choices use node or edge indices. At most twelve vertices and sixty-six edges unless a stricter service profile applies. Integer weights are exact within the input profile. No network access, account change or live routing. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=minimum-spanning-forest-edge-roles) · [Technical reference](https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.tree.mst.SpanningTreeIterator.html)

Example input:

```json
{
  "nodes": [
    "A",
    "B",
    "C"
  ],
  "edges": [
    {
      "from": "A",
      "to": "B",
      "weight": 1
    },
    {
      "from": "B",
      "to": "C",
      "weight": 1
    },
    {
      "from": "A",
      "to": "C",
      "weight": 2
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/cost": 2,
  "/roles": [
    "required",
    "required",
    "excluded"
  ],
  "/inclusionWitnesses": [
    [
      0,
      1
    ],
    [
      0,
      1
    ],
    []
  ]
}
```

## Temporal Contact Journeys API

Service ID: `temporal-contact-journeys`. USD 1.00 per job.

Dated directed contacts have strictly positive travel duration; waiting at vertices is permitted. Earliest arrival is minimized from the supplied departure lower bound. Contacts are finite supplied records, not a timetable fetched or a transport booking. At most twelve vertices and sixty-four contacts; exact integer time units. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=temporal-contact-journeys) · [Technical reference](https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.STACS.2026.24)

Example input:

```json
{
  "nodes": [
    "A",
    "B",
    "C"
  ],
  "contacts": [
    {
      "from": "A",
      "to": "B",
      "depart": 2,
      "arrive": 3
    },
    {
      "from": "B",
      "to": "C",
      "depart": 5,
      "arrive": 7
    },
    {
      "from": "A",
      "to": "C",
      "depart": 1,
      "arrive": 9
    }
  ],
  "source": "A",
  "earliestDeparture": 0
}
```

Selected expected result fields:

```json
{
  "/arrivals": [
    0,
    3,
    7
  ],
  "/contactPaths": [
    [],
    [
      0
    ],
    [
      0,
      1
    ]
  ],
  "/waits": [
    [],
    [
      2
    ],
    [
      2,
      2
    ]
  ]
}
```

## Normal Logic Policy Consequence Report

Service ID: `normal-logic-policy-consequence-report`. USD 9.00 per job.

Reconcile multiple always/sometimes/never claims across every stable alternative and retain countermodels. An inconsistent program supports no claims. Decisions remain supplied mathematical models. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=normal-logic-policy-consequence-report) · [Technical reference](https://www.cs.utexas.edu/users/vl/papers/stable.pdf)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "atoms": [
        "a",
        "b"
      ],
      "rules": [
        {
          "head": "a",
          "positive": [],
          "negative": [
            "b"
          ]
        },
        {
          "head": "b",
          "positive": [],
          "negative": [
            "a"
          ]
        }
      ],
      "claims": [
        {
          "atom": "a",
          "mode": "always"
        },
        {
          "atom": "b",
          "mode": "sometimes"
        }
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/modelCount": 2,
  "/records/0/claimResults/0/holds": false,
  "/records/0/claimResults/0/countermodel": [
    "b"
  ],
  "/records/0/claimResults/1/holds": true
}
```

## Catalog Attribute Closure Report

Service ID: `catalog-attribute-closure-report`. USD 9.00 per job.

Reconcile several category common-attribute claims against the same explicit incidence context, retaining missing and unsupported attributes. Empty object selections have every attribute by formal closure convention. Weighted computation profile: for each context use 2*(n*m+2^m*(3*n+m+8)+8*c^3+4*c^2+q*(m*n*n+n*n+3*m*m+3*m+8)), where n is object count, m attribute count, c closed-concept count and q supplied claim count (zero for the API). The sum across all supplied contexts must not exceed 10000000 before cover construction; otherwise FORMAL_CONTEXT_WORK_PROFILE rejects before checkout. This is not an elapsed-time guarantee. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=catalog-attribute-closure-report) · [Technical reference](https://concepts.readthedocs.io/en/stable/)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "objects": [
        "o1",
        "o2"
      ],
      "attributes": [
        "a",
        "b"
      ],
      "incidence": [
        [
          true,
          false
        ],
        [
          true,
          true
        ]
      ],
      "claims": [
        {
          "objects": [
            "o1",
            "o2"
          ],
          "attributes": [
            "b"
          ]
        }
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/conceptCount": 2,
  "/records/0/claimResults/0/actualAttributes": [
    "a"
  ],
  "/records/0/claimResults/0/missingAttributes": [
    "a"
  ],
  "/records/0/claimResults/0/unsupportedAttributes": [
    "b"
  ]
}
```

## Capability Merge Lattice Report

Service ID: `capability-merge-lattice-report`. USD 9.00 per job.

Review complete capability merge structure plus multiple declared merge outcomes; retain unavailable bounds and distributivity witnesses. No access-control or account setting is applied. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=capability-merge-lattice-report) · [Technical reference](https://doc.sagemath.org/html/en/reference/combinat/sage/combinat/posets/lattices.html)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "elements": [
        "bottom",
        "left",
        "right",
        "top"
      ],
      "lessEqual": [
        [
          "bottom",
          "left"
        ],
        [
          "bottom",
          "right"
        ],
        [
          "left",
          "top"
        ],
        [
          "right",
          "top"
        ]
      ],
      "merges": [
        {
          "left": "left",
          "right": "right",
          "claimedJoin": "left"
        }
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/isLattice": true,
  "/records/0/mergeResults/0/actualJoin": "top",
  "/records/0/mergeResults/0/matches": false
}
```

## Symmetry Subgroup Register Report

Service ID: `symmetry-subgroup-register-report`. USD 9.00 per job.

Reconcile multiple declared symmetry families, closure products and normality against the exact ambient finite group. No physical symmetry or security authorization is inferred. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=symmetry-subgroup-register-report) · [Technical reference](https://doc.sagemath.org/html/en/reference/groups/sage/groups/perm_gps/permgroup.html)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "table": [
        [
          0,
          1,
          2,
          3
        ],
        [
          1,
          2,
          3,
          0
        ],
        [
          2,
          3,
          0,
          1
        ],
        [
          3,
          0,
          1,
          2
        ]
      ],
      "families": [
        {
          "name": "bad",
          "members": [
            0,
            1
          ],
          "claimedNormal": true
        }
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/subgroupCount": 3,
  "/records/0/families/0/isSubgroup": false,
  "/records/0/families/0/missingProducts": [
    {
      "left": 1,
      "right": 1,
      "product": 2
    }
  ]
}
```

## Workflow Semigroup Ideal Report

Service ID: `workflow-semigroup-ideal-report`. USD 9.00 per job.

Compare multiple workflow equivalence claims with principal-ideal evidence over one supplied associative composition table. Ideal outputs for H/D claims are contextual two-sided ideals, while exact classes decide the claim. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=workflow-semigroup-ideal-report) · [Technical reference](https://doc.sagemath.org/html/en/reference/categories/sage/categories/semigroups.html)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "table": [
        [
          0,
          0
        ],
        [
          1,
          1
        ]
      ],
      "claims": [
        {
          "first": 0,
          "second": 1,
          "relation": "R",
          "equivalent": true
        }
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/classCounts/R": 2,
  "/records/0/claims/0/actual": false,
  "/records/0/claims/0/firstIdeal": [
    0
  ],
  "/records/0/claims/0/secondIdeal": [
    1
  ]
}
```

## Grammar Ambiguity Exposure Report

Service ID: `grammar-ambiguity-exposure-report`. USD 9.00 per job.

Review supplied example-word ambiguity claims and unreachable grammar scope with two concrete production histories. A witness pair is retained for each claimed word with bounded ambiguity; no unbounded unambiguity assertion follows from absence. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=grammar-ambiguity-exposure-report) · [Technical reference](https://comp.anu.edu.au/courses/comp3630/assets/lecture-pdfs/chapter7.pdf)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "start": "S",
      "nonterminals": [
        "S",
        "A",
        "B"
      ],
      "terminals": [
        "x"
      ],
      "productions": [
        {
          "lhs": "S",
          "rhs": [
            "A"
          ]
        },
        {
          "lhs": "S",
          "rhs": [
            "B"
          ]
        },
        {
          "lhs": "A",
          "rhs": [
            "x"
          ]
        },
        {
          "lhs": "B",
          "rhs": [
            "x"
          ]
        }
      ],
      "maxSteps": 2,
      "maxWordLength": 1,
      "claimedUnambiguousWords": [
        [
          "x"
        ]
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/ambiguous": true,
  "/records/0/witness/first": [
    0,
    2
  ],
  "/records/0/boundedWordCount": 1,
  "/records/0/unreachableNonterminals": []
}
```

## Petri Workflow Siphon Marking Report

Service ID: `petri-workflow-siphon-marking-report`. USD 9.00 per job.

Review multiple declared protected supports and a supplied initial marking against siphon/trap incidence. Empty siphons are review evidence; deadlock, boundedness and liveness are not inferred. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=petri-workflow-siphon-marking-report) · [Technical reference](https://projects.laas.fr/tina/manuals/stan.html)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "places": [
        "p",
        "q"
      ],
      "transitions": [
        {
          "input": [
            "p"
          ],
          "output": [
            "q"
          ]
        },
        {
          "input": [
            "q"
          ],
          "output": [
            "p"
          ]
        }
      ],
      "marking": [
        0,
        0
      ],
      "claimedProtectedSupports": [
        [
          "p"
        ]
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/unmarkedSiphons": [
    [
      "p",
      "q"
    ]
  ],
  "/records/0/supportResults/0/isTrap": false,
  "/records/0/supportResults/0/marked": false
}
```

## Adversarial Route Coverage Report

Service ID: `adversarial-route-coverage-report`. USD 9.00 per job.

Reconcile multiple claimed guaranteed states and proposed owned-state choices under explicit adversarial routing. Attractor-rank progress is sufficient for this reachability objective; no real routing changes. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=adversarial-route-coverage-report) · [Technical reference](https://www.prismmodelchecker.org/games/properties.php)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "states": [
        "start",
        "goal",
        "bad"
      ],
      "owner": [
        0,
        0,
        1
      ],
      "edges": [
        {
          "from": "start",
          "to": "goal"
        },
        {
          "from": "start",
          "to": "bad"
        },
        {
          "from": "goal",
          "to": "goal"
        },
        {
          "from": "bad",
          "to": "bad"
        }
      ],
      "targets": [
        "goal"
      ],
      "claimedGuaranteed": [
        "start",
        "bad"
      ],
      "choices": [
        {
          "state": "start",
          "next": "bad"
        }
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/incorrectGuarantees": [
    "bad"
  ],
  "/records/0/choiceResults/0/rankDecreases": false
}
```

## Coverage Complex Topology Report

Service ID: `coverage-complex-topology-report`. USD 9.00 per job.

Reconcile a full explicit face inventory and five recorded GF2 Betti counts with supplied facets. Multi-way coverage is a caller model; no physical coverage or geometric nerve assumptions are inferred. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=coverage-complex-topology-report) · [Technical reference](https://gudhi.inria.fr/python/latest/simplex_tree_ref.html)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "vertices": [
        "a",
        "b",
        "c"
      ],
      "facets": [
        [
          "a",
          "b"
        ],
        [
          "b",
          "c"
        ],
        [
          "a",
          "c"
        ]
      ],
      "explicitFaces": [
        [
          "a"
        ],
        [
          "b"
        ],
        [
          "c"
        ],
        [
          "a",
          "b"
        ],
        [
          "b",
          "c"
        ]
      ],
      "recordedBetti": [
        1,
        0,
        0,
        0,
        0
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/betti": [
    1,
    1,
    0,
    0,
    0
  ],
  "/records/0/missingFaces": [
    [
      "a",
      "c"
    ]
  ],
  "/records/0/extraFaces": []
}
```

## HTTP2 Settings Stream Lifecycle Report

Service ID: `http2-settings-stream-lifecycle-report`. USD 9.00 per job.

Reconcile interleaved directional frame records, SETTINGS acknowledgements, continuation adjacency and both stream half-closures. Only client-initiated streams with no push are supported. No HPACK or DATA payload validation; an unfinished SETTINGS debt is reported as state, not automatically an error. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=http2-settings-stream-lifecycle-report) · [Technical reference](https://www.rfc-editor.org/rfc/rfc9113.html)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "events": [
        {
          "sender": "client",
          "frameHex": "000000040000000000"
        },
        {
          "sender": "server",
          "frameHex": "000000040100000000"
        },
        {
          "sender": "client",
          "frameHex": "000000010500000001"
        },
        {
          "sender": "server",
          "frameHex": "000000010500000001"
        }
      ],
      "claimedOpenStreams": [
        1
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/settingsDebt": {
    "client": 0,
    "server": 0
  },
  "/records/0/actualOpenStreams": [],
  "/records/0/streams/0/clientEnded": true,
  "/records/0/streams/0/serverEnded": true
}
```

## FastCGI Multiplexed Request Report

Service ID: `fastcgi-multiplexed-request-report`. USD 9.00 per job.

Review normalized application-record metadata across multiplexed request IDs, role-specific input closures, output closure, aborts and completion claims. One lifetime per request ID; management records, payload interpretation and live execution excluded. role is used only on BEGIN_REQUEST. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=fastcgi-multiplexed-request-report) · [Technical reference](https://fastcgi-archives.github.io/FastCGI_Specification.html)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "events": [
        {
          "type": 1,
          "requestId": 1,
          "contentLength": 8,
          "role": 1
        },
        {
          "type": 4,
          "requestId": 1,
          "contentLength": 0,
          "role": 1
        },
        {
          "type": 5,
          "requestId": 1,
          "contentLength": 0,
          "role": 1
        },
        {
          "type": 6,
          "requestId": 1,
          "contentLength": 0,
          "role": 1
        },
        {
          "type": 3,
          "requestId": 1,
          "contentLength": 8,
          "role": 1
        }
      ],
      "claimedCompleted": []
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/actualCompleted": [
    1
  ],
  "/records/0/requests/0/completed": true
}
```

## BGP Open Peer Compatibility Report

Service ID: `bgp-open-peer-compatibility-report`. USD 9.00 per job.

Compare paired classic OPEN captures with expected remote identity, exact hold negotiation, bilateral capability codes and AFI/reserved/SAFI hex values. Capability-specific negotiation beyond codes1/2/65 and live session reachability are excluded. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=bgp-open-peer-compatibility-report) · [Technical reference](https://www.rfc-editor.org/rfc/rfc4271.html)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "localHex": "ffffffffffffffffffffffffffffffff00210104fc00005ac00002010402020200",
      "remoteHex": "ffffffffffffffffffffffffffffffff00210104fc01001ec00002020402020200",
      "expectedRemoteAS": 64513,
      "claimedHoldTime": 90,
      "requiredCapabilities": [
        2
      ],
      "requiredFamilies": []
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/negotiatedHoldTime": 30,
  "/records/0/remoteAS": 64513,
  "/records/0/mutualCapabilities": [
    2
  ],
  "/records/0/missingCapabilities": []
}
```

## WebVTT Source Delivery Reconciliation Report

Service ID: `webvtt-source-delivery-reconciliation-report`. USD 9.00 per job.

Reconcile identity, order, exact timing, settings and text across two supplied cue files; anonymous cues match by source position. The cue-only parser rejects malformed files and duplicate identifiers. No audio/video playback or accessibility certification. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=webvtt-source-delivery-reconciliation-report) · [Technical reference](https://www.w3.org/TR/webvtt1/)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "sourceText": "WEBVTT\n\nA\n00:00.000 --> 00:01.000\nHello\n\nB\n00:01.000 --> 00:02.000\nWorld\n",
      "deliveredText": "WEBVTT\n\nA\n00:00.000 --> 00:01.100\nHello\n",
      "mediaDurationMs": 1000
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/sourceCount": 2,
  "/records/0/deliveredCount": 1,
  "/records/0/missing": [
    "B"
  ],
  "/records/0/mismatches": [
    {
      "cueKey": "A",
      "fields": [
        "endMs"
      ]
    }
  ],
  "/records/0/outsideMedia": [
    "A"
  ]
}
```

## ICC Profile Package Reconciliation Report

Service ID: `icc-profile-package-reconciliation-report`. USD 9.00 per job.

Reconcile multiple asset/profile contract declarations, required tag signatures and declared profile-key byte identity. Profile ID digest, required ICC conformance tag sets, tag payload interpretation and colour rendering are excluded. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=icc-profile-package-reconciliation-report) · [Technical reference](https://www.color.org/specification/ICC.1-2022-05.pdf)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "assets": [
        {
          "assetId": "image1",
          "profileHex": "0000008400000000044000006d6e74725247422058595a20000000000000000000000000616373700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
          "declaredProfileKey": "display",
          "expectedClass": "prtr",
          "expectedColourSpace": "RGB ",
          "requiredTags": [
            "wtpt"
          ]
        }
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/assets/0/missingTags": [
    "wtpt"
  ],
  "/records/0/assets/0/classMatches": false,
  "/records/0/assets/0/spaceMatches": true
}
```

## Transition Migration Observation Report

Service ID: `transition-migration-observation-report`. USD 9.00 per job.

Review a supplied cross-version relation pair by pair, both directions of every action edge and initial-state coverage. Counterexamples expose unmatched branches; no weak/tau equivalence or deployment qualification. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=transition-migration-observation-report) · [Technical reference](https://mcrl2.org/web/user_manual/fundamentals/labelled_transition_systems.html)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "old": {
        "states": [
          "a",
          "c"
        ],
        "labels": [
          "x",
          "y"
        ],
        "edges": [
          {
            "from": "a",
            "to": "c",
            "action": "go"
          }
        ]
      },
      "next": {
        "states": [
          "b",
          "d"
        ],
        "labels": [
          "x",
          "y"
        ],
        "edges": [
          {
            "from": "b",
            "to": "d",
            "action": "go"
          },
          {
            "from": "b",
            "to": "b",
            "action": "again"
          }
        ]
      },
      "relation": [
        [
          "a",
          "b"
        ],
        [
          "c",
          "d"
        ]
      ],
      "oldInitial": [
        "a"
      ],
      "nextInitial": [
        "b"
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/pairResults/0/labelMatches": true,
  "/records/0/pairResults/0/oldUnmatched": [],
  "/records/0/pairResults/0/nextUnmatched": [
    {
      "action": "again",
      "to": "b"
    }
  ]
}
```

## Grammar Normalization Language Report

Service ID: `grammar-normalization-language-report`. USD 9.00 per job.

Review proposed CNF shape and finite token-language agreement using separately supplied original/proposed rewrite budgets. Both grammars are bounded to 8 nonterminals/20 productions. Budget differences can explain missing words; bounded agreement does not establish unbounded grammar equivalence. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=grammar-normalization-language-report) · [Technical reference](https://comp.anu.edu.au/courses/comp3630/assets/lecture-pdfs/chapter7.pdf)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "original": {
        "start": "S",
        "nonterminals": [
          "S"
        ],
        "terminals": [
          "a"
        ],
        "productions": [
          {
            "lhs": "S",
            "rhs": [
              "a"
            ]
          }
        ]
      },
      "proposed": {
        "start": "N",
        "nonterminals": [
          "N"
        ],
        "terminals": [
          "a",
          "b"
        ],
        "productions": [
          {
            "lhs": "N",
            "rhs": [
              "b"
            ]
          }
        ]
      },
      "originalMaxSteps": 1,
      "proposedMaxSteps": 1,
      "maxWordLength": 1
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/shapeViolations": [],
  "/records/0/missingWords": [
    [
      "a"
    ]
  ],
  "/records/0/extraWords": [
    [
      "b"
    ]
  ],
  "/records/0/originalWordCount": 1,
  "/records/0/proposedWordCount": 1
}
```

## Recurring Trace Acceptance Report

Service ID: `recurring-trace-acceptance-report`. USD 9.00 per job.

Reconcile multiple explicit ultimately periodic state traces, required recurring checkpoints and Buchi acceptance claims against one supplied model. Trace edges need at least one declared action; no token-word matching or real workflow execution. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=recurring-trace-acceptance-report) · [Technical reference](https://spot.lre.epita.fr/concepts.html)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "states": [
        "s",
        "a"
      ],
      "edges": [
        {
          "from": "s",
          "to": "a",
          "action": "go"
        },
        {
          "from": "a",
          "to": "a",
          "action": "tick"
        }
      ],
      "initial": "s",
      "accepting": [
        "a"
      ],
      "scenarios": [
        {
          "name": "valid",
          "prefix": [
            "s",
            "a"
          ],
          "loop": [
            "a",
            "a"
          ],
          "claimedAccepting": false,
          "requiredRecurring": [
            "a"
          ]
        }
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/scenariosAcceptedCount": 1,
  "/records/0/scenarios/0/validPath": true,
  "/records/0/scenarios/0/accepting": true,
  "/records/0/scenarios/0/claimMatches": false
}
```

## Relational Decomposition Integrity Report

Service ID: `relational-decomposition-integrity-report`. USD 9.00 per job.

Review attribute coverage, lossless-join tableau evidence and preservation under the union of projected functional dependencies, then reconcile both design claims. Finite schema-level analysis only; no SQL null/multivalued constraints or database changes. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=relational-decomposition-integrity-report) · [Technical reference](https://www.cs.sjsu.edu/faculty/pollett/157a.3.18f/Lec20180926.html)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "attributes": [
        "A",
        "B",
        "C"
      ],
      "relations": [
        [
          "A",
          "B"
        ],
        [
          "B",
          "C"
        ]
      ],
      "dependencies": [
        {
          "left": [
            "B"
          ],
          "right": [
            "C"
          ]
        }
      ],
      "claimedLossless": true,
      "claimedPreservesDependencies": false
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/lossless": true,
  "/records/0/missingAttributes": [],
  "/records/0/unpreservedDependencies": [],
  "/records/0/claimMatches": false
}
```

## HTTP2 Frame Stream Directory API

Service ID: `http2-frame-stream-directory`. USD 1.00 per job.

Decode frame envelopes plus core fixed-length constraints and SETTINGS. HPACK, flow-control state, header fields, padding and full payload validation are excluded. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=http2-frame-stream-directory) · [Technical reference](https://www.rfc-editor.org/rfc/rfc9113.html)

Example input:

```json
{
  "hex": "00000004010000000000000408000000000100000005"
}
```

Selected expected result fields:

```json
{
  "/frameCount": 2,
  "/frames/1/streamId": 1,
  "/frames/1/payloadHex": "00000005",
  "/byteLength": 22
}
```

## FastCGI Record Stream Directory API

Service ID: `fastcgi-record-stream-directory`. USD 1.00 per job.

Decode version1 records and concatenate supplied PARAMS content by request ID before UTF8 name/value decoding. Transport order and request lifecycle are reviewed separately; binary parameter names/values and multiple reused request lifetimes in one input are excluded. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=fastcgi-record-stream-directory) · [Technical reference](https://fastcgi-archives.github.io/FastCGI_Specification.html)

Example input:

```json
{
  "hex": "01010001000800000001010000000000010400010004000001014142"
}
```

Selected expected result fields:

```json
{
  "/recordCount": 2,
  "/records/0/role": 1,
  "/records/0/keepConnection": true,
  "/parameters/0/name": "A",
  "/parameters/0/value": "B"
}
```

## BGP Open Capability Directory API

Service ID: `bgp-open-capability-directory`. USD 1.00 per job.

Decode classic BGP4 OPEN with capability parameters. Extended OPEN lengths, UPDATE routing, signatures, live peers and session establishment are excluded. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=bgp-open-capability-directory) · [Technical reference](https://www.rfc-editor.org/rfc/rfc4271.html)

Example input:

```json
{
  "hex": "ffffffffffffffffffffffffffffffff00210104fc00005ac00002010402020200"
}
```

Selected expected result fields:

```json
{
  "/autonomousSystem": 64512,
  "/holdTime": 90,
  "/identifier": "192.0.2.1",
  "/capabilities/0/code": 2
}
```

## WebVTT Cue Block Decoder API

Service ID: `webvtt-cue-block-decoder`. USD 1.00 per job.

Cue-only profile supports optional identifiers, exact timestamps and vertical/align/size settings; size retains its decimal text and must be from 0 through 100 percent. NOTE, STYLE, REGION, other settings, rendering and cue markup validation are excluded. Overlap is permitted. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=webvtt-cue-block-decoder) · [Technical reference](https://www.w3.org/TR/webvtt1/)

Example input:

```json
{
  "text": "WEBVTT\n\nA\n00:00.000 --> 00:01.250 align:start\nHello\n\nB\n00:01.000 --> 00:02.000\nWorld\n"
}
```

Selected expected result fields:

```json
{
  "/cueCount": 2,
  "/cues/0/endMs": 1250,
  "/cues/1/startMs": 1000,
  "/durationMs": 2000
}
```

## ICC Profile Tag Directory API

Service ID: `icc-profile-tag-directory`. USD 1.00 per job.

Inspect a complete version4 profile byte envelope and tag directory with exact shared-range allowance. Required-tag completeness, profile ID digest, tag payload interpretation and colour rendering are excluded. A structurally readable empty directory is not a conformant usable profile. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=icc-profile-tag-directory) · [Technical reference](https://www.color.org/specification/ICC.1-2022-05.pdf)

Example input:

```json
{
  "hex": "0000008400000000044000006d6e74725247422058595a20000000000000000000000000616373700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
}
```

Selected expected result fields:

```json
{
  "/version": "4.4.0",
  "/deviceClass": "mntr",
  "/tagCount": 0
}
```

## Finite Transition Bisimulation Partition API

Service ID: `finite-transition-bisimulation-partition`. USD 1.00 per job.

Compute strong bisimulation of at most 16 observed states and 64 action-labelled edges. Internal tau abstraction and weak bisimulation are excluded. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=finite-transition-bisimulation-partition) · [Technical reference](https://mcrl2.org/web/user_manual/fundamentals/labelled_transition_systems.html)

Example input:

```json
{
  "states": [
    "a",
    "b",
    "c"
  ],
  "labels": [
    "x",
    "x",
    "y"
  ],
  "edges": [
    {
      "from": "a",
      "to": "c",
      "action": "go"
    },
    {
      "from": "b",
      "to": "c",
      "action": "go"
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/classes": [
    [
      "a",
      "b"
    ],
    [
      "c"
    ]
  ],
  "/classOf": [
    0,
    0,
    1
  ],
  "/classCount": 2
}
```

## Normal Logic Stable Model Enumeration API

Service ID: `normal-logic-stable-model-enumeration`. USD 1.00 per job.

Enumerate all stable models of at most 10 finite ground atoms and 32 normal rules; empty head denotes a constraint. Variables, functions, classical negation, disjunction and external facts are excluded. Empty model sets are reported explicitly. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=normal-logic-stable-model-enumeration) · [Technical reference](https://www.cs.utexas.edu/users/vl/papers/stable.pdf)

Example input:

```json
{
  "atoms": [
    "a",
    "b"
  ],
  "rules": [
    {
      "head": "a",
      "positive": [],
      "negative": [
        "b"
      ]
    },
    {
      "head": "b",
      "positive": [],
      "negative": [
        "a"
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/models": [
    [
      "a"
    ],
    [
      "b"
    ]
  ],
  "/always": [],
  "/sometimes": [
    "a",
    "b"
  ],
  "/never": []
}
```

## Formal Context Concept Lattice API

Service ID: `formal-context-concept-lattice`. USD 1.00 per job.

Enumerate exact intent/extent closure pairs and containment covers for a 10 by 10 Boolean incidence context; no approximate clustering or inference about absent data. Weighted computation profile: for each context use 2*(n*m+2^m*(3*n+m+8)+8*c^3+4*c^2+q*(m*n*n+n*n+3*m*m+3*m+8)), where n is object count, m attribute count, c closed-concept count and q supplied claim count (zero for the API). The sum across all supplied contexts must not exceed 10000000 before cover construction; otherwise FORMAL_CONTEXT_WORK_PROFILE rejects before checkout. This is not an elapsed-time guarantee. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=formal-context-concept-lattice) · [Technical reference](https://concepts.readthedocs.io/en/stable/)

Example input:

```json
{
  "objects": [
    "o1",
    "o2"
  ],
  "attributes": [
    "a",
    "b"
  ],
  "incidence": [
    [
      true,
      false
    ],
    [
      true,
      true
    ]
  ]
}
```

Selected expected result fields:

```json
{
  "/concepts": [
    {
      "extent": [
        "o1",
        "o2"
      ],
      "intent": [
        "a"
      ]
    },
    {
      "extent": [
        "o2"
      ],
      "intent": [
        "a",
        "b"
      ]
    }
  ],
  "/covers": [
    {
      "lower": 1,
      "upper": 0
    }
  ],
  "/conceptCount": 2
}
```

## Finite Lattice Law Witnesses API

Service ID: `finite-lattice-law-witnesses`. USD 1.00 per job.

Close supplied order pairs transitively, reject cycles, derive all pair meet/join values and a distributivity counterexample. Minus one means a unique bound is unavailable. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=finite-lattice-law-witnesses) · [Technical reference](https://doc.sagemath.org/html/en/reference/combinat/sage/combinat/posets/lattices.html)

Example input:

```json
{
  "elements": [
    "bottom",
    "left",
    "right",
    "top"
  ],
  "lessEqual": [
    [
      "bottom",
      "left"
    ],
    [
      "bottom",
      "right"
    ],
    [
      "left",
      "top"
    ],
    [
      "right",
      "top"
    ]
  ]
}
```

Selected expected result fields:

```json
{
  "/isLattice": true,
  "/distributive": true,
  "/bottom": 0,
  "/top": 3,
  "/complements": [
    [
      3
    ],
    [
      2
    ],
    [
      1
    ],
    [
      0
    ]
  ]
}
```

## Finite Group Subgroup Lattice API

Service ID: `finite-group-subgroup-lattice`. USD 1.00 per job.

Validate an associative group table of order at most 8, enumerate all subgroups and test conjugation normality. Ambient labels are table positions. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=finite-group-subgroup-lattice) · [Technical reference](https://doc.sagemath.org/html/en/reference/groups/sage/groups/perm_gps/permgroup.html)

Example input:

```json
{
  "table": [
    [
      0,
      1,
      2,
      3
    ],
    [
      1,
      2,
      3,
      0
    ],
    [
      2,
      3,
      0,
      1
    ],
    [
      3,
      0,
      1,
      2
    ]
  ]
}
```

Selected expected result fields:

```json
{
  "/identity": 0,
  "/inverses": [
    0,
    3,
    2,
    1
  ],
  "/subgroups": [
    {
      "members": [
        0
      ],
      "order": 1,
      "index": 4,
      "normal": true
    },
    {
      "members": [
        0,
        2
      ],
      "order": 2,
      "index": 2,
      "normal": true
    },
    {
      "members": [
        0,
        1,
        2,
        3
      ],
      "order": 4,
      "index": 1,
      "normal": true
    }
  ],
  "/covers": [
    {
      "lower": 0,
      "upper": 1
    },
    {
      "lower": 1,
      "upper": 2
    }
  ]
}
```

## Finite Semigroup Green Relations API

Service ID: `finite-semigroup-green-relations`. USD 1.00 per job.

Derive adjoined-identity principal ideals and Green relations in an associative table of at most 8 elements. No presentation-defined infinite semigroups. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=finite-semigroup-green-relations) · [Technical reference](https://doc.sagemath.org/html/en/reference/categories/sage/categories/semigroups.html)

Example input:

```json
{
  "table": [
    [
      0,
      0
    ],
    [
      1,
      1
    ]
  ]
}
```

Selected expected result fields:

```json
{
  "/leftIdeals": [
    [
      0,
      1
    ],
    [
      0,
      1
    ]
  ],
  "/rightIdeals": [
    [
      0
    ],
    [
      1
    ]
  ],
  "/L": [
    [
      0,
      1
    ]
  ],
  "/R": [
    [
      0
    ],
    [
      1
    ]
  ],
  "/H": [
    [
      0
    ],
    [
      1
    ]
  ],
  "/D": [
    [
      0,
      1
    ]
  ],
  "/J": [
    [
      0,
      1
    ]
  ]
}
```

## CFG Chomsky Normal Form Transform API

Service ID: `cfg-chomsky-normal-form-transform`. USD 1.00 per job.

Normalize a finite grammar through epsilon/unit elimination, terminal isolation and binary suffixes. Reserved internal names begin with @. The new start alone can retain epsilon. At most512 output productions. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=cfg-chomsky-normal-form-transform) · [Technical reference](https://comp.anu.edu.au/courses/comp3630/assets/lecture-pdfs/chapter7.pdf)

Example input:

```json
{
  "start": "S",
  "nonterminals": [
    "S",
    "A"
  ],
  "terminals": [
    "a",
    "b"
  ],
  "productions": [
    {
      "lhs": "S",
      "rhs": [
        "A",
        "b"
      ]
    },
    {
      "lhs": "A",
      "rhs": []
    },
    {
      "lhs": "A",
      "rhs": [
        "a"
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/start": "@start",
  "/nullableOriginal": [
    "A"
  ],
  "/productionCount": 6
}
```

## CFG Bounded Ambiguity Witness API

Service ID: `cfg-bounded-ambiguity-witness`. USD 1.00 per job.

Retain distinct leftmost production-index histories within at most 8 rewrites and 12 terminal tokens. A missing witness establishes only bounded absence. More than 5000 explored forms rejects. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=cfg-bounded-ambiguity-witness) · [Technical reference](https://comp.anu.edu.au/courses/comp3630/assets/lecture-pdfs/chapter7.pdf)

Example input:

```json
{
  "start": "S",
  "nonterminals": [
    "S",
    "A",
    "B"
  ],
  "terminals": [
    "x"
  ],
  "productions": [
    {
      "lhs": "S",
      "rhs": [
        "A"
      ]
    },
    {
      "lhs": "S",
      "rhs": [
        "B"
      ]
    },
    {
      "lhs": "A",
      "rhs": [
        "x"
      ]
    },
    {
      "lhs": "B",
      "rhs": [
        "x"
      ]
    }
  ],
  "maxSteps": 2,
  "maxWordLength": 1
}
```

Selected expected result fields:

```json
{
  "/ambiguous": true,
  "/witness": {
    "word": [
      "x"
    ],
    "first": [
      0,
      2
    ],
    "second": [
      1,
      3
    ]
  },
  "/words": [
    {
      "word": [
        "x"
      ],
      "history": [
        0,
        2
      ]
    }
  ]
}
```

## Petri Siphon Trap Enumeration API

Service ID: `petri-siphon-trap-enumeration`. USD 1.00 per job.

Enumerate inclusion-minimal nonempty siphon/trap supports of an ordinary unweighted net with at most 10 places. This is structural evidence, not liveness or deadlock certification. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=petri-siphon-trap-enumeration) · [Technical reference](https://projects.laas.fr/tina/manuals/stan.html)

Example input:

```json
{
  "places": [
    "p",
    "q"
  ],
  "transitions": [
    {
      "input": [
        "p"
      ],
      "output": [
        "q"
      ]
    },
    {
      "input": [
        "q"
      ],
      "output": [
        "p"
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/minimalSiphons": [
    [
      "p",
      "q"
    ]
  ],
  "/minimalTraps": [
    [
      "p",
      "q"
    ]
  ],
  "/siphonCount": 1,
  "/trapCount": 1
}
```

## Finite Reachability Game Strategy API

Service ID: `finite-reachability-game-strategy`. USD 1.00 per job.

Solve a total finite turn-based reachability game. Owner0 chooses and owner1 is adversarial; reaching a target ends the objective. Dead ends must be modelled by explicit self-loops. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=finite-reachability-game-strategy) · [Technical reference](https://www.prismmodelchecker.org/games/properties.php)

Example input:

```json
{
  "states": [
    "start",
    "goal",
    "bad"
  ],
  "owner": [
    0,
    0,
    1
  ],
  "edges": [
    {
      "from": "start",
      "to": "goal"
    },
    {
      "from": "start",
      "to": "bad"
    },
    {
      "from": "goal",
      "to": "goal"
    },
    {
      "from": "bad",
      "to": "bad"
    }
  ],
  "targets": [
    "goal"
  ]
}
```

Selected expected result fields:

```json
{
  "/winning": [
    "start",
    "goal"
  ],
  "/losing": [
    "bad"
  ],
  "/ranks": [
    1,
    0,
    -1
  ],
  "/strategy": [
    "goal",
    null,
    null
  ]
}
```

## Simplicial Complex GF2 Homology API

Service ID: `simplicial-complex-gf2-homology`. USD 1.00 per job.

Close supplied facets under nonempty faces, including every declared vertex. Exact GF2 boundary rank for dimension at most 4, 128 faces and at most 30 rows in each nontrivial boundary matrix; torsion/integer homology excluded. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=simplicial-complex-gf2-homology) · [Technical reference](https://gudhi.inria.fr/python/latest/simplex_tree_ref.html)

Example input:

```json
{
  "vertices": [
    "a",
    "b",
    "c"
  ],
  "facets": [
    [
      "a",
      "b"
    ],
    [
      "b",
      "c"
    ],
    [
      "a",
      "c"
    ]
  ]
}
```

Selected expected result fields:

```json
{
  "/faceCounts": [
    3,
    3,
    0,
    0,
    0
  ],
  "/boundaryRanks": [
    0,
    2,
    0,
    0,
    0
  ],
  "/betti": [
    1,
    1,
    0,
    0,
    0
  ],
  "/eulerCharacteristic": 0
}
```

## Relational Lossless Join Tableau Chase API

Service ID: `relational-lossless-join-tableau-chase`. USD 1.00 per job.

Chase a schema decomposition under functional dependencies using distinguished attribute symbols and per-cell variables. No actual database rows, multivalued dependencies, SQL nulls or database changes. Exact finite supplied-model inspection only. Input bounds limit computation. No external connection, execution, rendering, deployment, certification or control.  Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=relational-lossless-join-tableau-chase) · [Technical reference](https://www.cs.sjsu.edu/faculty/pollett/157a.3.18f/Lec20180926.html)

Example input:

```json
{
  "attributes": [
    "A",
    "B",
    "C"
  ],
  "relations": [
    [
      "A",
      "B"
    ],
    [
      "B",
      "C"
    ]
  ],
  "dependencies": [
    {
      "left": [
        "B"
      ],
      "right": [
        "C"
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/lossless": true,
  "/witnessRow": 0,
  "/tableau": [
    [
      0,
      1,
      2
    ],
    [
      6,
      1,
      2
    ]
  ],
  "/merges": [
    {
      "dependency": 0,
      "first": 0,
      "second": 1,
      "attribute": 2
    }
  ],
  "/missingAttributes": []
}
```

## Exposure Bracket Fusion Artifact Review

Service ID: `exposure-bracket-fusion-artifact-review`. USD 9.00 per job.

Audit the complete fused log-radiance artifact against a supplied known log-response table g[0..255]. Expected value is sum w(z)*(g[z]-ln(exposure))/sum w(z), with w(z)=min(z,255-z). Every frame requires a unique explicit ID and positive exposure. All-saturated pixels produce a null result and finding. No response estimation, registration, tone mapping or physical radiance calibration. Review supplied mathematical records and retain localized expected-versus-observed evidence. Maximum sixteen rows and columns per numeric grid and eight independent review records. Coordinates are zero-based row and column. Strict raw absolute comparisons use the supplied tolerance before twelve-significant-digit display rounding. No actual file processing, physical inspection, clinical interpretation or professional approval. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=exposure-bracket-fusion-artifact-review) · [Technical reference](https://www.pauldebevec.com/Research/HDR/debevec-siggraph97.pdf)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "frames": [
        {
          "id": "F1",
          "exposure": 1,
          "grid": [
            [
              1,
              0
            ]
          ]
        },
        {
          "id": "F2",
          "exposure": 1,
          "grid": [
            [
              2,
              255
            ]
          ]
        }
      ],
      "logResponse": [
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0
      ],
      "recordedLogRadiance": [
        [
          0,
          0
        ]
      ],
      "tolerance": 0
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/logRadiance": [
    [
      0,
      null
    ]
  ],
  "/records/0/contributors": [
    [
      2,
      0
    ]
  ],
  "/records/0/discrepancyCount": 1
}
```

## Dark Stack Defect Register Review

Service ID: `dark-stack-defect-register-review`. USD 9.00 per job.

Reconcile a dark-frame defect map: class 2 if temporal range is strictly above unstableRange; otherwise class 1 if temporal median is strictly above hotMedian; otherwise class 0. The map describes supplied samples, not a hardware defect diagnosis. Review supplied mathematical records and retain localized expected-versus-observed evidence. Maximum sixteen rows and columns per numeric grid and eight independent review records. Coordinates are zero-based row and column. Strict raw absolute comparisons use the supplied tolerance before twelve-significant-digit display rounding. No actual file processing, physical inspection, clinical interpretation or professional approval. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=dark-stack-defect-register-review) · [Technical reference](https://ccdproc.readthedocs.io/en/latest/reduction_toolbox.html)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "frames": [
        [
          [
            1,
            9
          ]
        ],
        [
          [
            1,
            11
          ]
        ],
        [
          [
            1,
            10
          ]
        ]
      ],
      "hotMedian": 8,
      "unstableRange": 3,
      "claimed": [
        [
          0,
          0
        ]
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/median": [
    [
      1,
      10
    ]
  ],
  "/records/0/range": [
    [
      0,
      2
    ]
  ],
  "/records/0/classification": [
    [
      0,
      1
    ]
  ],
  "/records/0/discrepancyCount": 1
}
```

## Mosaic Overlap Radiometry Review

Service ID: `mosaic-overlap-radiometry-review`. USD 9.00 per job.

Fit target=gain*source+offset by ordinary least squares on all paired overlap samples, then reconcile declared coefficients and every fitted pixel residual. Constant source overlaps reject. Review supplied mathematical records and retain localized expected-versus-observed evidence. Maximum sixteen rows and columns per numeric grid and eight independent review records. Coordinates are zero-based row and column. Strict raw absolute comparisons use the supplied tolerance before twelve-significant-digit display rounding. No actual file processing, physical inspection, clinical interpretation or professional approval. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=mosaic-overlap-radiometry-review) · [Technical reference](https://www.itl.nist.gov/div898/handbook/pmd/section4/pmd431.htm)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "source": [
        [
          0,
          1,
          2
        ]
      ],
      "target": [
        [
          1,
          3,
          5
        ]
      ],
      "recordedGain": 1,
      "recordedOffset": 1,
      "tolerance": 0
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/gain": 2,
  "/records/0/offset": 1,
  "/records/0/residuals": [
    [
      0,
      0,
      0
    ]
  ],
  "/records/0/discrepancyCount": 1
}
```

## Instance Label Split Merge Register Review

Service ID: `instance-label-split-merge-register-review`. USD 9.00 per job.

Audit a one-to-one supplied positive-label mapping. Label 0 is background. Retain all overlap counts including background, splits, merges, missing mapping labels and any pixel overlap outside its declared pair. Review supplied mathematical records and retain localized expected-versus-observed evidence. Maximum sixteen rows and columns per numeric grid and eight independent review records. Coordinates are zero-based row and column. Strict raw absolute comparisons use the supplied tolerance before twelve-significant-digit display rounding. No actual file processing, physical inspection, clinical interpretation or professional approval. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=instance-label-split-merge-register-review) · [Technical reference](https://scikit-image.org/docs/stable/api/skimage.metrics.html#skimage.metrics.contingency_table)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "reference": [
        [
          1,
          1,
          2
        ]
      ],
      "observed": [
        [
          3,
          4,
          4
        ]
      ],
      "mappings": [
        {
          "referenceLabel": 1,
          "observedLabel": 3
        },
        {
          "referenceLabel": 2,
          "observedLabel": 4
        }
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/splitLabels": [
    1
  ],
  "/records/0/mergedLabels": [
    4
  ],
  "/records/0/discrepancyCount": 3
}
```

## Contour Chain Raster Support Review

Service ID: `contour-chain-raster-support-review`. USD 9.00 per job.

Replay the eight-direction Freeman convention shown in the cited lecture: 0 east, 1 northeast, 2 north, 3 northwest, 4 west, 5 southwest, 6 south, 7 southeast. The following support-audit rules are this supplied-path profile: every visited cell must be foreground; only the final closure may repeat the starting pixel. This checks supplied path support, not full boundary completeness. Review supplied mathematical records and retain localized expected-versus-observed evidence. Maximum sixteen rows and columns per numeric grid and eight independent review records. Coordinates are zero-based row and column. Strict raw absolute comparisons use the supplied tolerance before twelve-significant-digit display rounding. No actual file processing, physical inspection, clinical interpretation or professional approval. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=contour-chain-raster-support-review) · [Technical reference](https://www.nii.ac.jp/userimg/lectures/20120319/Lecture5.pdf)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "mask": [
        [
          1,
          1
        ],
        [
          1,
          1
        ]
      ],
      "start": {
        "row": 0,
        "column": 0
      },
      "codes": [
        0,
        6,
        4,
        2
      ],
      "claimedEnd": {
        "row": 0,
        "column": 0
      },
      "claimedClosed": true
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/end": {
    "row": 0,
    "column": 0
  },
  "/records/0/closed": true,
  "/records/0/discrepancyCount": 0
}
```

## Image Pyramid Level Conservation Review

Service ID: `image-pyramid-level-conservation-review`. USD 9.00 per job.

Verify supplied complete two-by-two arithmetic-mean pyramid levels with no filtering, padding, rounding or partial blocks. Mismatch codes identify the child level. Review supplied mathematical records and retain localized expected-versus-observed evidence. Maximum sixteen rows and columns per numeric grid and eight independent review records. Coordinates are zero-based row and column. Strict raw absolute comparisons use the supplied tolerance before twelve-significant-digit display rounding. No actual file processing, physical inspection, clinical interpretation or professional approval. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=image-pyramid-level-conservation-review) · [Technical reference](https://scikit-image.org/docs/stable/api/skimage.transform.html#skimage.transform.downscale_local_mean)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "levels": [
        [
          [
            0,
            2
          ],
          [
            4,
            6
          ]
        ],
        [
          [
            4
          ]
        ]
      ],
      "tolerance": 0
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/levelMismatchCounts": [
    1
  ],
  "/records/0/discrepancyCount": 1
}
```

## Affine Fiducial Heldout Review

Service ID: `affine-fiducial-heldout-review`. USD 9.00 per job.

Fit xTarget=a*x+b*y+c and yTarget=d*x+e*y+f to calibration points by normal equations with a 1e-10 pivot/scale floor. Independently heldout points are not used for fitting. Reconcile heldout radial error and supplied recorded residual. Review supplied mathematical records and retain localized expected-versus-observed evidence. Maximum sixteen rows and columns per numeric grid and eight independent review records. Coordinates are zero-based row and column. Strict raw absolute comparisons use the supplied tolerance before twelve-significant-digit display rounding. No actual file processing, physical inspection, clinical interpretation or professional approval. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=affine-fiducial-heldout-review) · [Technical reference](https://scikit-image.org/docs/stable/api/skimage.transform.html#skimage.transform.AffineTransform)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "calibration": [
        {
          "source": {
            "x": 0,
            "y": 0
          },
          "target": {
            "x": 1,
            "y": 2
          }
        },
        {
          "source": {
            "x": 1,
            "y": 0
          },
          "target": {
            "x": 3,
            "y": 2
          }
        },
        {
          "source": {
            "x": 0,
            "y": 1
          },
          "target": {
            "x": 1,
            "y": 5
          }
        }
      ],
      "heldout": [
        {
          "source": {
            "x": 1,
            "y": 1
          },
          "target": {
            "x": 3,
            "y": 5
          },
          "recordedResidual": 0
        }
      ],
      "tolerance": 0
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/coefficients": [
    2,
    0,
    1,
    0,
    3,
    2
  ],
  "/records/0/predictions": [
    {
      "x": 3,
      "y": 5
    }
  ],
  "/records/0/residuals": [
    0
  ],
  "/records/0/discrepancyCount": 0
}
```

## Projective Cross Ratio Register Review

Service ID: `projective-crossratio-register-review`. USD 9.00 per job.

Reconcile CR(A,B;C,D)=AC*BD/(AD*BC) using signed coordinates projected along the first pair. Every source pair and target pair must have exactly distinct coordinates; repeated points reject with CROSS_RATIO_DEGENERATE before the existing datum/denominator checks. Collinearity residual is perpendicular distance; supplied tolerance applies separately to each recorded quantity. Review supplied mathematical records and retain localized expected-versus-observed evidence. Maximum sixteen rows and columns per numeric grid and eight independent review records. Coordinates are zero-based row and column. Strict raw absolute comparisons use the supplied tolerance before twelve-significant-digit display rounding. No actual file processing, physical inspection, clinical interpretation or professional approval. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=projective-crossratio-register-review) · [Technical reference](https://web.math.ucsb.edu/~sballas/260p/lectures/lecture5/)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "source": [
        {
          "x": 0,
          "y": 0
        },
        {
          "x": 1,
          "y": 0
        },
        {
          "x": 2,
          "y": 0
        },
        {
          "x": 3,
          "y": 0
        }
      ],
      "target": [
        {
          "x": 0,
          "y": 0
        },
        {
          "x": 2,
          "y": 0
        },
        {
          "x": 4,
          "y": 0
        },
        {
          "x": 6,
          "y": 0
        }
      ],
      "claimedRatio": 1,
      "tolerance": 0
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/sourceRatio": 1.33333333333,
  "/records/0/targetRatio": 1.33333333333,
  "/records/0/discrepancyCount": 1
}
```

## Epipolar Correspondence Residual Review

Service ID: `epipolar-correspondence-residual-review`. USD 9.00 per job.

Reconcile xSecond^T F xFirst=0 and squared Sampson distance. Normalize F by largest absolute coefficient; require rank two within 1e-10 determinant/minor profile. No camera estimation or correspondence discovery. Review supplied mathematical records and retain localized expected-versus-observed evidence. Maximum sixteen rows and columns per numeric grid and eight independent review records. Coordinates are zero-based row and column. Strict raw absolute comparisons use the supplied tolerance before twelve-significant-digit display rounding. No actual file processing, physical inspection, clinical interpretation or professional approval. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=epipolar-correspondence-residual-review) · [Technical reference](https://docs.opencv.org/4.x/da/de9/tutorial_py_epipolar_geometry.html)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "fundamental": [
        [
          0,
          0,
          0
        ],
        [
          0,
          0,
          -1
        ],
        [
          0,
          1,
          0
        ]
      ],
      "pairs": [
        {
          "first": {
            "x": 0,
            "y": 2
          },
          "second": {
            "x": 1,
            "y": 3
          },
          "claimedAccepted": true
        }
      ],
      "maximumSampson": 0
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/sampson": [
    0.5
  ],
  "/records/0/signedConstraints": [
    -1
  ],
  "/records/0/accepted": [
    false
  ],
  "/records/0/discrepancyCount": 1
}
```

## Polygon Mask Rasterization Review

Service ID: `polygon-mask-rasterization-review`. USD 9.00 per job.

Rasterize explicit rings by even-odd parity at centers (column+0.5,row+0.5). Boundary centers count as covered and also produce explicit ambiguity findings. Rings close implicitly; self-crossings follow even-odd parity. Review supplied mathematical records and retain localized expected-versus-observed evidence. Maximum sixteen rows and columns per numeric grid and eight independent review records. Coordinates are zero-based row and column. Strict raw absolute comparisons use the supplied tolerance before twelve-significant-digit display rounding. No actual file processing, physical inspection, clinical interpretation or professional approval. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=polygon-mask-rasterization-review) · [Technical reference](https://scikit-image.org/docs/stable/api/skimage.measure.html#skimage.measure.grid_points_in_poly)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "rings": [
        [
          {
            "x": 0,
            "y": 0
          },
          {
            "x": 2,
            "y": 0
          },
          {
            "x": 2,
            "y": 1
          },
          {
            "x": 0,
            "y": 1
          }
        ]
      ],
      "mask": [
        [
          1,
          0
        ]
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/expected": [
    [
      1,
      1
    ]
  ],
  "/records/0/boundaryCenters": [],
  "/records/0/discrepancyCount": 1
}
```

## Blur Kernel Forward Model Review

Service ID: `blur-kernel-forward-model-review`. USD 9.00 per job.

Reconcile observed arrays against circular convolution sum source[(row-r)mod H,(column-c)mod W]*kernel[r,c]. The top-left kernel element is zero displacement. Kernel entries are nonnegative and their sum must differ from one by at most 1e-12. Review supplied mathematical records and retain localized expected-versus-observed evidence. Maximum sixteen rows and columns per numeric grid and eight independent review records. Coordinates are zero-based row and column. Strict raw absolute comparisons use the supplied tolerance before twelve-significant-digit display rounding. No actual file processing, physical inspection, clinical interpretation or professional approval. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=blur-kernel-forward-model-review) · [Technical reference](https://scikit-image.org/docs/stable/api/skimage.restoration.html#skimage.restoration.richardson_lucy)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "source": [
        [
          2,
          4
        ]
      ],
      "kernel": [
        [
          0.5,
          0.5
        ]
      ],
      "observed": [
        [
          3,
          4
        ]
      ],
      "tolerance": 0
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/predicted": [
    [
      3,
      3
    ]
  ],
  "/records/0/discrepancyCount": 1
}
```

## Temporal Background Trend Register Review

Service ID: `temporal-background-trend-register-review`. USD 9.00 per job.

Fit each pixel against supplied strictly increasing times. Class 2 means detrended residual range exceeds its bound; otherwise class 1 means absolute time slope exceeds its bound; otherwise class 0. Times use a caller-consistent unit. Review supplied mathematical records and retain localized expected-versus-observed evidence. Maximum sixteen rows and columns per numeric grid and eight independent review records. Coordinates are zero-based row and column. Strict raw absolute comparisons use the supplied tolerance before twelve-significant-digit display rounding. No actual file processing, physical inspection, clinical interpretation or professional approval. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=temporal-background-trend-register-review) · [Technical reference](https://ccdproc.readthedocs.io/en/latest/reduction_toolbox.html)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "frames": [
        [
          [
            1,
            3
          ]
        ],
        [
          [
            2,
            3
          ]
        ],
        [
          [
            3,
            3
          ]
        ]
      ],
      "times": [
        0,
        1,
        2
      ],
      "maximumSlope": 0.5,
      "maximumResidualRange": 1,
      "claimed": [
        [
          0,
          0
        ]
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/slopes": [
    [
      1,
      0
    ]
  ],
  "/records/0/residualRanges": [
    [
      0,
      0
    ]
  ],
  "/records/0/classification": [
    [
      1,
      0
    ]
  ],
  "/records/0/discrepancyCount": 1
}
```

## Binary Mask Distance Witness Review

Service ID: `binary-mask-distance-witness-review`. USD 9.00 per job.

Verify each externally supplied nearest-background coordinate field and exact squared-distance matrix. All equally nearest valid background witnesses pass. Missing background and out-of-grid coordinates reject before checkout. Review supplied mathematical records and retain localized expected-versus-observed evidence. Maximum sixteen rows and columns per numeric grid and eight independent review records. Coordinates are zero-based row and column. Strict raw absolute comparisons use the supplied tolerance before twelve-significant-digit display rounding. No actual file processing, physical inspection, clinical interpretation or professional approval. Integral report quantities must remain exactly representable; unsupported calculation profiles reject before checkout. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=binary-mask-distance-witness-review) · [Technical reference](https://docs.scipy.org/doc/scipy/reference/generated/scipy.ndimage.distance_transform_edt.html)

Example input:

```json
{
  "records": [
    {
      "id": "R1",
      "mask": [
        [
          0,
          1,
          1
        ]
      ],
      "witnesses": [
        [
          {
            "row": 0,
            "column": 0
          },
          {
            "row": 0,
            "column": 0
          },
          {
            "row": 0,
            "column": 1
          }
        ]
      ],
      "recordedSquaredDistance": [
        [
          0,
          1,
          1
        ]
      ]
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/records/0/minimumSquaredDistance": [
    [
      0,
      1,
      4
    ]
  ],
  "/records/0/witnessSquaredDistance": [
    [
      0,
      1,
      1
    ]
  ],
  "/records/0/discrepancyCount": 2
}
```

## Grayscale Geodesic Reconstruction API

Service ID: `grayscale-geodesic-reconstruction`. USD 1.00 per job.

Reconstruct by synchronous four-neighbor grayscale dilation constrained above by mask; seed must be no greater than mask. changedRounds counts changed sweeps, excluding the final unchanged sweep. Calculate the declared mathematical model from supplied small numeric arrays. Grids have at most sixteen rows and columns; total elementary work is at most two million operations per job. Coordinates are zero-based row and column. No actual image file, clinical interpretation, remote sensing inference, physical control or certification. Floating results use twelve significant digits; strict comparisons precede display rounding. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=grayscale-geodesic-reconstruction) · [Technical reference](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.reconstruction)

Example input:

```json
{
  "seed": [
    [
      3,
      0,
      0
    ]
  ],
  "mask": [
    [
      3,
      2,
      3
    ]
  ]
}
```

Selected expected result fields:

```json
{
  "/grid": [
    [
      3,
      2,
      2
    ]
  ],
  "/changedRounds": 2
}
```

## Marker Minimax Flood Assignment API

Service ID: `marker-minimax-flood-assignment`. USD 1.00 per job.

For every marker independently minimize maximum elevation along four-neighbor paths, including both endpoints. Select the lowest barrier; equal barriers select the first supplied marker even at another marker cell. Labels are zero-based marker indices, not conventional watershed lines. Calculate the declared mathematical model from supplied small numeric arrays. Grids have at most sixteen rows and columns; total elementary work is at most two million operations per job. Coordinates are zero-based row and column. No actual image file, clinical interpretation, remote sensing inference, physical control or certification. Floating results use twelve significant digits; strict comparisons precede display rounding. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=marker-minimax-flood-assignment) · [Technical reference](https://scikit-image.org/docs/stable/api/skimage.segmentation.html#skimage.segmentation.watershed)

Example input:

```json
{
  "elevation": [
    [
      1,
      9,
      2
    ]
  ],
  "markers": [
    {
      "row": 0,
      "column": 0
    },
    {
      "row": 0,
      "column": 2
    }
  ]
}
```

Selected expected result fields:

```json
{
  "/labels": [
    [
      0,
      0,
      1
    ]
  ],
  "/barrier": [
    [
      1,
      9,
      2
    ]
  ]
}
```

## Grayscale Connected Area Opening API

Service ID: `grayscale-connected-area-opening`. USD 1.00 per job.

Use four-neighbor components of grid>=level at each distinct supplied gray level. Reconstruct each pixel at the largest level whose component area meets minimumArea; components failing at every level become zero. Calculate the declared mathematical model from supplied small numeric arrays. Grids have at most sixteen rows and columns; total elementary work is at most two million operations per job. Coordinates are zero-based row and column. No actual image file, clinical interpretation, remote sensing inference, physical control or certification. Floating results use twelve significant digits; strict comparisons precede display rounding. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=grayscale-connected-area-opening) · [Technical reference](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.area_opening)

Example input:

```json
{
  "grid": [
    [
      0,
      5,
      0
    ],
    [
      2,
      2,
      0
    ]
  ],
  "minimumArea": 2
}
```

Selected expected result fields:

```json
{
  "/grid": [
    [
      0,
      2,
      0
    ],
    [
      2,
      2,
      0
    ]
  ],
  "/removedIntensity": 3
}
```

## Eight Neighbor Local Binary Pattern API

Service ID: `eight-neighbor-local-binary-pattern`. USD 1.00 per job.

For interior pixels only, set bits 0..7 for neighbors northwest,north,northeast,east,southeast,south,southwest,west respectively when neighbor>=center. This is a square eight-neighbor profile with no circular interpolation. Histogram has 256 bins. Calculate the declared mathematical model from supplied small numeric arrays. Grids have at most sixteen rows and columns; total elementary work is at most two million operations per job. Coordinates are zero-based row and column. No actual image file, clinical interpretation, remote sensing inference, physical control or certification. Floating results use twelve significant digits; strict comparisons precede display rounding. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=eight-neighbor-local-binary-pattern) · [Technical reference](https://scikit-image.org/docs/stable/api/skimage.feature.html#skimage.feature.local_binary_pattern)

Example input:

```json
{
  "grid": [
    [
      1,
      1,
      1
    ],
    [
      1,
      0,
      1
    ],
    [
      1,
      1,
      1
    ]
  ]
}
```

Selected expected result fields:

```json
{
  "/codes": [
    [
      255
    ]
  ],
  "/histogram/255": 1
}
```

## Gray Level Run Length Texture API

Service ID: `gray-level-run-length-texture`. USD 1.00 per job.

Pool horizontal and vertical maximal runs into counts[gray][length-1]. Run emphasis uses squared lengths; gray nonuniformity is sum of squared gray run totals divided by runCount; runPercentage=runCount/(2*pixelCount). No clinical texture interpretation. Calculate the declared mathematical model from supplied small numeric arrays. Grids have at most sixteen rows and columns; total elementary work is at most two million operations per job. Coordinates are zero-based row and column. No actual image file, clinical interpretation, remote sensing inference, physical control or certification. Floating results use twelve significant digits; strict comparisons precede display rounding. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=gray-level-run-length-texture) · [Technical reference](https://pyradiomics.readthedocs.io/en/latest/features.html#gray-level-run-length-matrix-glrlm-features)

Example input:

```json
{
  "grid": [
    [
      0,
      0,
      1
    ]
  ],
  "levels": 2
}
```

Selected expected result fields:

```json
{
  "/counts": [
    [
      2,
      1,
      0
    ],
    [
      2,
      0,
      0
    ]
  ],
  "/runCount": 5,
  "/shortRunEmphasis": 0.85,
  "/longRunEmphasis": 1.6,
  "/grayNonuniformity": 2.6,
  "/runPercentage": 0.833333333333
}
```

## Central Gradient Harris Response API

Service ID: `central-gradient-harris-response`. USD 1.00 per job.

Centered differences have factor one half. Outer-border gradients and output responses are zero. Interior box windows clip to interior gradient cells; tensor terms are sums, with no Gaussian smoothing. Harris response=det(A)-k*trace(A)^2; eigenvalues use stable two-by-two formulas. Calculate the declared mathematical model from supplied small numeric arrays. Grids have at most sixteen rows and columns; total elementary work is at most two million operations per job. Coordinates are zero-based row and column. No actual image file, clinical interpretation, remote sensing inference, physical control or certification. Floating results use twelve significant digits; strict comparisons precede display rounding. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=central-gradient-harris-response) · [Technical reference](https://scikit-image.org/docs/stable/api/skimage.feature.html#skimage.feature.corner_harris)

Example input:

```json
{
  "grid": [
    [
      0,
      0,
      0
    ],
    [
      0,
      0,
      2
    ],
    [
      0,
      2,
      0
    ]
  ],
  "radius": 0,
  "k": 0.04
}
```

Selected expected result fields:

```json
{
  "/response/1/1": -0.16,
  "/lambdaMin/1/1": 0,
  "/lambdaMax/1/1": 2
}
```

## Prime Grid Finite Radon Transform API

Service ID: `prime-grid-finite-radon-transform`. USD 1.00 per job.

Prime dimension is one of 2,3,5,7,11,13. Projection[m][t]=sum_y grid[y][(t+m*y)mod p]; last projection is the row sums. Integer input magnitude at most one million makes every projection and total exactly representable. Calculate the declared mathematical model from supplied small numeric arrays. Grids have at most sixteen rows and columns; total elementary work is at most two million operations per job. Coordinates are zero-based row and column. No actual image file, clinical interpretation, remote sensing inference, physical control or certification. Floating results use twelve significant digits; strict comparisons precede display rounding. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=prime-grid-finite-radon-transform) · [Technical reference](https://scikit-image.org/docs/stable/api/skimage.transform.html#skimage.transform.frt2)

Example input:

```json
{
  "grid": [
    [
      1,
      2
    ],
    [
      3,
      4
    ]
  ]
}
```

Selected expected result fields:

```json
{
  "/projections": [
    [
      4,
      6
    ],
    [
      5,
      5
    ],
    [
      3,
      7
    ]
  ],
  "/lineMasses": [
    10,
    10,
    10
  ],
  "/totalMass": 10
}
```

## Bounded Grid Bilateral Filter API

Service ID: `bounded-grid-bilateral-filter`. USD 1.00 per job.

At every pixel use a clipped square radius neighborhood, no padding. Weight=exp(-spatialDistanceSquared/(2*spatialSigma^2)-intensityDifferenceSquared/(2*rangeSigma^2)); intensity units remain supplied 0..255. Return normalized weighted mean and weight sum. Calculate the declared mathematical model from supplied small numeric arrays. Grids have at most sixteen rows and columns; total elementary work is at most two million operations per job. Coordinates are zero-based row and column. No actual image file, clinical interpretation, remote sensing inference, physical control or certification. Floating results use twelve significant digits; strict comparisons precede display rounding. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=bounded-grid-bilateral-filter) · [Technical reference](https://scikit-image.org/docs/stable/api/skimage.restoration.html#skimage.restoration.denoise_bilateral)

Example input:

```json
{
  "grid": [
    [
      7
    ]
  ],
  "radius": 1,
  "spatialSigma": 1,
  "rangeSigma": 1
}
```

Selected expected result fields:

```json
{
  "/grid": [
    [
      7
    ]
  ],
  "/weightSums": [
    [
      1
    ]
  ]
}
```

## Circular Richardson Lucy Reconstruction API

Service ID: `circular-richardson-lucy-reconstruction`. USD 1.00 per job.

Start every estimate pixel at one. Repeat estimate*=adjointKernel(observed/convolve(estimate,kernel)) for exactly iterations. The top-left kernel element has zero displacement; boundaries are circular. Kernel is nonnegative and normalized within 1e-12. No clipping or hidden epsilon; intermediate values below 1e-100 reject. Calculate the declared mathematical model from supplied small numeric arrays. Grids have at most sixteen rows and columns; total elementary work is at most two million operations per job. Coordinates are zero-based row and column. No actual image file, clinical interpretation, remote sensing inference, physical control or certification. Floating results use twelve significant digits; strict comparisons precede display rounding. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=circular-richardson-lucy-reconstruction) · [Technical reference](https://scikit-image.org/docs/stable/api/skimage.restoration.html#skimage.restoration.richardson_lucy)

Example input:

```json
{
  "observed": [
    [
      2,
      4
    ]
  ],
  "kernel": [
    [
      1
    ]
  ],
  "iterations": 2
}
```

Selected expected result fields:

```json
{
  "/grid": [
    [
      2,
      4
    ]
  ],
  "/massTrajectory": [
    6,
    6
  ],
  "/absoluteResidual": 0
}
```

## Masked Grid Harmonic Interpolation API

Service ID: `masked-grid-harmonic-interpolation`. USD 1.00 per job.

At each missing cell solve degree*value-sum(unknownNeighbors)=sum(knownNeighbors) with the actual in-grid four-neighbor degree. At most 32 unknowns; at least one known sample. Preserve known samples. Partial-pivot solve uses a 1e-10 scale-relative pivot floor; output includes the maximum raw equation residual. Calculate the declared mathematical model from supplied small numeric arrays. Grids have at most sixteen rows and columns; total elementary work is at most two million operations per job. Coordinates are zero-based row and column. No actual image file, clinical interpretation, remote sensing inference, physical control or certification. Floating results use twelve significant digits; strict comparisons precede display rounding. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=masked-grid-harmonic-interpolation) · [Technical reference](https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csgraph.laplacian.html)

Example input:

```json
{
  "grid": [
    [
      0,
      0,
      4
    ]
  ],
  "missing": [
    [
      0,
      1,
      0
    ]
  ]
}
```

Selected expected result fields:

```json
{
  "/grid": [
    [
      0,
      2,
      4
    ]
  ],
  "/maximumResidual": 0,
  "/unknownCount": 1
}
```

## Cell Histogram of Oriented Gradients API

Service ID: `cell-histogram-oriented-gradients`. USD 1.00 per job.

Centered differences are evaluated only at interior pixels. Complete supplied cell sizes partition the full grid. Unsigned angles lie in [0,pi); distribute magnitude linearly between two cyclic angular bins. No block normalization, clipping, padding or rotation normalization. Calculate the declared mathematical model from supplied small numeric arrays. Grids have at most sixteen rows and columns; total elementary work is at most two million operations per job. Coordinates are zero-based row and column. No actual image file, clinical interpretation, remote sensing inference, physical control or certification. Floating results use twelve significant digits; strict comparisons precede display rounding. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=cell-histogram-oriented-gradients) · [Technical reference](https://scikit-image.org/docs/stable/api/skimage.feature.html#skimage.feature.hog)

Example input:

```json
{
  "grid": [
    [
      0,
      1,
      2
    ],
    [
      0,
      1,
      2
    ],
    [
      0,
      1,
      2
    ]
  ],
  "cellRows": 3,
  "cellColumns": 3,
  "bins": 2
}
```

Selected expected result fields:

```json
{
  "/histograms": [
    [
      [
        1,
        0
      ]
    ]
  ],
  "/magnitudeSum": 1
}
```

## Seven Hu Image Invariants API

Service ID: `seven-hu-image-invariants`. USD 1.00 per job.

Treat nonnegative gray values as weights, coordinates as row and column, and require positive total weight. Normalize central moment of total order k by mass^(1+k/2); return Hu invariants in conventional order. The seventh sign follows row-first coordinates; no mirror invariance is claimed. Calculate the declared mathematical model from supplied small numeric arrays. Grids have at most sixteen rows and columns; total elementary work is at most two million operations per job. Coordinates are zero-based row and column. No actual image file, clinical interpretation, remote sensing inference, physical control or certification. Floating results use twelve significant digits; strict comparisons precede display rounding. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=seven-hu-image-invariants) · [Technical reference](https://scikit-image.org/docs/stable/api/skimage.measure.html#skimage.measure.moments_hu)

Example input:

```json
{
  "grid": [
    [
      1,
      0,
      1
    ]
  ]
}
```

Selected expected result fields:

```json
{
  "/mass": 2,
  "/centroid": {
    "row": 0,
    "column": 1
  },
  "/hu": [
    0.5,
    0.25,
    0,
    0,
    0,
    0,
    0
  ]
}
```

## Grayscale Upper Component Tree API

Service ID: `grayscale-upper-component-tree`. USD 1.00 per job.

At distinct ascending gray levels enumerate four-neighbor upper components, collapsing repeated identical pixel sets. Each node retains its lowest level, area, sorted flat pixel indices and smallest canonical index; parent is the closest strict lower-level superset. Previous-level per-pixel ownership selects a parent directly, without prior-node subset searches. Row-major collection supplies sorted pixels without sorting. Before enumeration admit at most 2048+4*n*L+52*(n*L-L*(L-1)/2) charged operations, where n is pixel count and L is distinct gray-level count; the maximum 16 by 16 profile is 1974784, below two million. Output numeric traversal is included; VM instructions and elapsed time are not work units. This produces a hierarchy artifact, not a filtered image. Calculate the declared mathematical model from supplied small numeric arrays. Grids have at most sixteen rows and columns; total elementary work is at most two million operations per job. Coordinates are zero-based row and column. No actual image file, clinical interpretation, remote sensing inference, physical control or certification. Floating results use twelve significant digits; strict comparisons precede display rounding. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=grayscale-upper-component-tree) · [Technical reference](https://scikit-image.org/docs/stable/api/skimage.morphology.html#skimage.morphology.max_tree)

Example input:

```json
{
  "grid": [
    [
      0,
      2,
      0
    ]
  ]
}
```

Selected expected result fields:

```json
{
  "/nodes/0": {
    "level": 0,
    "area": 3,
    "canonicalPixel": 0,
    "parent": -1,
    "pixels": [
      0,
      1,
      2
    ]
  },
  "/nodes/1": {
    "level": 2,
    "area": 1,
    "canonicalPixel": 1,
    "parent": 0,
    "pixels": [
      1
    ]
  }
}
```

## Lucas Kanade Patch Motion API

Service ID: `lucas-kanade-patch-motion`. USD 1.00 per job.

Use first-patch centered spatial differences and second-minus-first temporal differences at interior pixels. Solve one constant displacement by two-by-two normal equations. Require determinant>1e-10*trace^2; return every interior brightness residual and zero outer-border residuals. No iteration, pyramid tracking or large-motion claim. Calculate the declared mathematical model from supplied small numeric arrays. Grids have at most sixteen rows and columns; total elementary work is at most two million operations per job. Coordinates are zero-based row and column. No actual image file, clinical interpretation, remote sensing inference, physical control or certification. Floating results use twelve significant digits; strict comparisons precede display rounding. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=lucas-kanade-patch-motion) · [Technical reference](https://docs.opencv.org/4.x/d4/dee/tutorial_optical_flow.html)

Example input:

```json
{
  "first": [
    [
      0,
      0,
      0,
      0
    ],
    [
      0,
      2,
      0,
      0
    ],
    [
      0,
      0,
      0,
      0
    ],
    [
      0,
      0,
      0,
      0
    ]
  ],
  "second": [
    [
      0,
      0,
      0,
      0
    ],
    [
      0,
      2,
      0,
      0
    ],
    [
      0,
      0,
      0,
      0
    ],
    [
      0,
      0,
      0,
      0
    ]
  ]
}
```

Selected expected result fields:

```json
{
  "/rowShift": 0,
  "/columnShift": 0,
  "/determinant": 1
}
```

## Integer Circle Hough Votes API

Service ID: `integer-circle-hough-votes`. USD 1.00 per job.

For each distinct positive integer radius and every in-grid integer center count edge pixels satisfying exact squaredDistance=radius^2. Radius order is supplied order; maxima ties choose first row-major center. This exact lattice-circle profile does not use rounded continuous circles. Calculate the declared mathematical model from supplied small numeric arrays. Grids have at most sixteen rows and columns; total elementary work is at most two million operations per job. Coordinates are zero-based row and column. No actual image file, clinical interpretation, remote sensing inference, physical control or certification. Floating results use twelve significant digits; strict comparisons precede display rounding. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=integer-circle-hough-votes) · [Technical reference](https://scikit-image.org/docs/stable/api/skimage.transform.html#skimage.transform.hough_circle)

Example input:

```json
{
  "edges": [
    [
      0,
      1,
      0
    ],
    [
      1,
      0,
      1
    ],
    [
      0,
      1,
      0
    ]
  ],
  "radii": [
    1
  ]
}
```

Selected expected result fields:

```json
{
  "/maxima": [
    {
      "radius": 1,
      "row": 1,
      "column": 1,
      "votes": 4
    }
  ]
}
```

## Quality Tree Phase Unwrapping API

Service ID: `quality-tree-phase-unwrapping`. USD 1.00 per job.

Anchor flat pixel 0 to its supplied phase. Grow a maximum-quality spanning tree using edge quality=min(endpointQuality); ties choose lowest child then parent flat index. Integrate phase differences into (-pi,pi]. Return parent indices and the maximum absolute non-tree wrapped-gradient closure discrepancy. Each undirected non-tree edge is measured once from the lower to the higher flat pixel index; tree and reverse edges are excluded. Inconsistent loops remain evidence. Calculate the declared mathematical model from supplied small numeric arrays. Grids have at most sixteen rows and columns; total elementary work is at most two million operations per job. Coordinates are zero-based row and column. No actual image file, clinical interpretation, remote sensing inference, physical control or certification. Floating results use twelve significant digits; strict comparisons precede display rounding. Use authorized, non-sensitive data. The report describes supplied records and does not change external systems.

[Open this service](https://gatewayinformationgroup.com/data-tools?tool=quality-tree-phase-unwrapping) · [Technical reference](https://scikit-image.org/docs/stable/api/skimage.restoration.html#skimage.restoration.unwrap_phase)

Example input:

```json
{
  "phase": [
    [
      3,
      -3
    ]
  ],
  "quality": [
    [
      1,
      1
    ]
  ]
}
```

Selected expected result fields:

```json
{
  "/unwrapped": [
    [
      3,
      3.28318530718
    ]
  ],
  "/parent": [
    -1,
    0
  ],
  "/maximumClosureResidual": 0
}
```

Use authorized, non-sensitive input. Each service applies its stated profile and does not change external systems or provide professional certification. A quote is unpaid; a signature alone does not establish settlement.