{
  "format": "refined.math.definition",
  "schemaVersion": 1,
  "id": "custom-b1e88a62fbc56a9049971dcc",
  "revision": 1,
  "digest": "5f270f44d7ab4b3b0d2981c0250dd4e0db9b5ce4b9053e1290660cce06d173c6",
  "structure": "839019ce0a00741ec01b9e200e24c68970177782ea30400e997c56c7e753614c",
  "profile": {
    "format": "refined.math.adapter",
    "schemaVersion": 1,
    "adapterId": "customer-program",
    "version": "0.7.0",
    "name": {
      "en": "Cardinality-preserving weighted partition",
      "sk": "Vážené rozdelenie so zachovaním počtu"
    },
    "description": {
      "en": "Import your own initialization, evaluation, validator and operators as a bounded native program.",
      "sk": "Importujte vlastnú inicializáciu, hodnotenie, kontrolu a operátory ako ohraničený natívne vykonávaný program."
    },
    "help": {
      "en": "Program v1 uses exact integer, binary or permutation states. The admitted program runs inside the private native worker; Refined core source is not included.",
      "sk": "Program v1 používa presné celočíselné, binárne alebo permutačné stavy. Prijatý program beží v súkromnom natívnom workeri; zdrojový kód jadra Refined sa neposkytuje."
    },
    "runtime": {
      "binding": "customer-program",
      "coreRevision": "d2c02f944772b7f7a586c4f3357fc90e480349ad",
      "inputKey": "input"
    },
    "inputSchema": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "program": {},
        "data": {}
      },
      "required": [
        "program",
        "data"
      ]
    },
    "contract": {
      "state": {
        "en": "A caller-defined binary, integer or permutation vector with 1..512 values.",
        "sk": "Vektor s 1 až 512 hodnotami, ktorého binárnu, celočíselnú alebo permutačnú reprezentáciu určí autor."
      },
      "score": {
        "en": "Customer evaluation supplies nonnegative violations and an exact objective. The final state is re-evaluated and checked by the customer's validation hook.",
        "sk": "Vlastné hodnotenie určí nezáporné porušenia podmienok a presný cieľ. Konečný stav sa znovu vyhodnotí a skontroluje validačným programom autora."
      },
      "operators": {
        "en": [
          "Only the uploaded operator bodies supply state changes; no generic mathematical neighborhood is substituted."
        ],
        "sk": [
          "Zmeny stavu určujú výhradne nahrané operátory; nenahrádza ich generické matematické okolie."
        ]
      },
      "output": {
        "en": "Candidate values, objective, feasibility, fresh checks, actual Refined statistics and per-operator execution counters.",
        "sk": "Hodnoty kandidáta, cieľ, prípustnosť, čerstvé kontroly, skutočné štatistiky Refined a počítadlá vykonaní operátorov."
      }
    },
    "defaultTask": {
      "format": "refined.math.task",
      "schemaVersion": 1,
      "adapterId": "customer-program",
      "title": "Cardinality-preserving weighted partition",
      "payload": {
        "input": {
          "program": {
            "format": "refined.math.program",
            "schemaVersion": 1,
            "name": "Cardinality-preserving weighted partition",
            "parameters": [
              {
                "name": "weights",
                "minLength": 2,
                "maxLength": 128
              },
              {
                "name": "count",
                "minLength": 1,
                "maxLength": 1
              }
            ],
            "state": {
              "kind": "binary",
              "size": [
                "len",
                "weights"
              ]
            },
            "inputChecks": [
              [
                ">",
                [
                  "data",
                  "count",
                  0
                ],
                0
              ],
              [
                "<",
                [
                  "data",
                  "count",
                  0
                ],
                [
                  "len",
                  "weights"
                ]
              ]
            ],
            "initialize": [
              {
                "for": "i",
                "from": 0,
                "to": "size",
                "do": [
                  {
                    "set": "i",
                    "value": [
                      "<",
                      "i",
                      [
                        "data",
                        "count",
                        0
                      ]
                    ]
                  }
                ]
              }
            ],
            "evaluation": {
              "steps": [
                {
                  "let": "left",
                  "value": 0
                },
                {
                  "let": "total",
                  "value": 0
                },
                {
                  "let": "selected",
                  "value": 0
                },
                {
                  "for": "i",
                  "from": 0,
                  "to": "size",
                  "do": [
                    {
                      "let": "left",
                      "value": [
                        "+",
                        "left",
                        [
                          "*",
                          [
                            "state",
                            "i"
                          ],
                          [
                            "data",
                            "weights",
                            "i"
                          ]
                        ]
                      ]
                    },
                    {
                      "let": "total",
                      "value": [
                        "+",
                        "total",
                        [
                          "data",
                          "weights",
                          "i"
                        ]
                      ]
                    },
                    {
                      "let": "selected",
                      "value": [
                        "+",
                        "selected",
                        [
                          "state",
                          "i"
                        ]
                      ]
                    }
                  ]
                }
              ],
              "objective": [
                "abs",
                [
                  "-",
                  [
                    "*",
                    2,
                    "left"
                  ],
                  "total"
                ]
              ],
              "violations": [
                "abs",
                [
                  "-",
                  "selected",
                  [
                    "data",
                    "count",
                    0
                  ]
                ]
              ]
            },
            "validation": {
              "steps": [
                {
                  "let": "selected",
                  "value": 0
                },
                {
                  "for": "i",
                  "from": 0,
                  "to": "size",
                  "do": [
                    {
                      "let": "selected",
                      "value": [
                        "+",
                        "selected",
                        [
                          "state",
                          "i"
                        ]
                      ]
                    }
                  ]
                }
              ],
              "valid": [
                "==",
                "selected",
                [
                  "data",
                  "count",
                  0
                ]
              ]
            },
            "goal": "minimize",
            "operators": [
              {
                "name": "best_exchange",
                "steps": [
                  {
                    "let": "left",
                    "value": 0
                  },
                  {
                    "let": "total",
                    "value": 0
                  },
                  {
                    "let": "selected",
                    "value": 0
                  },
                  {
                    "for": "i",
                    "from": 0,
                    "to": "size",
                    "do": [
                      {
                        "let": "left",
                        "value": [
                          "+",
                          "left",
                          [
                            "*",
                            [
                              "state",
                              "i"
                            ],
                            [
                              "data",
                              "weights",
                              "i"
                            ]
                          ]
                        ]
                      },
                      {
                        "let": "total",
                        "value": [
                          "+",
                          "total",
                          [
                            "data",
                            "weights",
                            "i"
                          ]
                        ]
                      },
                      {
                        "let": "selected",
                        "value": [
                          "+",
                          "selected",
                          [
                            "state",
                            "i"
                          ]
                        ]
                      }
                    ]
                  },
                  {
                    "let": "best",
                    "value": [
                      "abs",
                      [
                        "-",
                        [
                          "*",
                          2,
                          "left"
                        ],
                        "total"
                      ]
                    ]
                  },
                  {
                    "let": "a",
                    "value": 0
                  },
                  {
                    "let": "b",
                    "value": 0
                  },
                  {
                    "for": "i",
                    "from": 0,
                    "to": "size",
                    "do": [
                      {
                        "if": [
                          "==",
                          [
                            "state",
                            "i"
                          ],
                          1
                        ],
                        "then": [
                          {
                            "for": "j",
                            "from": 0,
                            "to": "size",
                            "do": [
                              {
                                "if": [
                                  "==",
                                  [
                                    "state",
                                    "j"
                                  ],
                                  0
                                ],
                                "then": [
                                  {
                                    "let": "gap",
                                    "value": [
                                      "abs",
                                      [
                                        "-",
                                        [
                                          "*",
                                          2,
                                          [
                                            "+",
                                            [
                                              "-",
                                              "left",
                                              [
                                                "data",
                                                "weights",
                                                "i"
                                              ]
                                            ],
                                            [
                                              "data",
                                              "weights",
                                              "j"
                                            ]
                                          ]
                                        ],
                                        "total"
                                      ]
                                    ]
                                  },
                                  {
                                    "if": [
                                      "<",
                                      "gap",
                                      "best"
                                    ],
                                    "then": [
                                      {
                                        "let": "best",
                                        "value": "gap"
                                      },
                                      {
                                        "let": "a",
                                        "value": "i"
                                      },
                                      {
                                        "let": "b",
                                        "value": "j"
                                      }
                                    ]
                                  }
                                ]
                              }
                            ]
                          }
                        ]
                      }
                    ]
                  },
                  {
                    "swap": [
                      "a",
                      "b"
                    ]
                  }
                ]
              },
              {
                "name": "random_exchange",
                "steps": [
                  {
                    "let": "a",
                    "value": [
                      "random",
                      "size"
                    ]
                  },
                  {
                    "let": "b",
                    "value": [
                      "random",
                      "size"
                    ]
                  },
                  {
                    "swap": [
                      "a",
                      "b"
                    ]
                  }
                ]
              }
            ],
            "outputs": {
              "leftWeight": "left",
              "rightWeight": [
                "-",
                "total",
                "left"
              ],
              "selectedCount": "selected"
            }
          },
          "data": {
            "weights": [
              9,
              8,
              7,
              6,
              5,
              3
            ],
            "count": [
              3
            ]
          }
        }
      },
      "options": {
        "seed": 42,
        "timeLimitMs": 2000,
        "maxCandidateStates": 512
      }
    },
    "samples": []
  },
  "createdAt": "2026-10-23T11:05:03.797Z"
}