optimization-ai999x 1.6.0: Apache-2.0 release

.gitattributes

@@ -0,0 +1,44 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+dist/optimization_ai999x-1.0.0-py3-none-any.whl filter=lfs diff=lfs merge=lfs -text
+docs/optimization_ai999x_capabilities.pdf filter=lfs diff=lfs merge=lfs -text
+dist/optimization_ai999x-1.0.1-py3-none-any.whl filter=lfs diff=lfs merge=lfs -text
+dist/optimization_ai999x-1.0.2-py3-none-any.whl filter=lfs diff=lfs merge=lfs -text
+dist/optimization_ai999x-1.0.3-py3-none-any.whl filter=lfs diff=lfs merge=lfs -text
+docs/optimization_ai999x_rust_guide.pdf filter=lfs diff=lfs merge=lfs -text
+dist/optimization_ai999x-1.1.0-py3-none-any.whl filter=lfs diff=lfs merge=lfs -text
+dist/optimization_ai999x-1.5.0-py3-none-any.whl filter=lfs diff=lfs merge=lfs -text
+dist/optimization_ai999x-1.6.0-py3-none-any.whl filter=lfs diff=lfs merge=lfs -text

CITATION.cff

@@ -0,0 +1,24 @@
+cff-version: 1.2.0
+message: "If you use this software, please cite it as below."
+title: "optimization-ai999x: an offline, verified optimization solver"
+authors:
+  - family-names: Farabi
+    given-names: Ibnul Jaif
+    affiliation: AI999X
+version: 1.6.0
+license: Apache-2.0
+url: "https://huggingface.co/AI999X/optimization-ai999x"
+repository-code: "https://github.com/AI999X/optimization-ai999x"
+keywords:
+  - optimization
+  - operations-research
+  - linear-programming
+  - integer-programming
+  - network-optimization
+  - queueing
+  - inventory
+  - scheduling
+  - game-theory
+  - mcda
+  - ai999x
+  - offline

LICENSE

@@ -0,0 +1,204 @@
+Copyright 2026 AI999X Labs and Ibnul Jaif Farabi
+Contact: support@ai999x.com · ibnuljaiffarabi@ai999x.com · https://www.ai999x.com
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 AI999X Labs and Ibnul Jaif Farabi
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

NOTICE

@@ -0,0 +1,8 @@
+AI999X
+Copyright 2026 AI999X Labs and Ibnul Jaif Farabi
+
+Licensed under the Apache License, Version 2.0 (see LICENSE).
+
+support@ai999x.com
+ibnuljaiffarabi@ai999x.com
+https://www.ai999x.com

README.md

