Datasets:

PureOne
/

Qyxo-Zhaenivoth-Guard

# Guard integration cookbook

Use a **prepared static value bank, new weight bounds and one threshold vector
per update**. This is the narrow measured workload. The commands below use the
bundled wheel; they do not assume that this package is published on PyPI.
Python 3.10+ is required. See `PUBLIC_INTERFACE.md` for the complete contract.

## Install in an application directory

These commands work from your application's directory, outside the release
folder. Replace the quoted release path with the path where you unpacked it.
The first installation is offline and uses only the bundled wheel. The NumPy
command is optional and may download packages.

Windows PowerShell:

```powershell
py -3 -m venv .venv
.\.venv\Scripts\python.exe -m pip install --no-index "C:\path\Guard\wheels\qyxo_zhaenivoth_guard-1.0.0-py3-none-any.whl"
.\.venv\Scripts\python.exe -m pip install "numpy>=1.24"
.\.venv\Scripts\python.exe -m qzguard doctor --backend filtered
```

Linux/macOS:

```bash
python3 -m venv .venv
.venv/bin/python -m pip install --no-index "/path/Guard/wheels/qyxo_zhaenivoth_guard-1.0.0-py3-none-any.whl"
.venv/bin/python -m pip install 'numpy>=1.24'
.venv/bin/python -m qzguard doctor --backend filtered
```

For exact-only use, omit NumPy installation and run doctor with
`--backend exact`. Run a saved Python example with your environment's interpreter:
`.venv/bin/python example.py` or `.\.venv\Scripts\python.exe example.py`.
Doctor checks a few deterministic fixtures; it does not certify every hardware
or compiler premise of the floating filter.

## Exact policy check with a counterexample

This complete example needs no NumPy. Values are fixed here; supplying
`value_upper` would make them independent value intervals.

```python
from qzguard import PreparedBank
bank = PreparedBank([0., 1.], backend='exact')
assert bank.evaluate([1., 100.], [1., 1_000_000.], .9,
                     relation='>=').all_guaranteed
answer = bank.evaluate([1., 0.], [1., 1_000_000.], .9, relation='>=')
assert answer.guaranteed == (False,)
witness = answer.exact(witness=True).witnesses[0]
assert witness.ratio < .9
print('admissible counterexample mean:', witness.ratio)
```

False means a violating configuration exists inside the independent input box.
It does not mean every configuration violates the policy. A witness from a box
that ignores physical correlations may be impossible in the original system.

## Recommended ndarray service loop

This is the installed-package form of `examples/fast_array_service.py`. It is
an executable integration example, not a benchmark or a production certificate.
Application-provided numeric NumPy arrays use the best measured public Python
path. Inputs are copied into immutable snapshots; keep the value bank outside
the update loop.

```python
import numpy as np
from qzguard import PreparedBank
x = np.linspace(-1.0, 1.0, 4096, dtype=np.float64)
values = np.column_stack((x, x + 0.25, x - 0.5, 2*x))
bank = PreparedBank(values - 0.01, values + 0.01, backend='filtered')
threshold = np.array([-0.2, 0.05, -0.7, -0.4], dtype=np.float64)
for step in range(3):
    lower = np.ones(len(x), dtype=np.float64)
    upper = lower * (1.1 + step * 0.05)
    result = bank.evaluate(lower, upper, threshold, relation='>=')
    assert result.all_guaranteed
    print({'step': step, 'backend': result.backend,
           'guaranteed': result.guaranteed, 'modes': result.modes})
    del result
```

One ambiguous coordinate currently triggers the full exact vector calculation.
`witness=True`, `exact_margins=True` and `.exact()` explicitly pay exact work;
leave them off the frequent path when decisions alone suffice. Route counts
count sign-decision routes, not arithmetic operations. An Evaluation retains
its weight snapshot and any exact fallback state. Store compact decision tuples
or serialized records instead of accumulating whole Evaluations indefinitely.

The filter requires the stated IEEE round-to-nearest binary64/gradual-underflow
and NumPy reduction premises. Use `backend='exact'` when those premises are
unavailable. `auto` selects once and reports `bank.backend`; explicit selection
is preferable for a fixed application contract. All guarantees concern the
exact real values of finite converted binary64 inputs, valid independent
intervals and a strictly positive minimum denominator.

