set/subset
===============================================================================

%% Subset test (set containment relation)

1. Usage
-------------------------------------------------------------------------------

```mech:disabled
R := set/subset(A, B)
R := A ⊆ B
```

2. Description
-------------------------------------------------------------------------------

Determines whether set `A` is a **subset** of set `B`.  
A subset has all its elements contained within another set.  
This function returns a boolean value indicating the result.

The implementation wraps the Rust `IndexSet` containment logic and
preserves Mech's deterministic order semantics for reproducibility.

3. Input
-------------------------------------------------------------------------------

Arguments:
- A : set of T   — candidate subset
- B : set of T   — superset being tested

Element type constraints:
- `T` must be hashable and comparable for equality (`Eq` + `Hash` in Rust).
- Common scalar kinds: integers, strings, symbols, booleans.

4. Output
-------------------------------------------------------------------------------

Result:
- R : boolean — true if all elements of `A` are contained in `B`, otherwise false.

5. Examples
-------------------------------------------------------------------------------

(a) True subset

```mech:ex1
A := {"b", "c"}
B := {"a", "b", "c", "d"}
R := set/subset(A, B)
```
Result: `R` = true

(b) False subset

```mech:ex2
A := {1, 4}
B := {1, 2, 3}
R := A ⊆ B
```
Result: `R` = false

(c) Equal sets still count as subsets

```mech:ex3
A := {"x", "y", "z"}
B := {"x", "y", "z"}
R := set/subset(A, B)
```
Result: `R` = true

6. Details
-------------------------------------------------------------------------------

Set semantics:
- Inputs are treated as sets (duplicates ignored).
- Order does not affect results.

Relation logic:
- `A` is a **subset** of `B` if every element of `A` exists in `B`.
- This differs from a **proper subset**, which requires `A` to contain
  strictly fewer elements than `B`.

Symbolic shorthand:
- `A ⊆ B` is equivalent to `set/subset(A, B)`.

Performance:
- Average O(\|A\|) time using hashing; memory O(1).

Determinism:
- Results are deterministic across runs and platforms.

7. Errors
-------------------------------------------------------------------------------

- Incorrect number of arguments (expects two).
- Unsupported element type (not hashable or comparable).
- Inconsistent element kinds between A and B.