@@ -0,0 +1,1057 @@
+---
+license: apache-2.0
+license_link: LICENSE
+library_name: optimization-ai999x
+language:
+- en
+inference: false
+pipeline_tag: question-answering
+tags:
+- optimization
+- operations-research
+- linear-programming
+- integer-programming
+- network-optimization
+- queueing
+- inventory
+- scheduling
+- game-theory
+- mcda
+- linear-and-integer-programming
+- convex-and-nonlinear-optimisation
+- assignment
+- question-answering
+- rust
+- optimization-solver
+- step-by-step-solutions
+- homework-help
+- offline
+- zero-hallucination
+- python
+- ai999x
+model-index:
+- name: optimization-ai999x
+  results:
+  - task:
+      type: question-answering
+      name: optimization question answering
+    dataset:
+      name: "Golden answers (247 documented questions, Windows + Linux Python 3.10-3.14)"
+      type: ai999x-evaluation
+    metrics:
+    - type: accuracy
+      value: 1.0
+      name: "identical on every platform"
+---
+# optimization-ai999x: offline, verified optimization solver with step-by-step answers
+
+**[Desktop app & command line](https://www.ai999x.com/desktop-cli/)** · **[Compute in your browser](https://www.ai999x.com/models/optimization-ai999x/#try)** · **[Install (Python)](https://pypi.org/project/optimization-ai999x/)** · **[Guides](https://huggingface.co/AI999X/optimization-ai999x/tree/main/docs)** · **[Evaluation](https://huggingface.co/AI999X/optimization-ai999x/tree/main/evaluation)** · **[AI999X on Hugging Face](https://huggingface.co/AI999X)** · **[Website](https://ai999x.com)** · **[Support: Buy Me a Coffee](https://buymeacoffee.com/ibnuljaiffarabi)**
+
+License: Apache-2.0 · Author: Ibnul Jaif Farabi (creator and engineer) · Organization: AI999X · Version 1.6.0
+
+Field: **Mathematics & Statistics** · Tasks: Question Answering
+
+optimization-ai999x is an offline, deterministic optimization solver written in Rust: a desktop app, a command-line program, a browser module and a Python package. It answers optimization questions with verified results from 73 certified capabilities, gives 247 documented answers identically on Windows and Linux, and refuses rather than guesses when an answer cannot be verified.
+
+**optimization-ai999x** reads a question in plain English (or a typed call), picks a certified optimization capability, computes the answer exactly, checks it, and returns the result with its steps, units, LaTeX and assumptions, or a refusal that says what is missing. It runs fully offline on any CPU, needs no GPU, no API key and no internet, and is built to give **zero wrong answers**: when it is not sure, it refuses instead of guessing.
+
+[![Buy me a coffee](https://img.shields.io/badge/Buy%20me%20a%20coffee-support%20development-FFDD00?logo=buymeacoffee&logoColor=black)](https://buymeacoffee.com/ibnuljaiffarabi) ![License](https://img.shields.io/badge/license-Apache--2.0-blue) ![Python](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-blue) ![Offline](https://img.shields.io/badge/runs-offline%20on%20CPU-green) ![Rust](https://img.shields.io/badge/Rust-Windows%20%7C%20Linux%20%7C%20WebAssembly-orange)
+
+**Run it your way.** optimization-ai999x comes as the AI999X desktop app and as the command-line program `optimization` for Windows and Linux, runs in your browser as WebAssembly, and installs as a Python package. The desktop app, the command line and the browser run the same compiled Rust program on your own device: offline, no Python needed.
+
+## Get it
+
+| Way to run it | For | Get it |
+|---|---|---|
+| **AI999X Optimization desktop app** 1.5.0 | Windows, Linux. This model in its own app: search, ask in words, forms, live figures, explanations, offline | [Windows (x86-64)](https://downloads.ai999x.com/desktop/1.5.0/ai999x-optimization-1.5.0-windows-x86_64.zip) · [Linux (x86-64)](https://downloads.ai999x.com/desktop/1.5.0/ai999x-optimization-1.5.0-linux-x86_64.tar.gz) |
+| **AI999X desktop app** 1.5.0 | Windows, Linux. Every AI999X model in one app: search, ask in words, forms, live figures, explanations, offline | [Windows (x86-64)](https://downloads.ai999x.com/desktop/1.5.0/ai999x-1.5.0-windows-x86_64.zip) · [Linux (x86-64)](https://downloads.ai999x.com/desktop/1.5.0/ai999x-1.5.0-linux-x86_64.tar.gz) |
+| **Command line** (`optimization`) | Windows, Linux. One program per model, offline, no Python | [Windows (x86-64)](https://downloads.ai999x.com/desktop/1.5.0/ai999x-cli-1.5.0-windows-x86_64.zip) · [Linux (x86-64)](https://downloads.ai999x.com/desktop/1.5.0/ai999x-cli-1.5.0-linux-x86_64.tar.gz) |
+| **In your browser** | any device. Nothing to install | [Compute on the model page](https://www.ai999x.com/models/optimization-ai999x/#try) |
+| **Python** | Python 3.10+ | `pip install optimization-ai999x` |
+
+Checksums: [SHA256SUMS](https://downloads.ai999x.com/desktop/1.5.0/SHA256SUMS) · every version: [https://downloads.ai999x.com/desktop/latest/](https://downloads.ai999x.com/desktop/latest/) · install guide: [desktop & command line](https://www.ai999x.com/desktop-cli/)
+
+## Quick start
+
+### Desktop app
+
+Download **AI999X Optimization** for your system (above), unpack it and start it; type a question in words or pick a capability, fill in the form and press Compute. Figures and an explanation of the answer appear beside it. The AI999X desktop app has the same, with Optimization among all AI999X models.
+
+Linux, from a terminal:
+
+```bash
+curl -LO https://downloads.ai999x.com/desktop/1.5.0/ai999x-optimization-1.5.0-linux-x86_64.tar.gz
+curl -LO https://downloads.ai999x.com/desktop/1.5.0/SHA256SUMS
+sha256sum -c --ignore-missing SHA256SUMS
+tar xzf ai999x-optimization-1.5.0-linux-x86_64.tar.gz
+./ai999x-optimization-1.5.0-linux-x86_64/ai999x-optimization
+```
+
+### Command line
+
+Linux:
+
+```bash
+curl -LO https://downloads.ai999x.com/desktop/1.5.0/ai999x-cli-1.5.0-linux-x86_64.tar.gz
+curl -LO https://downloads.ai999x.com/desktop/1.5.0/SHA256SUMS
+sha256sum -c --ignore-missing SHA256SUMS
+mkdir -p ~/.local/share && tar xzf ai999x-cli-1.5.0-linux-x86_64.tar.gz -C ~/.local/share
+echo 'export PATH="$HOME/.local/share/ai999x-cli-1.5.0-linux-x86_64:$PATH"' >> ~/.bashrc && source ~/.bashrc
+optimization --version
+```
+
+Windows (PowerShell):
+
+```powershell
+$F = "ai999x-cli-1.5.0-windows-x86_64.zip"
+Invoke-WebRequest "https://downloads.ai999x.com/desktop/1.5.0/$F" -OutFile $F
+Invoke-WebRequest "https://downloads.ai999x.com/desktop/1.5.0/SHA256SUMS" -OutFile SHA256SUMS
+(Get-FileHash $F -Algorithm SHA256).Hash.ToLower() -eq ((Select-String -SimpleMatch $F SHA256SUMS).Line -split ' ')[0]
+Expand-Archive $F -DestinationPath "$env:LOCALAPPDATA\AI999X" -Force
+$D = "$env:LOCALAPPDATA\AI999X\ai999x-cli-1.5.0-windows-x86_64"; $env:Path += ";$D"
+[Environment]::SetEnvironmentVariable("Path", [Environment]::GetEnvironmentVariable("Path", "User") + ";$D", "User")
+optimization --version
+```
+
+Every command below was run as shown; the text under it is what the program printed.
+
+**Ask in words**: Write the question as you would say it: the program reads the quantities and their units, picks the capability and answers.
+
+```console
+$ optimization ask "Solve the transportation problem with supply [20, 30], demand [10, 25, 15] and cost matrix [[2, 3, 1], [5, 4, 8]]."
+Read as: Transportation problem (minimum shipping cost)
+min_cost = 150
+shipments = [[5.0,0.0,15.0],[5.0,25.0,0.0]]
+plan_unique = yes
+dual = [-3.0,0.0,5.0,4.0,4.0]
+  by: Transportation problem (minimum shipping cost)  (the transportation LP solved exactly (rational simplex), certified by its dual (u_i + v_j <= c_ij))
+  assumes: total supply >= total demand (surplus stays at the sources at no cost); at most 60 routes
+```
+
+**What a capability needs**: The equation or method, every input and output with its SI unit. Read this before solve: it tells you the input names.
+
+```console
+$ optimization info eoq
+Economic order quantity (EOQ)
+  minimise D S / Q + H Q / 2 (at the optimum ordering cost equals holding cost)
+  in   D        demand per period (units, e.g. per year) [1]
+  in   S        fixed cost per order [1]
+  in   H        holding cost per unit per period [1]
+  out  Q        economic order quantity [1]
+  out  total_cost minimum ordering + holding cost per period [1]
+  out  orders_per_period number of orders per period [1]
+  out  cycle_time time between orders (in periods) [1]
+```
+
+**Solve**: Inputs as name=value, each with any unit of the right kind. The answer lists every output, the method used, each input converted to SI, and the conditions the answer assumes.
+
+```console
+$ optimization solve eoq D=1200 S=50 H=3
+Q = 200
+total_cost = 600
+orders_per_period = 6
+cycle_time = 0.1666666667
+  by: Economic order quantity (EOQ)  (minimise D S / Q + H Q / 2 (at the optimum ordering cost equals holding cost))
+  D = 1200
+  S = 50
+  H = 3
+  assumes: D, S, H > 0; constant demand, instant replenishment, no shortages
+```
+
+**Many questions at once**: One JSON request per line in, one JSON answer per line out, in order: for scripts, notebooks and agents (the program starts once). In PowerShell: Get-Content cases.jsonl | optimization batch
+
+`cases.jsonl`:
+
+```json
+{"key": "eoq", "inputs": {"D": 1200, "S": 50, "H": 3}}
+{"key": "ahp_consistency_ratio", "inputs": {"judgments": "[3, 5, 2]"}}
+```
+
+```console
+$ optimization batch < cases.jsonl
+{"outcome":"SOLVED","message":"","value":200.0,"unit":"","solved_for":"Q","si":[["D",1200.0],["S",50.0],["H",3.0]],"values":[["Q",200.0,""],["total_cost",600.0,""],["orders_per_period",6.0,""],["cycle_time",0.16666666666666666,""]],"target":"Q","phrase":"economic order quantity","assumptions":["D, S, H > 0","constant demand, instant replenishment, no shortages"],"name":"Economic order quantity (EOQ)","equation":"minimise D S / Q + H Q / 2 (at the optimum ordering cost equals holding cost)"}
+{"outcome":"SOLVED","message":"","value":0.0031849983307239735,"unit":"","solved_for":"CR","values":[["CR",0.0031849983307239735,""],["CI",0.0018472990318199045,""],["lambda_max",3.00369459806364,""],["weights",[0.6483290138222366,0.2296507940626371,0.12202019211512621],""],["acceptable","yes",""]],"target":"CR","phrase":"consistency ratio","assumptions":["3 to 10 criteria","RI = 0.58, 0.90, 1.12, 1.24, 1.32, 1.41, 1.45, 1.49 for n = 3..10 (Saaty)"],"name":"AHP consistency ratio","equation":"principal eigenpair by power iteration (certified as an eigenpair), then CI and CR"}
+```
+
+### In your browser
+
+Open [Optimization on ai999x.com](https://www.ai999x.com/models/optimization-ai999x/#try), choose a capability and press **Compute**: the model runs on your own device as WebAssembly; nothing is sent anywhere. Change any input (any unit of the right kind) and the answer, its explanation and the figures follow.
+
+In your own page: `optimization_ai999x.wasm` and the loader `ax-wasm.js` (https://www.ai999x.com/compute/rust/ax-wasm.js).
+
+### Python
+
+```bash
+pip install optimization-ai999x
+```
+
+## Worked examples in every form
+
+The same worked example from the command line, from Python and in the browser. Each command-line output is what the program printed.
+
+### Absolute extrema of a polynomial on a closed interval
+
+The absolute minimum and maximum of a polynomial on [lo, hi] (closed-interval method: endpoints and critical points), and where they are attained.
+
+Command line:
+
+```console
+$ optimization solve polynomial_extrema_interval "coefficients=[1, -3, 0, 2]" lo=-1 hi=3
+min_value = -2
+max_value = 2
+argmin_example = -1
+argmax_example = 0
+  by: Absolute extrema of a polynomial on a closed interval  (real roots of f' in [lo, hi] (monotone pieces between the roots of f'' bisected to the last float), compared with the endpoints)
+  lo = -1
+  hi = 3
+  assumes: lo < hi; degree 1 to 5
+```
+
+Python:
+
+```python
+import optimization_ai999x as m
+
+a = m.solve("polynomial_extrema_interval", coefficients=[1, -3, 0, 2], lo="-1", hi="3")
+print(a.values or (a.value, a.unit))
+```
+
+Browser: [open this capability on the model page](https://www.ai999x.com/models/optimization-ai999x/#cap-polynomial_extrema_interval) and press **Compute in your browser**.
+
+_What this means:_ This calculation determines the global extrema of a polynomial on the closed interval from -1 to 3. It evaluates the function at the endpoints and all real critical points where the derivative is zero within the interval. The smallest resulting value is reported as the absolute minimum, -2, attained at -1, while the largest is the absolute maximum, 2, found at 0.
+
+### Closed cylinder of least surface area for a given volume
+
+The radius, height and surface area of the closed cylindrical can that holds a volume V with the least material.
+
+Command line:
+
+```console
+$ optimization solve can_min_surface V=500
+radius = 4.301270069
+height = 8.602540138
+min_area = 348.7342055
+  by: Closed cylinder of least surface area for a given volume  (A(r) = 2 pi r^2 + 2V/r; A'(r) = 0)
+  V = 500
+  assumes: V > 0; closed top and bottom
+```
+
+Python:
+
+```python
+import optimization_ai999x as m
+
+a = m.solve("can_min_surface", V="500")
+print(a.values or (a.value, a.unit))
+```
+
+Browser: [open this capability on the model page](https://www.ai999x.com/models/optimization-ai999x/#cap-can_min_surface) and press **Compute in your browser**.
+
+_What this means:_ This calculation determines the dimensions for a closed cylindrical container that holds a specific volume while using the least amount of material. Given an input volume of 500, the method finds the optimal radius to be 4.30127 and the corresponding height to be 8.60254. The resulting minimum surface area required is 348.734. This ensures efficient packaging design by balancing the top, bottom, and side surfaces.
+
+### Critical point of a two-variable quadratic and its classification
+
+For f(x, y) = a x^2 + b xy + c y^2 + d x + e y + f0: the critical point, its value and whether it is a local minimum, a local maximum or a saddle point (second-derivative test).
+
+Command line:
+
+```console
+$ optimization solve critical_point_two_variables a=3 b=2 c=1 d=-4 e=6 f0=1
+f_value = -20.5
+x = 2.5
+y = -5.5
+type = local minimum
+  by: Critical point of a two-variable quadratic and its classification  (grad f = 0 solved exactly; D = f_xx f_yy - f_xy^2 = 4ac - b^2 classifies it)
+  a = 3
+  b = 2
+  c = 1
+  d = -4
+  e = 6
+  f0 = 1
+  assumes: 4ac - b^2 != 0 (an isolated critical point)
+```
+
+Python:
+
+```python
+import optimization_ai999x as m
+
+a = m.solve("critical_point_two_variables", a="3", b="2", c="1", d="-4", e="6", f0="1")
+print(a.values or (a.value, a.unit))
+```
+
+Browser: [open this capability on the model page](https://www.ai999x.com/models/optimization-ai999x/#cap-critical_point_two_variables) and press **Compute in your browser**.
+
+_What this means:_ This calculation identifies the stationary point for the quadratic function defined by coefficients 3, 2, 1, -4, 6, and 1. Solving the gradient equal to zero shows that the critical point occurs at coordinates x equals 2.5 and y equals -5.5. The value of the function at this specific location is -20.5. Based on the second derivative test, which examines the curvature using the determinant of the Hessian matrix, the nature of this point is classified as a local minimum. This classification indicates whether the surface curves upward like a bowl, downward like a dome, or forms a saddle shape at this coordinate.
+
+### Largest rectangle for a given length of fencing
+
+The dimensions and maximum area of a rectangle enclosed by a fence of length L, on four sides or on three sides with a wall or river as the fourth.
+
+Command line:
+
+```console
+$ optimization solve fence_max_area wall=False L=200
+width = 50
+length = 50
+max_area = 2500
+  by: Largest rectangle for a given length of fencing  (area as a function of one side, derivative set to zero)
+  L = 200
+  assumes: L > 0
+```
+
+Python:
+
+```python
+import optimization_ai999x as m
+
+a = m.solve("fence_max_area", wall="False", L="200")
+print(a.values or (a.value, a.unit))
+```
+
+Browser: [open this capability on the model page](https://www.ai999x.com/models/optimization-ai999x/#cap-fence_max_area) and press **Compute in your browser**.
+
+_What this means:_ This calculation finds the largest rectangular area possible for a given fencing length. Using the total fence amount 200, it determines the optimal side dimensions. The resulting maximum area is 2500, achieved when the perpendicular side is 50 and the parallel side is 50. This ensures the most efficient use of boundary materials.
+
+## Documentation
+
+- **Rust user guide**: the command line, every capability with a command and what it printed: [PDF](docs/optimization_ai999x_rust_guide.pdf) · [Markdown](docs/optimization_ai999x_rust_guide.md)
+- **Python guide**: every capability with a Python example: [PDF](docs/optimization_ai999x_capabilities.pdf) · [Markdown](docs/optimization_ai999x_capabilities.md)
+- **Desktop app & command line**: downloads, install, ask and search, figures, offline use, checksums: https://www.ai999x.com/desktop-cli/
+- **Model page**: compute in your browser, every capability explained: https://www.ai999x.com/models/optimization-ai999x/
+
+## Highlights
+
+- **Verified, not generated.** Every answer is computed by a certified optimization capability and checked (substituted back, dimension-checked or compared with an independent computation) before it is returned.
+- **Zero wrong answers by design.** Seven explicit outcomes (SOLVED, NEEDS_INPUT, AMBIGUOUS, INVALID_INPUT, OUT_OF_SCOPE, UNRECOGNIZED_FORMAT, INTERNAL_ERROR), never a silent guess. Every one of its 247 documented answers is reproduced exactly on every tested platform.
+- **Plain-English questions and a guaranteed typed interface.** `ask()` reads documented question forms; `solve(capability_id, **inputs)` always solves a supported task with valid inputs.
+- **Explains itself.** Steps, formulas in LaTeX, units, assumptions and the model used, ready for notebooks, tutoring apps and homework checkers.
+- **Native and in the browser.** Every capability also computes natively in Rust: the desktop app and the `optimization` command line for Windows and Linux, and WebAssembly on the model page, no Python, no network.
+- **Small and portable.** Pure Python (sympy, mpmath); identical answers on Windows and Linux (Python 3.10, 3.11, 3.12, 3.13, 3.14).
+- **Coverage:** linear and integer programming, convex and nonlinear optimisation, assignment, transportation and shortest-route problems, scheduling, inventory, queueing, game theory and multi-criteria decisions.
+
+## Model overview
+
+| Property | Value |
+|---|---|
+| Package | `optimization-ai999x` 1.6.0 (import `optimization_ai999x`) |
+| Type | Deterministic neuro-symbolic optimization engine (rule-based reading + certified symbolic capabilities) |
+| Capabilities | 73 certified procedures |
+| Knowledge pack | version 1.0.1 |
+| Golden answers | 247 documented answers, identical on every tested platform |
+| Platforms tested | Windows (Python 3.13), Linux x86-64 (Python 3.10, 3.11, 3.12, 3.13, 3.14) |
+| Runtime | CPU only, offline; no GPU, no network, no API key |
+| License | Apache-2.0 |
+| Creator / engineer | Ibnul Jaif Farabi |
+| Organization | AI999X |
+
+## Python quick start
+
+```bash
+pip install optimization-ai999x
+# or straight from this repository:
+pip install https://huggingface.co/AI999X/optimization-ai999x/resolve/main/dist/optimization_ai999x-1.6.0-py3-none-any.whl
+```
+
+```python
+import optimization_ai999x as optimization
+
+optimization.ask("Solve the transportation problem with supply [20, 30], demand [10, 25, 15] and cost matrix [[2, 3, 1], [5, 4, 8]].").show()
+# -> SOLVED — min_cost = 150, shipments = [[5.0, 0.0, 15.0], [5.0, 25.0, 0.0]], plan_unique = yes, dual = [-3.0, 0.0, 5.0, 4.0, 4.0]  (transportation_problem)
+optimization.ask("Find the shortest path from A to D in the undirected graph with edges A-B 4, A-C 2, B-C 1, B-D 5, C-D 8.").show()
+# -> SOLVED — distance = 8, path = ['A', 'C', 'B', 'D'], path_unique = yes  (shortest_path)
+optimization.solve("eoq", D=1200, S=50, H=3).show()
+# -> SOLVED — Q = 200, total_cost = 600, orders_per_period = 6, cycle_time = 0.166667  (eoq)
+optimization.ask("Find the AHP consistency ratio for the pairwise judgments [3, 5, 2].").show()
+# -> SOLVED — CR = 0.003185, CI = 0.0018473, lambda_max = 3.00369, weights = [0.6483290138222366, 0.2296507940626371, 0.12202019211512621]  (ahp_consistency_ratio)
+optimization.ask("Find the pure-strategy Nash equilibria of the bimatrix game with row payoffs [[3, 0], [5, 1]] and column payoffs [[3, 5], [0, 1]].").show()
+# -> SOLVED — count = 1, equilibria = [[2.0, 2.0]]  (pure_nash_equilibria)
+optimization.ask("Who created you?").message
+# -> optimization-ai999x was created and engineered by Ibnul Jaif Farabi at AI999X.
+```
+
+The Python package also installs a Python command, `optimization-ai999x "<question>"`; for the native program use `optimization` (above). The outputs above were produced by running this exact code on optimization-ai999x 1.6.0.
+
+## How every answer is verified
+
+1. **Reading**: the question is turned into typed quantities (value, unit, kind, role) and one asked quantity; every stated number must be used or the question is refused.
+2. **Planning**: only certified capabilities may answer; a capability applies only under the conditions the wording states (for example a pendulum, a liquid at rest, boiling).
+3. **Computing**: exact symbolic or high-precision numeric evaluation.
+4. **Checking**: dimensions, substitution back into the defining equation, and agreement between independent readings; any disagreement becomes a refusal, never a number.
+
+Capabilities are certified before they ship: each must reproduce hand-worked reference cases, reject a deliberately wrong variant (a control), and leave every benchmark answer unchanged.
+
+## Python worked examples, with their steps
+
+Each question was put to `optimization-ai999x`; the answer is the one it returned, with the steps it took.
+
+**Transportation problem (minimum shipping cost)** · _Network optimisation_
+
+> Solve the transportation problem with supply [20, 30], demand [10, 25, 15] and cost matrix [[2, 3, 1], [5, 4, 8]].
+
+→ **min_cost = 150, shipments = [[5, 0, 15], [5, 25, 0]], plan_unique = yes, dual = [-3, 0, 5, 4, 4]**
+
+<details><summary>Steps</summary>
+
+- Transportation problem (minimum shipping cost): supply = [20, 30], demand = [10, 25, 15], cost = [2 3 1; 5 4 8] → min_cost = 150, shipments = [[5, 0, 15], [5, 25, 0]], plan_unique = yes, dual = [-3, 0, 5, 4, 4]
+
+</details>
+
+**Shortest path (Dijkstra's algorithm)** · _Network optimisation_
+
+> Find the shortest path from A to D in the undirected graph with edges A-B 4, A-C 2, B-C 1, B-D 5, C-D 8.
+
+→ **distance = 8, path = [A, C, B, D], path_unique = yes**
+
+<details><summary>Steps</summary>
+
+- Shortest path (Dijkstra's algorithm): edges = A-B (4), A-C (2), B-C (1), B-D (5), C-D (8), source = A, target = D, directed = False → distance = 8, path = [A, C, B, D], path_unique = yes
+
+</details>
+
+**Economic order quantity (EOQ)** · _Inventory management_
+
+`m.solve("eoq", D=1200, S=50, H=3)`
+
+→ **Q = 200, total_cost = 600, orders_per_period = 6, cycle_time = 0.1666666667**
+
+<details><summary>Steps</summary>
+
+- Economic order quantity (EOQ): D = 1200, S = 50, H = 3 → Q = 200, total_cost = 600, orders_per_period = 6, cycle_time = 0.1666666667
+
+</details>
+
+**AHP consistency ratio** · _Multi-criteria decision analysis_
+
+> Find the AHP consistency ratio for the pairwise judgments [3, 5, 2].
+
+→ **CR = 0.003184998331, CI = 0.001847299032, lambda_max = 3.003694598, weights = [0.6483290138, 0.2296507941, 0.1220201921], acceptable = yes**
+
+<details><summary>Steps</summary>
+
+- AHP consistency ratio: judgments = [3, 5, 2] → CR = 0.003184998331, CI = 0.001847299032, lambda_max = 3.003694598, weights = [0.6483290138, 0.2296507941, 0.1220201921], acceptable = yes
+
+</details>
+
+**Pure-strategy Nash equilibria of a bimatrix game** · _Game theory_
+
+> Find the pure-strategy Nash equilibria of the bimatrix game with row payoffs [[3, 0], [5, 1]] and column payoffs [[3, 5], [0, 1]].
+
+→ **count = 1, equilibria = [[2, 2]]**
+
+<details><summary>Steps</summary>
+
+- Pure-strategy Nash equilibria of a bimatrix game: A = [3 0; 5 1], B = [3 5; 0 1] → count = 1, equilibria = [[2, 2]]
+
+</details>
+
+**Closed cylinder of least surface area for a given volume** · _Calculus optimisation_
+
+> A closed cylindrical can must hold 500 cm^3. Find the dimensions that minimize the surface area.
+
+→ **radius = 4.301270069, height = 8.602540138, min_area = 348.7342055**
+
+<details><summary>Steps</summary>
+
+- Closed cylinder of least surface area for a given volume: V = 500 → radius = 4.301270069, height = 8.602540138, min_area = 348.7342055
+
+</details>
+
+## Figures
+
+Every point was computed by `optimization-ai999x`.
+
+**A linear programme: feasible region and optimal corner**
+
+![A linear programme: feasible region and optimal corner, computed by optimization-ai999x](figures/lp-two-variable-graphical-region.svg)
+
+_Maximise 3x + 5y subject to x ≤ 4; 2y ≤ 12; 3x + 2y ≤ 18, x, y ≥ 0: the feasible region with the corner points the package returns ((0, 0), (0, 6), (2, 6), (4, 0), (4, 3)) and the objective line through the optimum; marked: x = 2, y = 6, objective 36._
+
+**Steepest descent zig-zagging to the minimum**
+
+![Steepest descent zig-zagging to the minimum, computed by optimization-ai999x](figures/steepest-descent-step-iteration.svg)
+
+_Steepest descent with exact line search on f(x) = ½ xᵀQx, Q = [[2, 0], [0, 8]], from x₀ = (4, 1): six steps computed by the package, each perpendicular to the level set through its start (f = 20, 7.2, 2.592, 0.93312, 0.335923, 0.120932, 0.0435356); marked: x₆ = (0.186624, 0.046656)._
+
+**Shortest path and minimum spanning tree**
+
+![Shortest path and minimum spanning tree, computed by optimization-ai999x](figures/shortest-path-graph.svg)
+
+_A weighted network (A-B 4, A-C 2, B-C 1, B-D 5, C-D 8, A-E 7, E-D 3, C-E 6): the shortest path from A to D the package finds, A → C → B → D of length 8, and its minimum spanning tree (B-C, A-C, E-D, B-D, total weight 11)._
+
+**An optimal transportation plan**
+
+![An optimal transportation plan, computed by optimization-ai999x](figures/transportation-problem-heatmap.svg)
+
+_The optimal transportation plan the package computes for supplies [20, 30], demands [10, 25, 15] and unit costs [[2, 3, 1], [5, 4, 8]] (rows: sources, columns: destinations; left the unit costs, right the quantities shipped): minimum total cost 150._
+
+**A two-machine schedule in Johnson's order**
+
+![A two-machine schedule in Johnson's order, computed by optimization-ai999x](figures/johnson-two-machine-gantt.svg)
+
+_A two-machine flow shop: processing times [5, 2, 6, 7] on machine 1 and [3, 4, 8, 2] on machine 2. The package's Johnson order is job 2 → job 3 → job 1 → job 4, with makespan 22; each job starts on machine 2 as soon as it leaves machine 1 and machine 2 is free._
+
+## Capabilities
+
+73 certified procedures. A few of them:
+
+- **Procedures:** 0/1 knapsack problem; 2 x 2 zero-sum game (saddle point or mixed-strategy formula); AHP consistency ratio; AHP priority vector (principal eigenvector); AHP weights by the geometric mean method; Absolute extrema of a polynomial on a closed interval; All-pairs shortest distances (Floyd-Warshall); Assignment problem (Hungarian method), maximum total value; Assignment problem (Hungarian method), minimum total cost; Bin packing (minimum number of bins); Break-even quantity; Chromatic number (minimum graph colouring); Closed cylinder of least surface area for a given volume; Critical path method (project duration and slack); Critical point of a two-variable quadratic and its classification; Discounted Markov decision process (optimal values and policy); Dynamic lot sizing (Wagner-Whitin); EOQ with planned backorders; Earliest due date rule (minimum maximum lateness); Economic order quantity (EOQ); Economic production quantity (EPQ); Equality-constrained quadratic program (Lagrange multipliers / KKT); Erlang B blocking probability (M/M/c/c loss system); Integer linear program (branch and bound) …
+
+`optimization_ai999x.templates()` lists every question form `ask()` reads; the capability guide (PDF, every example executed) is included in this repository.
+
+### All 73 formulas
+
+<details><summary>Show every formula, by topic</summary>
+
+**Calculus optimisation / geometry**
+
+*Closed cylinder of least surface area for a given volume*
+
+$$
+r^* = \left(\frac{V}{2\pi}\right)^{1/3}, \quad h^* = 2r^*
+$$
+
+*Largest rectangle for a given length of fencing*
+
+$$
+A_{\max} = \frac{L^2}{16} \text{ (4 sides)}, \quad \frac{L^2}{8} \text{ (3 sides)}
+$$
+
+*Open box of maximum volume from a rectangular sheet*
+
+$$
+x^* = \frac{(L+W) - \sqrt{L^2 - LW + W^2}}{6}
+$$
+
+**Calculus optimisation / one variable**
+
+*Absolute extrema of a polynomial on a closed interval*
+
+$$
+\min_{[a,b]} f = \min\{f(a), f(b), f(c) : f'(c) = 0,\ a < c < b\}
+$$
+
+**Calculus optimisation / several variables**
+
+*Critical point of a two-variable quadratic and its classification*
+
+$$
+D = f_{xx} f_{yy} - f_{xy}^2 = 4ac - b^2
+$$
+
+**Cost-volume-profit analysis**
+
+*Break-even quantity*
+
+$$
+Q_{BE} = \frac{F}{p - v}
+$$
+
+**Dynamic programming / Markov decision processes**
+
+*Discounted Markov decision process (optimal values and policy)*
+
+$$
+V^*(s) = \max_a \Big( R(s,a) + \gamma \sum_{s'} P(s' \mid s,a)\, V^*(s') \Big)
+$$
+
+**Dynamic programming / inventory**
+
+*Dynamic lot sizing (Wagner-Whitin)*
+
+$$
+C_t = \min_{1 \le s \le t} \Big( C_{s-1} + K + h \sum_{u=s}^{t} (u - s)\, d_u \Big)
+$$
+
+**Economic optimisation / monopoly pricing**
+
+*Profit-maximising output with linear demand*
+
+$$
+q^* = \frac{a - c}{2b}, \quad p^* = \frac{a + c}{2}
+$$
+
+**Economic optimisation / pricing**
+
+*Revenue-maximising price with linear demand*
+
+$$
+p^* = \frac{\alpha}{2\beta}, \quad R^* = \frac{\alpha^2}{4\beta}
+$$
+
+**Game theory / non-zero-sum games**
+
+*Mixed-strategy Nash equilibrium of a 2 x 2 game*
+
+$$
+q = \frac{a_{22} - a_{12}}{a_{11} - a_{12} - a_{21} + a_{22}},\quad p = \frac{b_{22} - b_{21}}{b_{11} - b_{12} - b_{21} + b_{22}}
+$$
+
+*Pure-strategy Nash equilibria of a bimatrix game*
+
+$$
+a_{rs} = \max_k a_{ks},\quad b_{rs} = \max_k b_{rk}
+$$
+
+**Game theory / zero-sum games**
+
+*2 x 2 zero-sum game (saddle point or mixed-strategy formula)*
+
+$$
+v = \frac{ad - bc}{a + d - b - c},\quad p = \frac{d - c}{a + d - b - c},\quad q = \frac{d - b}{a + d - b - c}
+$$
+
+*Two-person zero-sum game (value and optimal mixed strategies)*
+
+$$
+v = \max_{x \in \Delta_m} \min_{j} \sum_i x_i a_{ij} = \min_{y \in \Delta_n} \max_i \sum_j a_{ij} y_j
+$$
+
+**Integer programming**
+
+*Integer linear program (branch and bound)*
+
+$$
+\max / \min \; c^\top x \quad \text{s.t. } A x \;(\le,\ge,=)\; b,\; x \in \mathbb{Z}_{\ge 0}^n
+$$
+
+**Integer programming / covering**
+
+*Minimum vertex cover (and maximum independent set)*
+
+$$
+\tau(G) = \min\{\vert C\vert  : C \cap \{u, v\} \neq \emptyset\ \forall uv \in E\},\quad \alpha(G) = \vert V\vert  - \tau(G)
+$$
+
+*Minimum-cost set cover*
+
+$$
+\min \sum_i c_i x_i\ \text{s.t.}\ \sum_{i \ni e} x_i \ge 1\ \forall e,\ x \in \{0,1\}
+$$
+
+**Integer programming / graph colouring**
+
+*Chromatic number (minimum graph colouring)*
+
+$$
+\chi(G) = \min\{k : \exists\, c: V \to \{1..k\},\ c(u) \neq c(v)\ \forall uv \in E\}
+$$
+
+**Integer programming / knapsack**
+
+*0/1 knapsack problem*
+
+$$
+\max \sum_i v_i x_i \ \text{s.t.}\ \sum_i w_i x_i \le W,\ x_i \in \{0,1\}
+$$
+
+*Unbounded knapsack problem*
+
+$$
+V(c) = \max\big(V(c-1),\ \max_{i: w_i \le c} V(c - w_i) + v_i\big)
+$$
+
+**Integer programming / location**
+
+*Uncapacitated facility location*
+
+$$
+\min_{S \neq \emptyset} \sum_{i \in S} f_i + \sum_j \min_{i \in S} c_{ij}
+$$
+
+**Integer programming / packing**
+
+*Bin packing (minimum number of bins)*
+
+$$
+\min \#\text{bins} \ \ge\ \left\lceil \sum_j s_j / C \right\rceil
+$$
+
+**Inventory management**
+
+*EOQ with planned backorders*
+
+$$
+Q^* = \sqrt{\frac{2DS}{H}\cdot\frac{H+B}{B}}, \quad s^* = Q^* \frac{H}{H+B}
+$$
+
+*Economic order quantity (EOQ)*
+
+$$
+Q^* = \sqrt{\frac{2 D S}{H}}, \quad TC^* = \sqrt{2 D S H}
+$$
+
+*Economic production quantity (EPQ)*
+
+$$
+Q^* = \sqrt{\frac{2DS}{H(1 - D/P)}}
+$$
+
+*Order quantity with quantity discounts (all-units)*
+
+$$
+TC(Q) = D p_k + \frac{D S}{Q} + \frac{i p_k Q}{2}
+$$
+
+*Periodic-review order-up-to level*
+
+$$
+S = \bar d (R + L) + z_{SL}\,\sigma_d\sqrt{R + L}
+$$
+
+*Reorder point with safety stock*
+
+$$
+ROP = \bar d L + z_{SL}\,\sigma_d \sqrt{L}
+$$
+
+**Inventory management / single-period**
+
+*Newsvendor order quantity (discrete demand)*
+
+$$
+Q^* = \min\{ d : F(d) \ge \tfrac{p - c}{p - s} \}
+$$
+
+*Newsvendor order quantity (normal demand)*
+
+$$
+F(Q^*) = \frac{p - c}{p - s}, \quad Q^* = \mu + z\,\sigma
+$$
+
+*Newsvendor order quantity (uniform demand)*
+
+$$
+Q^* = a + \frac{p - c}{p - s}(b - a)
+$$
+
+**Linear programming**
+
+*Linear program (simplex method)*
+
+$$
+\max / \min \; c^\top x \quad \text{s.t. } A x \;(\le, \ge, =)\; b,\; x \ge 0
+$$
+
+*Two-variable linear program (graphical corner-point method)*
+
+$$
+z^* = \max_{v \in \text{corners}} c^\top v
+$$
+
+**Linear programming / sensitivity analysis**
+
+*LP duality and sensitivity ranges*
+
+$$
+\max c^\top x\ \text{s.t.}\ A x \le b,\ x \ge 0 \;\Longleftrightarrow\; \min b^\top y\ \text{s.t.}\ A^\top y \ge c,\ y \ge 0;\quad x_B + \delta\,B^{-1}e_i \ge 0,\quad d_k - \Delta\,(B^{-1}A_k)_r \ge 0
+$$
+
+*Shadow prices of a linear program*
+
+$$
+y^\top = c_B^\top B^{-1}, \qquad \frac{\partial z^*}{\partial b_i} = y_i
+$$
+
+**Multi-criteria decision analysis**
+
+*TOPSIS ranking (closeness to the ideal solution)*
+
+$$
+C_i = \frac{D_i^-}{D_i^+ + D_i^-},\quad D_i^\pm = \Big\\vert  w \odot r_i - v^\pm \Big\\vert _2
+$$
+
+*Weighted product model*
+
+$$
+P_i = \prod_j n_{ij}^{\,w_j}
+$$
+
+*Weighted sum model (simple additive weighting)*
+
+$$
+S_i = \sum_j w_j n_{ij},\quad n_{ij} = \frac{x_{ij}}{\max_i x_{ij}}\ \text{or}\ \frac{\min_i x_{ij}}{x_{ij}}
+$$
+
+**Multi-criteria decision analysis / AHP**
+
+*AHP consistency ratio*
+
+$$
+CI = \frac{\lambda_{\max} - n}{n - 1},\quad CR = \frac{CI}{RI_n}
+$$
+
+*AHP priority vector (principal eigenvector)*
+
+$$
+P w = \lambda_{\max} w,\quad \sum_i w_i = 1
+$$
+
+*AHP weights by the geometric mean method*
+
+$$
+w_i = \frac{(\prod_j a_{ij})^{1/n}}{\sum_k (\prod_j a_{kj})^{1/n}}
+$$
+
+**Network optimisation / assignment**
+
+*Assignment problem (Hungarian method), maximum total value*
+
+$$
+\min_{\sigma} \sum_i c_{i\sigma(i)} = \max \Big\{ \sum_i u_i + \sum_j v_j : u_i + v_j \le c_{ij} \Big\}
+$$
+
+*Assignment problem (Hungarian method), minimum total cost*
+
+$$
+\min_{\sigma} \sum_i c_{i\sigma(i)} = \max \Big\{ \sum_i u_i + \sum_j v_j : u_i + v_j \le c_{ij} \Big\}
+$$
+
+**Network optimisation / flows**
+
+*Maximum flow and minimum cut (Edmonds-Karp)*
+
+$$
+\max \vert f\vert  = \min_{(S, \bar S)} c(S, \bar S)
+$$
+
+*Minimum-cost flow (transshipment)*
+
+$$
+\min \sum c_{ij} x_{ij}\ \text{s.t.}\ \sum_j x_{vj} - \sum_i x_{iv} = b_v,\ 0 \le x_{ij} \le u_{ij}
+$$
+
+**Network optimisation / matching**
+
+*Maximum bipartite matching*
+
+$$
+\nu(G) = \tau(G) \text{ for bipartite } G
+$$
+
+*Maximum-weight matching (general graph)*
+
+$$
+\max_{M \text{ matching}} \sum_{e \in M} w_e
+$$
+
+**Network optimisation / routing**
+
+*Travelling salesman tour (exact, Held-Karp)*
+
+$$
+g(S, k) = \min_{m \in S \setminus \{k\}} \big(g(S \setminus \{k\}, m) + d_{mk}\big)
+$$
+
+**Network optimisation / shortest routes**
+
+*All-pairs shortest distances (Floyd-Warshall)*
+
+$$
+d_{ij} \leftarrow \min(d_{ij},\, d_{ik} + d_{kj})
+$$
+
+*Shortest path (Dijkstra's algorithm)*
+
+$$
+d(v) = \min_{(u,v)} \big(d(u) + w_{uv}\big)
+$$
+
+*Shortest path with negative weights (Bellman-Ford)*
+
+$$
+d(v) \le d(u) + w_{uv} \ \forall (u,v)
+$$
+
+**Network optimisation / spanning trees**
+
+*Minimum spanning tree (Kruskal's algorithm)*
+
+$$
+\min_{T \text{ spanning tree}} \sum_{e \in T} w_e
+$$
+
+**Network optimisation / transportation**
+
+*Transportation problem (minimum shipping cost)*
+
+$$
+\min \sum_{ij} c_{ij} x_{ij}\ \text{s.t.}\ \sum_j x_{ij} \le s_i,\ \sum_i x_{ij} = d_j,\ x \ge 0
+$$
+
+**Nonlinear optimisation / descent methods**
+
+*Steepest descent step with exact line search (quadratic)*
+
+$$
+\alpha = \frac{g^\top g}{g^\top Q g},\quad x_1 = x_0 - \alpha g
+$$
+
+**Nonlinear optimisation / quadratic**
+
+*Equality-constrained quadratic program (Lagrange multipliers / KKT)*
+
+$$
+\begin{bmatrix} Q & A^\top \\ A & 0 \end{bmatrix}\begin{bmatrix} x \\ \lambda \end{bmatrix} = \begin{bmatrix} -c \\ b \end{bmatrix}
+$$
+
+*Unconstrained quadratic minimisation*
+
+$$
+x^* = -Q^{-1} c,\quad f^* = \tfrac12 c^\top x^*
+$$
+
+**Project scheduling**
+
+*Critical path method (project duration and slack)*
+
+$$
+ES_k = \max_{j \to k}(ES_j + d_j),\quad LS_k = \min_{k \to s} LS_s - d_k,\quad \text{slack}_k = LS_k - ES_k
+$$
+
+*PERT project duration and completion probability*
+
+$$
+t_e = \frac{a + 4m + b}{6},\; \sigma^2 = \left(\frac{b - a}{6}\right)^2,\; P(T \le d) = \Phi\!\left(\frac{d - \mu}{\sigma}\right)
+$$
+
+**Queueing theory**
+
+*M/G/1 queue (Pollaczek-Khinchine formula)*
+
+$$
+L_q = \frac{\lambda^2 \sigma_S^2 + \rho^2}{2(1-\rho)}
+$$
+
+*M/M/1 queue*
+
+$$
+L = \frac{\rho}{1-\rho},\; W = \frac{1}{\mu - \lambda},\; W_q = \frac{\rho}{\mu-\lambda}
+$$
+
+*M/M/c queue (Erlang C)*
+
+$$
+C(c, a) = \frac{B(c,a)}{1 - \rho(1 - B(c,a))}, \quad L_q = C\,\frac{\rho}{1-\rho}
+$$
+
+*M/M/c/K queue (finite capacity)*
+
+$$
+\pi_n \propto \frac{a^n}{n!}\ (n \le c),\quad \frac{a^c}{c!}\left(\frac{a}{c}\right)^{n-c}\ (c < n \le K)
+$$
+
+*Machine-repair (finite-source) queue*
+
+$$
+\pi_n \propto \frac{N!}{(N-n)!}\,\frac{(\lambda/\mu)^n}{n!\ \text{or}\ c!\,c^{n-c}}
+$$
+
+**Queueing theory / staffing**
+
+*Minimum number of servers for a service target (Erlang C)*
+
+$$
+c^* = \min\{c > \lambda/\mu : C(c, \lambda/\mu) \le \alpha\}
+$$
+
+**Queueing theory / teletraffic**
+
+*Erlang B blocking probability (M/M/c/c loss system)*
+
+$$
+B(c, A) = \frac{A^c / c!}{\sum_{k=0}^{c} A^k / k!}
+$$
+
+**Revenue management**
+
+*Littlewood's rule (two-fare protection level)*
+
+$$
+P(D_1 > y^*) = \frac{p_2}{p_1}, \quad y^* = \mu + z\,\sigma
+$$
+
+**Scheduling / flow shop**
+
+*Johnson's rule (two-machine flow shop)*
+
+$$
+\min C_{\max} \text{ for } F2 \\vert  C_{\max}
+$$
+
+**Scheduling / parallel machines**
+
+*Minimum makespan on identical parallel machines*
+
+$$
+\min_{\text{assignment}} \max_k \sum_{j \to k} p_j
+$$
+
+**Scheduling / single machine**
+
+*Earliest due date rule (minimum maximum lateness)*
+
+$$
+\min L_{\max} = \min \max_j (C_j - d_j):\; d_{[1]} \le d_{[2]} \le \dots
+$$
+
+*Moore-Hodgson algorithm (minimum number of tardy jobs)*
+
+$$
+\min \sum_j U_j
+$$
+
+*Shortest processing time rule (minimum mean flow time)*
+
+$$
+\min \tfrac{1}{n}\sum_j C_j:\; p_{[1]} \le p_{[2]} \le \dots
+$$
+
+*Weighted shortest processing time (Smith's rule)*
+
+$$
+\min \sum_j w_j C_j:\; \frac{p_{[1]}}{w_{[1]}} \le \frac{p_{[2]}}{w_{[2]}} \le \dots
+$$
+
+**Unconstrained optimisation / one variable**
+
+*Optimum of a quadratic function*
+
+$$
+x^* = -\frac{b}{2a}, \quad f^* = c - \frac{b^2}{4a}
+$$
+
+</details>
+
+## Out of scope
+
+- Open-ended explanation, essay writing or tutoring dialogue: it is a solver, not a chatbot.
+- Questions outside its certified optimization capabilities, and any question whose stated numbers it cannot all use: it refuses with the reason instead.
+- High-stakes engineering, medical or legal decisions without independent review.
+
+## Limitations
+
+- It answers what its certified capabilities cover (linear and integer programming, convex and nonlinear optimisation, assignment, transportation and shortest-route problems, scheduling, inventory, queueing, game theory and multi-criteria decisions); anything else is refused with a reason.
+- `ask()` reads documented question forms and common phrasings; unusual wording may be refused; use `solve()` for guaranteed results.
+- Results are as correct as the certified relations and their stated conditions; a certified relation is a checked model, not a claim about every physical situation.
+
+## Citation
+
+```bibtex
+@software{optimization_ai999x_1_6_0,
+  title  = {optimization-ai999x: an offline, verified optimization solver},
+  author = {Farabi, Ibnul Jaif}, organization = {AI999X},
+  year   = {2026}, version = {1.6.0},
+  url    = {https://huggingface.co/AI999X/optimization-ai999x}
+}
+```
+
+## Contact
+
+Questions, bug reports and requests: open a discussion on https://huggingface.co/AI999X/optimization-ai999x/discussions or visit https://ai999x.com.
+
+## Support the project
+
+optimization-ai999x is free and open source. If it helps you, you can support further development on [Buy Me a Coffee](https://buymeacoffee.com/ibnuljaiffarabi).
+
+Created and engineered by **Ibnul Jaif Farabi** · **[AI999X](https://huggingface.co/AI999X)** · [ai999x.com](https://ai999x.com)

config.json

@@ -0,0 +1,11 @@
+{
+ "library_name": "optimization-ai999x",
+ "import_name": "optimization_ai999x",
+ "version": "1.6.0",
+ "knowledge_pack": "1.0.1",
+ "capabilities": 73,
+ "license": "apache-2.0",
+ "install": "pip install optimization-ai999x",
+ "author": "Ibnul Jaif Farabi",
+ "organization": "AI999X"
+}

dist/optimization_ai999x-1.6.0-py3-none-any.whl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6dd20697f73ee4321ba6ca71f1e0e8298d1979c62b5ff666bd446a072c8275d4
+size 3968813

docs/optimization_ai999x_capabilities.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e45943f95f10bf921c3f363bba42b562b87afc5365cac0150e3dde93cec4b5d3
+size 2827479

docs/optimization_ai999x_rust_guide.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:13eadc3e8b89b78b71d29a526cf03d19b4278ba77b1054b9d6ac6d5fd5d860a8
+size 1942944

evaluation/KNOWLEDGE_CARD.md

@@ -0,0 +1,36 @@
+# Dataset card: optimization
+
+Generated 2026-11-13 by `tools/cards.py` from the domain's measured state (pack 1.0.1). Nothing here is hand-edited.
+
+**Creator / engineer:** Ibnul Jaif Farabi · **Company:** AI999X.
+
+## What the knowledge base holds
+
+6207 records, of which 6135 are **machine-checked** (recomputed or checked step by step by the factory). Every other record is **structurally valid only**: well formed and consistent, but its meaning is not verified, and it is labelled so in the store.
+
+| kind | tier | records |
+|---|---|---|
+| exercise | machine_checked | 6063 |
+| explanation | structurally_valid | 72 |
+| procedure | machine_checked | 72 |
+
+## How it was produced
+
+Candidate content was written by a teacher model and judged by the factory's own checks (no teacher output is trusted by itself). Campaigns:
+
+| campaign | teacher | status | requests sent | accepted | machine-checked | spend (USD) |
+|---|---|---|---|---|---|---|
+
+## Reference sources
+
+- none
+
+## Decision-model datasets
+
+- none
+
+## Limits
+
+- Machine-checked means checked by computation against the factory's certified relations, procedures and identities; it does not mean verified by experiment or by an expert.
+- Structurally valid records (concepts, theories, explanations, many misconceptions) are not verified in meaning.
+- The teacher model's wording is original to it; the source screen catches verbatim copying, not paraphrase.

evaluation/release_gate.md

@@ -0,0 +1,27 @@
+# optimization-ai999x 1.6.0 — release gate
+
+Pack 1.0.1. **RELEASABLE** (generated by `tools/release_gate.py`). Not published: publication needs the owner's approval.
+
+| criterion | passed | evidence |
+|---|---|---|
+| contracts | yes | {"contracts": 73, "invalid": {}} |
+| wheel_is_this_version | yes | {"version": "1.6.0", "latest_wheel": "optimization_ai999x-1.6.0-py3-none-any.whl"} |
+| acceptance | yes | {"tested": "optimization_ai999x-1.6.0-py3-none-any.whl", "latest_wheel": "optimization_ai999x-1.6.0-py3-none-any.whl", "tally": {"structured": {"run": 108, "passed": 108}, "missing": {"run": 278, "passed": 278}, "wrong_unit": {"run": 95, "passed": 95}, "unknown_input": {"run": 108, "passed": 108}, " |
+| guide | yes | {"examples_run": 248, "printed": 248, "withheld": 0} |
+| clean_install | yes | {"wheel": "optimization_ai999x-1.6.0-py3-none-any.whl", "wheel_kb": 3968.8, "installed_package_mb": 18.8, "cold_import_s": 0.043, "first_ask_s": 0.024, "warm_median_ms": 0.5, "peak_rss_mb": 29.0, "python": "3.14.4", "platform": "linux", "failed_checks": []} |
+| procedures | yes | {"defined": ["ahp_consistency_ratio", "ahp_geometric_mean", "ahp_priority_vector", "all_pairs_shortest_paths", "assignment_max_profit", "assignment_min_cost", "bellman_ford_shortest_path", "bin_packing", "bipartite_matching", "break_even_point", "can_min_surface", "critical_path_method", "critical_p |
+| must_refuse | n/a | {"questions": 0, "answered": []} |
+| regression | yes | {"files": {"probes.json": {"correct": 4, "refused_no_answer_is_determined": 1, "refused_capability_gap": 0, "refused_unjustified": 0, "incorrect": 0, "crash": 0, "correct_rate": 0.8, "refusal_rate": 0.2}}} |
+| no_network | yes | {"files_scanned": 36, "hits": []} |
+| no_source_material | yes | {"wheel": "optimization_ai999x-1.6.0-py3-none-any.whl", "leaks": []} |
+| reader_optional | n/a | {} |
+
+Release standard (what the vault's `releases/` accepts): **PUBLISHABLE**
+
+| criterion | passed | evidence |
+|---|---|---|
+| platforms | yes | {"identical_on": ["Linux", "Windows"], "reports": 2, "note": "macOS is expected (pure-Python core) but not tested"} |
+| dataset_card | yes | {"card": "release/DATASET_CARD.md"} |
+| pack_snapshot | yes | {"version": "1.0.1"} |
+| licence | yes | {} |
+| version | yes | {"version": "1.6.0"} |