## JSONL without a Python integration

From the release root, the no-install exact path is:

```bash
python START_HERE.py check --bank examples/json/bank_exact.json \
  --updates examples/json/updates.jsonl --output decisions.jsonl
```

For an installed environment, commands work from any directory. Use absolute
paths to the data files and your environment's interpreter in place of `python`:

```bash
python -m qzguard check --bank /path/Guard/examples/json/bank_exact.json \
  --updates /path/Guard/examples/json/updates.jsonl --output decisions.jsonl
python -m qzguard check --bank /path/Guard/examples/json/bank_fast.json \
  --updates /path/Guard/examples/json/updates.jsonl --backend filtered \
  --output filtered_decisions.jsonl
```

On Windows, use quoted Windows paths instead. The CLI defaults to exact unless
the bank or `--backend` explicitly selects another backend. JSONL prepares one
bank and processes one new weight box per line. Array speed measurements do
not describe JSON parsing, file I/O or process startup. Invalid update lines
produce error records and exit code 2 after the stream; valid false decisions
are successful results. Check `status` as well as `guaranteed`.

## Many thresholds on one unchanged box

Use cached sharp endpoints instead of repeated fresh-box evaluation:

```python
from fractions import Fraction
from qzguard import NormalizedBox
box = NormalizedBox([1., 100.], [1., 1_000_000.], [0., 1.])
bounds = box.enclose()
assert bounds.lower[0] == Fraction(100, 101)
for threshold in (.9, .99, 1.):
    cached = box.guard_from_bounds(threshold, relation='>=')
    assert cached.guaranteed == box.guard(threshold, relation='>=').guaranteed
    print(threshold, cached.guaranteed)
```

The cached path applies only while values, masses and bases stay unchanged.
Tiny boxes, boundary-heavy arithmetic, value-bank reconstruction and repeated
unchanged-box queries can favor exact methods. Consult `PUBLIC_API_RESULTS.md`
for measured scope and negative controls before making a runtime budget claim.

	# Guard integration cookbook

	Use a **prepared static value bank, new weight bounds and one threshold vector
	per update**. This is the narrow measured workload. The commands below use the
	bundled wheel; they do not assume that this package is published on PyPI.
	Python 3.10+ is required. See `PUBLIC_INTERFACE.md` for the complete contract.

	## Install in an application directory

	These commands work from your application's directory, outside the release
	folder. Replace the quoted release path with the path where you unpacked it.
	The first installation is offline and uses only the bundled wheel. The NumPy
	command is optional and may download packages.

	Windows PowerShell:

	```powershell
	py -3 -m venv .venv
	.\.venv\Scripts\python.exe -m pip install --no-index "C:\path\Guard\wheels\qyxo_zhaenivoth_guard-1.0.0-py3-none-any.whl"
	.\.venv\Scripts\python.exe -m pip install "numpy>=1.24"
	.\.venv\Scripts\python.exe -m qzguard doctor --backend filtered
	```

	Linux/macOS:

	```bash
	python3 -m venv .venv
	.venv/bin/python -m pip install --no-index "/path/Guard/wheels/qyxo_zhaenivoth_guard-1.0.0-py3-none-any.whl"
	.venv/bin/python -m pip install 'numpy>=1.24'
	.venv/bin/python -m qzguard doctor --backend filtered
	```

	For exact-only use, omit NumPy installation and run doctor with
	`--backend exact`. Run a saved Python example with your environment's interpreter:
	`.venv/bin/python example.py` or `.\.venv\Scripts\python.exe example.py`.
	Doctor checks a few deterministic fixtures; it does not certify every hardware
	or compiler premise of the floating filter.

	## Exact policy check with a counterexample

	This complete example needs no NumPy. Values are fixed here; supplying
	`value_upper` would make them independent value intervals.

	```python
	from qzguard import PreparedBank

	bank = PreparedBank([0., 1.], backend='exact')
	assert bank.evaluate([1., 100.], [1., 1_000_000.], .9,
	relation='>=').all_guaranteed
	answer = bank.evaluate([1., 0.], [1., 1_000_000.], .9, relation='>=')
	assert answer.guaranteed == (False,)
	witness = answer.exact(witness=True).witnesses[0]
	assert witness.ratio < .9
	print('admissible counterexample mean:', witness.ratio)
	```

	False means a violating configuration exists inside the independent input box.
	It does not mean every configuration violates the policy. A witness from a box
	that ignores physical correlations may be impossible in the original system.

	## Recommended ndarray service loop

	This is the installed-package form of `examples/fast_array_service.py`. It is
	an executable integration example, not a benchmark or a production certificate.
	Application-provided numeric NumPy arrays use the best measured public Python
	path. Inputs are copied into immutable snapshots; keep the value bank outside
	the update loop.

	```python
	import numpy as np
	from qzguard import PreparedBank

	x = np.linspace(-1.0, 1.0, 4096, dtype=np.float64)
	values = np.column_stack((x, x + 0.25, x - 0.5, 2*x))
	bank = PreparedBank(values - 0.01, values + 0.01, backend='filtered')
	threshold = np.array([-0.2, 0.05, -0.7, -0.4], dtype=np.float64)
	for step in range(3):
	lower = np.ones(len(x), dtype=np.float64)
	upper = lower * (1.1 + step * 0.05)
	result = bank.evaluate(lower, upper, threshold, relation='>=')
	assert result.all_guaranteed
	print({'step': step, 'backend': result.backend,
	'guaranteed': result.guaranteed, 'modes': result.modes})
	del result
	```

	One ambiguous coordinate currently triggers the full exact vector calculation.
	`witness=True`, `exact_margins=True` and `.exact()` explicitly pay exact work;
	leave them off the frequent path when decisions alone suffice. Route counts
	count sign-decision routes, not arithmetic operations. An Evaluation retains
	its weight snapshot and any exact fallback state. Store compact decision tuples
	or serialized records instead of accumulating whole Evaluations indefinitely.

	The filter requires the stated IEEE round-to-nearest binary64/gradual-underflow
	and NumPy reduction premises. Use `backend='exact'` when those premises are
	unavailable. `auto` selects once and reports `bank.backend`; explicit selection
	is preferable for a fixed application contract. All guarantees concern the
	exact real values of finite converted binary64 inputs, valid independent
	intervals and a strictly positive minimum denominator.

	## JSONL without a Python integration

	From the release root, the no-install exact path is:

	```bash
	python START_HERE.py check --bank examples/json/bank_exact.json \
	--updates examples/json/updates.jsonl --output decisions.jsonl
	```

	For an installed environment, commands work from any directory. Use absolute
	paths to the data files and your environment's interpreter in place of `python`:

	```bash
	python -m qzguard check --bank /path/Guard/examples/json/bank_exact.json \
	--updates /path/Guard/examples/json/updates.jsonl --output decisions.jsonl
	python -m qzguard check --bank /path/Guard/examples/json/bank_fast.json \
	--updates /path/Guard/examples/json/updates.jsonl --backend filtered \
	--output filtered_decisions.jsonl
	```

	On Windows, use quoted Windows paths instead. The CLI defaults to exact unless
	the bank or `--backend` explicitly selects another backend. JSONL prepares one
	bank and processes one new weight box per line. Array speed measurements do
	not describe JSON parsing, file I/O or process startup. Invalid update lines
	produce error records and exit code 2 after the stream; valid false decisions
	are successful results. Check `status` as well as `guaranteed`.

	## Many thresholds on one unchanged box

	Use cached sharp endpoints instead of repeated fresh-box evaluation:

	```python
	from fractions import Fraction
	from qzguard import NormalizedBox

	box = NormalizedBox([1., 100.], [1., 1_000_000.], [0., 1.])
	bounds = box.enclose()
	assert bounds.lower[0] == Fraction(100, 101)
	for threshold in (.9, .99, 1.):
	cached = box.guard_from_bounds(threshold, relation='>=')
	assert cached.guaranteed == box.guard(threshold, relation='>=').guaranteed
	print(threshold, cached.guaranteed)
	```

	The cached path applies only while values, masses and bases stay unchanged.
	Tiny boxes, boundary-heavy arithmetic, value-bank reconstruction and repeated
	unchanged-box queries can favor exact methods. Consult `PUBLIC_API_RESULTS.md`
	for measured scope and negative controls before making a runtime budget claim.