Hypercube World Model

This package is the Python surface for HypercubeWorldModel (import hypercube_worldmodel). Full API reference: docs/Python_SDK.md. C++ integration guide: docs/CPP_SDK.md. Project home: github.com/dliptak001/HypercubeWorldModel.

HypercubeWorldModel learns how the world moves. It is built from three core classes.

The WorldModel class wraps the other two and manages encoding, training, and prediction.

The other two form a pipeline: encoder → predictor.

The Encoder class is a frozen hypercube reservoir. Its neurons are the vertices of a Boolean hypercube, one neuron per vertex, and a cube of dimension dim has N = 2ᵈⁱᵐ of them. What it consumes is a field: one value per vertex, N values in all. What it returns after an episode of T passes is a cube: the value every neuron settled on, again N values. The WorldModel owns two of these encoders, and they sit on cubes of different sizes.

The view encoder sits on the dim-cube. The view is what the world model sees at one moment: a field of N values, one per vertex. The episode returns a cube of N values, and only the first 2ᵏ of them are kept, for some k smaller than dim. Those first 2ᵏ vertices form a face of the cube, the k-face, and the kept values are the view's code, written E(x). That cut is the compression: E(x) is 2ᵏ long.

Two things could be meant by compression, and it is worth separating them now. Dimensional compression is the count: N values in, 2ᵏ out, with the ratio fixed by k and nothing else. That is what this project does, on purpose and exactly. Semantic compression is whether those 2ᵏ values say something about the whole field rather than about 2ᵏ vertices of it. The reservoir mixes every vertex with every other over T passes before the cut, so the k-face carries the rest of the field with it, and the Decoder can get part of it back. That carrying is the whole reason the encoder works: a bare slice of 2ᵏ samples would say nothing about the other N − 2ᵏ, and the orbit is what makes the k-face a code instead of a crop. What the project does not yet do is put a number on it or steer it. Nothing in the design sets how much of the field the k-face holds, nothing measures it apart from what the Decoder gets back, and no knob turns it up or down. When this page says compression it means the count. The semantic side is real, it is the point, but it is still unquantified.

The action encoder sits on a cube of dimension k, the size of the face just kept. The action is what the agent did, painted as a picture of 2ᵏ values, one per vertex. The episode returns a cube of 2ᵏ values and all of it is kept. Nothing is cut, because the action cube is already the size of the code. The result is the action's code, written E(a), and it is 2ᵏ long.

So the view comes in at N = 2ᵈⁱᵐ and the action at 2ᵏ, and both leave their encoders at 2ᵏ. Two codes of the same length is what lets them sit side by side on the Predictor.

The Predictor class is a locally connected net, an LCN, on a hypercube of dimension k+1, twice the code length. Every vertex has its own weights over its neighbors and nothing else. One half of the cube holds E(x), the other half holds E(a), and the net emits a guess at the next E(x).

A fourth class, the Decoder, is a meter. It learns to rebuild the field from its k-face so you can see what the compression threw away. It never sits in the prediction loop.

This is a JEPA-shaped world model with frozen encoders: predict the next code, not the next samples.

The point of this experiment is to see whether a frozen hypercube reservoir can serve as the encoder of a world model, so that the Predictor is the only part that has to be trained. The encoders are drawn from a seed and never modified. The Predictor is small: one weight table per vertex, over that vertex's neighbors and nothing else.

A world model does not predict the next view. It predicts the next code: a short list of numbers that stands in for the view, small enough to learn on and rich enough that the view could be rebuilt from it. The usual name for it is the latent; this page says code. Many systems learn that code. Here it is not learned at all. It is the first 2ᵏ vertices of the cube the encoder ran on, read straight off the reservoir.

The aim, then, is a world model whose encoders cost nothing to train, whose code is a face of the cube it was born on, and whose dynamics learn from that code alone.

In Python the product is two classes, hypercube_worldmodel.WorldModel and hypercube_worldmodel.Decoder, plus one function, paint_stripes, that turns a short vector into a field.

HypercubeAI ecosystem

HypercubeESN · HypercubeCNN · HypercubeHopfield · HypercubeWTF · HypercubeEtalon · HypercubeCascade · HypercubeLCN · HypercubeWorldModel

📄 Foundational paper: Boolean Hypercubes as a Neural Substrate (D. C. Liptak, 2026)

HypercubeWorldModel is an experiment in the HypercubeAI project — our quest to systematically re-implement classical neural architectures on a Boolean hypercube topology instead of Euclidean grids or random graphs. The central thesis is “topology-native intelligence”: the hypercube’s algebraic structure (vertex-transitive symmetry, Hamming geometry, bitwise addressing) can serve as a first-class computational substrate.

A topology you don’t store — the graph is specified: connectivity is implicit in the vertex indices; with a seed and a few config scalars the whole reservoir reconstructs mathematically.
Perfect homogeneity — every vertex has the same degree and the same local world, so local dynamics mean the same thing everywhere — no structural favorites baked in by a random graph.
Cheap navigation — each neighbor is a few bit operations on the vertex index, not a pointer chase through a stored edge list, so walks stay arithmetic and cache-friendly.
Topology-native pairing — the code is a face of the cube the encoder ran on, and the predictor is a net on that same cube grown by one bit. The code never leaves the hypercube it was born on, and the action sits one hop from the view.
Nested codes from one episode — faces of a hypercube nest by address prefix: the (k−1)-face is the first half of the k-face. So one encoder episode yields the code at every compression ratio at once, and choosing k is choosing where to cut, not rerunning the encoder. A learned encoder has to be retrained for each latent size.

Each product in the family is a different architecture on that same foundation.

The Encoder

HypercubeWTF drives a frozen hypercube reservoir with a still field and hands the result to a readout. HypercubeLCN trains a locally connected net directly on a cube field. The world model sits between them: WTF's reservoir as the eye, LCN's net as the dynamics.

The Encoder is a fork of the HypercubeWTF core: one neuron per vertex, frozen recurrent weights over the cube's edges, a delay line holding the last M outputs, tanh activation, and a frozen initial condition that is reloaded before every episode. Nothing in it is ever trained.

A field has no next sample. So the Encoder invents a short stretch of synthetic time: it re-addresses the same fixed field over the cube for T passes and samples the reservoir once at the end. Geometry and weights stay put; only the registration of the field moves. The episode goes something like this.

Leave the caller's field alone. The drive is built in a scratch
buffer.

Reload the reservoir's frozen initial condition.

LOOP:

    Remap the field by xor with the pass index: vertex v is driven
    by the field value at v xor c.

    Inject that remapping. Step the reservoir: every vertex forms
    the weighted sum of its neighbors and its drive, and writes
    tanh of that sum.

    Increment the pass index.

GOTO LOOP

After T passes, the reservoir's live output is the cube.

Every episode starts from the same frozen initial condition, so the cube depends on the field and nothing else. Both the view and the action go through an episode like this. They differ in which cube they run on and in how much of the output is kept.

The view

The view is what the world model sees at one moment: a field of N values laid onto the dim-cube, vertex i holding sample i. The WorldModel does not define what those samples are. That is up to the application. A state vector shorter than N goes through paint_stripes, which lays each value over a block of the cube.

The view encoder runs one episode on that field and returns a cube of N values. Only the low k-face, 2ᵏ values, is kept. That cut is the compression, and it is where the world model decides how much of the view to carry forward. The kept face is E(x).

The action

An action goes through the same machine as the view. The caller paints it as a picture of 2ᵏ cells, one per vertex of a second, smaller cube of dimension k. A second Encoder, built from the same knobs and seeds as the view encoder but on that k-cube, runs one episode on the picture. Its whole output is already 2ᵏ long, so nothing is cut: that output is E(a).

The WorldModel does not define what the picture looks like. That is up to the application. A task with no action at all can pass a constant picture. A bounded action vector goes through paint_stripes the same way a state vector does.

The Predictor

The Predictor's cube has dimension k+1: twice the k-face. The extra address bit splits it in half. The first half carries E(x). The second half carries E(a), scaled by one constant so the two codes reach the net at a chosen ratio. Vertex i of the view sits one hop from vertex i of the action, so the net's first depth already sees both.

The net is an LCN: every vertex keeps its own small weight table over its neighbors and itself, applied depth after depth, with a short lookback over earlier depths. Training is backprop through every depth with Adam.

The net has one output per vertex, 2ᵏ⁺¹ in all, but only the first 2ᵏ are used. Those are the predicted next view code, and they are what the loss compares against the true next view code. The other outputs are not read by anything.

The Decoder

As a convenience, the Decoder is provided as a reconstruction meter. It takes the k-face, places it on the low subcube of a full cube, feeds zero everywhere else, and learns to emit the original field. The residual, the reconstruction minus the field, is what the compression threw away in a form the Decoder could not invert. It is trained separately, scored separately, and never enters the prediction loop. In Python it is the second class, and it decodes a predicted code as readily as an encoded one.

Installation

Preferred: install a pre-built wheel from PyPI (no compiler).

pip install hypercube-worldmodel

import hypercube_worldmodel as hw
print(hw.__version__)

Package name on PyPI: hypercube-worldmodel. Import name: hypercube_worldmodel. Main types: hw.WorldModel and hw.Decoder.

The wheel compiles the C++ WorldModel and Decoder into the extension. It is the same net as the C++ SDK, the same files, not a port.

Wheels target Python 3.10 through 3.14 on common Windows, Linux, and macOS machines. Runtime dependency: NumPy only.

From source (full repository)

To compile the extension yourself, clone the entire repository, not the python folder alone: the C++ core lives next to it. You need Python 3.10 or later, a C++23 compiler, and CMake 3.21 or later.

git clone https://github.com/dliptak001/HypercubeWorldModel.git
cd HypercubeWorldModel/python
pip install .

On Windows with CLion's MinGW, put that compiler's bin folder and Ninja on your PATH, then:

pip install . --no-build-isolation --force-reinstall --no-deps

(Exact CLion paths change with the version.)

Quick start

A point on a plane moves by a bounded velocity. The view is the position, the action is the velocity. Both are short vectors, so they go through paint_stripes, which spreads each value over a block of the cube so the encoder has something to respond to.

Shapes that matter:

Array	Shape	Notes
a view field	(N,) or (count, N)	one value per vertex of the view cube
an action picture	(code_size,) or (count, code_size)	one value per vertex of the action cube
a code	(code_size,) or (count, code_size)	what encode, encode_action, and predict return
a plan	(H, code_size) or (count, H, code_size)	action codes for rollout

import numpy as np
import hypercube_worldmodel as hw

rng = np.random.default_rng(0)
count = 512
obs = rng.uniform(-1, 1, (count, 2)).astype(np.float32)
act = rng.uniform(-1, 1, (count, 2)).astype(np.float32)
obs_next = np.clip(obs + 0.1 * act, -1, 1)

wm = hw.WorldModel(dim=6, k=5, passes=12, leak_rate=0.25, input_scaling=0.8,
                   action_scale=0.33, z_max=15, gather_span=5, tanh_last=True,
                   lr=0.03, lr_min_frac=0.05, restore_best=True)

z = wm.encode(hw.paint_stripes(obs, wm.N))                # (count, code_size)
za = wm.encode_action(hw.paint_stripes(act, wm.code_size))
z_next = wm.encode(hw.paint_stripes(obs_next, wm.N))

wm.fit(z, za, z_next, epochs=200, batch_size=16, verbose=True)

hat = wm.predict(z[0], za[0])          # (code_size,) predicted next view code
path = wm.rollout(z[0], za[:3])        # (4, code_size): z[0] then three steps
wm.save("model.wm")                    # the same file C++ WorldModel::Load reads

To see what a code stands for, train a Decoder beside it:

dec = hw.Decoder(dim=wm.dim, k=wm.k, gather_span=3, lr=0.01, restore_best=True)
dec.fit(z, hw.paint_stripes(obs, wm.N), epochs=100, batch_size=16)
field = dec.decode(hat)                # (N,) the predicted next view, rebuilt

Step by step (same loop, more control)

fit is nothing but this loop. Drive it yourself to interleave your own metrics, schedules, or early stopping:

for epoch in range(epochs):
    wm.set_epoch(epoch, epochs)               # cosine learning rate
    for start in range(0, count, batch_size):
        wm.begin_batch()
        idx = slice(start, start + batch_size)
        wm.accumulate(z[idx], za[idx], z_next[idx])   # forward, loss, backward per row
        wm.end_batch()                        # one Adam step per batch
    wm.observe(wm.evaluate(z_val, za_val, z_val_next), epoch)
wm.restore_best()

The gradient is a sum over the batch, so the effective step scales with batch size, the same convention as the C++ SDK.

Driving a planner

A sampling planner needs five calls from a model: encode a view, encode an action, step a code, roll a code out over a plan, and score the result. The package gives the first four; scoring is the task's. python/examples/plan_toy.py is the DeepMind Control Suite protocol: CEM samples raw actions, reads action_space.low / .high, and passes those arrays to rollout. The adapter paints and encode_action's the block once, then WorldModel.rollout on the codes. This path is state-based: concatenate the observation into a vector, paint_stripes onto N, encode. A camera frame is not a field of N. Swap the environment for a state-based suite task and keep the adapter.

Features

Two classes. hw.WorldModel and hw.Decoder are the whole surface, plus one function, hw.paint_stripes.
Frozen encoders. Codes depend only on the field and the seeds; encode a stream once, train on it many times.
fit. Shuffle, batch, cosine schedule, restore-best with an optional validation set, in one call.
Custom loops. begin_batch, accumulate, end_batch, set_epoch, observe, restore_best, exposed one to one with the C++ API.
Batched by shape. Every method takes one row or many and returns the same shape; the loop runs in C++ with the GIL released.
rollout. Chain predict over a plan of action codes, for a sampling planner.
Nested codes. Faces nest by address prefix, so the first half of a code is the code one k lower; last_cube gives the whole episode.
Weights and gradient as NumPy. Settable weights and a readable gradient on both classes, for hosts that train replicas.
Save and load. The same binary files the C++ classes write and read, and pickle for convenience. Optimizer state is not stored.
NumPy float32. Arrays converted for you; prefer contiguous float32.

Examples

For a first try, paste the Quick start after pip install hypercube-worldmodel. That is self-contained.

The demo scripts on GitHub under python/examples/ are there to open or download; they are not added to your machine by pip.

Script	What it is for
plane_point.py	The quick start with a held-out score against the identity guess, a Decoder, and a save and load round trip
plan_toy.py	DMC protocol adapter: CEM passes raw actions to rollout, action_space.low / .high; state vectors, not pixels

# from a clone of HypercubeWorldModel, after: pip install hypercube-worldmodel
python python/examples/plane_point.py
python python/examples/plan_toy.py

These use an easy made-up world so the API is obvious; they are not scores to publish.

Tests and write-ups

The C++ tests are where the design was worked out, and each one has its own write-up in the repository.

CompressionTest: how much of a field survives the cut to a k-face. Write-up: docs/compression_test.md.
JepaEncoderTest: does the k-face damp noise relative to content, or copy the field. Write-up: docs/jepa_encoder_test.md.
JepaPredictorTest: the Predictor on a stream with no action. Write-up: docs/jepa_predictor_test.md.
WorldModelTest: the full WorldModel on a stream with a constant action. Write-up: docs/world_model_test.md.
TerrainWalkerTest: a walker on an elevation map, the WorldModel predicting the next crop from the current crop and the step taken, and the swap check that shows the Predictor reads the action. Write-up: docs/terrain_walker.md.

The component specifications are docs/encoder.md, docs/predictor.md, docs/decoder.md, and docs/world_model.md.

The package's own tests are python/tests/test_basic.py: contract coverage on small cubes, including the save and load round trip against the C++ file format.

Documentation

Doc	Role
docs/Python_SDK.md	Canonical Python API: every method, shape, file format, limits
docs/CPP_SDK.md	Native library guide (same product, C++)
Project README	Product story and the C++ SDK from the repo root
docs/encoder.md	The frozen encoder episode and its knobs
docs/predictor.md	The Predictor and its training cycle
docs/world_model.md	The WorldModel class, the action path, persistence
docs/decoder.md	The Decoder class and its file format
python/examples/README.md	The Python demo scripts

Ecosystem

HypercubeWTF: the frozen reservoir orbit the Encoder is forked from, plus a thin readout.
HypercubeLCN: the locally connected net the Predictor and the Decoder are built from, every weight trained.
HypercubeEtalon: frozen etalon transit plus a thin readout.
HypercubeCascade: both frozen stages in series plus a thin readout.
HypercubeCNN: cube-native conv stack with shared kernels.
HypercubeESN: echo-state reservoir computing on streams.
HypercubeHopfield: Hopfield-style dynamics on the cube.

License

Apache 2.0.

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

hypercube_worldmodel-1.0.0.tar.gz (40.1 kB view details)

Uploaded Sep 10, 2026 Source

Built Distributions

If you're not sure about the file name format, learn more about wheel file names.

The dropdown lists show the available interpreters, ABIs, and platforms. Enable javascript to be able to filter the list of wheel files.

hypercube_worldmodel-1.0.0-cp314-cp314-win_amd64.whl (376.9 kB view details)

Uploaded Sep 10, 2026 CPython 3.14Windows x86-64

hypercube_worldmodel-1.0.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (208.0 kB view details)

Uploaded Sep 10, 2026 CPython 3.14manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

hypercube_worldmodel-1.0.0-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl (193.1 kB view details)

Uploaded Sep 10, 2026 CPython 3.14manylinux: glibc 2.26+ ARM64manylinux: glibc 2.28+ ARM64

hypercube_worldmodel-1.0.0-cp314-cp314-macosx_13_0_x86_64.whl (171.5 kB view details)

Uploaded Sep 10, 2026 CPython 3.14macOS 13.0+ x86-64

hypercube_worldmodel-1.0.0-cp314-cp314-macosx_13_0_arm64.whl (157.1 kB view details)

Uploaded Sep 10, 2026 CPython 3.14macOS 13.0+ ARM64

hypercube_worldmodel-1.0.0-cp313-cp313-win_amd64.whl (365.4 kB view details)

Uploaded Sep 10, 2026 CPython 3.13Windows x86-64

hypercube_worldmodel-1.0.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (207.9 kB view details)

Uploaded Sep 10, 2026 CPython 3.13manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

hypercube_worldmodel-1.0.0-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl (192.5 kB view details)

Uploaded Sep 10, 2026 CPython 3.13manylinux: glibc 2.26+ ARM64manylinux: glibc 2.28+ ARM64

hypercube_worldmodel-1.0.0-cp313-cp313-macosx_13_0_x86_64.whl (171.3 kB view details)

Uploaded Sep 10, 2026 CPython 3.13macOS 13.0+ x86-64

hypercube_worldmodel-1.0.0-cp313-cp313-macosx_13_0_arm64.whl (156.9 kB view details)

Uploaded Sep 10, 2026 CPython 3.13macOS 13.0+ ARM64

hypercube_worldmodel-1.0.0-cp312-cp312-win_amd64.whl (365.4 kB view details)

Uploaded Sep 10, 2026 CPython 3.12Windows x86-64

hypercube_worldmodel-1.0.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (207.8 kB view details)

Uploaded Sep 10, 2026 CPython 3.12manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

hypercube_worldmodel-1.0.0-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl (192.7 kB view details)

Uploaded Sep 10, 2026 CPython 3.12manylinux: glibc 2.26+ ARM64manylinux: glibc 2.28+ ARM64

hypercube_worldmodel-1.0.0-cp312-cp312-macosx_13_0_x86_64.whl (171.2 kB view details)

Uploaded Sep 10, 2026 CPython 3.12macOS 13.0+ x86-64

hypercube_worldmodel-1.0.0-cp312-cp312-macosx_13_0_arm64.whl (156.8 kB view details)

Uploaded Sep 10, 2026 CPython 3.12macOS 13.0+ ARM64

hypercube_worldmodel-1.0.0-cp311-cp311-win_amd64.whl (365.2 kB view details)

Uploaded Sep 10, 2026 CPython 3.11Windows x86-64

hypercube_worldmodel-1.0.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (207.4 kB view details)

Uploaded Sep 10, 2026 CPython 3.11manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

hypercube_worldmodel-1.0.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl (193.1 kB view details)

Uploaded Sep 10, 2026 CPython 3.11manylinux: glibc 2.26+ ARM64manylinux: glibc 2.28+ ARM64

hypercube_worldmodel-1.0.0-cp311-cp311-macosx_13_0_x86_64.whl (168.3 kB view details)

Uploaded Sep 10, 2026 CPython 3.11macOS 13.0+ x86-64

hypercube_worldmodel-1.0.0-cp311-cp311-macosx_13_0_arm64.whl (154.6 kB view details)

Uploaded Sep 10, 2026 CPython 3.11macOS 13.0+ ARM64

hypercube_worldmodel-1.0.0-cp310-cp310-win_amd64.whl (363.9 kB view details)

Uploaded Sep 10, 2026 CPython 3.10Windows x86-64

hypercube_worldmodel-1.0.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (205.4 kB view details)

Uploaded Sep 10, 2026 CPython 3.10manylinux: glibc 2.27+ x86-64manylinux: glibc 2.28+ x86-64

hypercube_worldmodel-1.0.0-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl (191.6 kB view details)

Uploaded Sep 10, 2026 CPython 3.10manylinux: glibc 2.26+ ARM64manylinux: glibc 2.28+ ARM64

hypercube_worldmodel-1.0.0-cp310-cp310-macosx_13_0_x86_64.whl (167.0 kB view details)

Uploaded Sep 10, 2026 CPython 3.10macOS 13.0+ x86-64

hypercube_worldmodel-1.0.0-cp310-cp310-macosx_13_0_arm64.whl (153.3 kB view details)

Uploaded Sep 10, 2026 CPython 3.10macOS 13.0+ ARM64

File details

Details for the file hypercube_worldmodel-1.0.0.tar.gz.

File metadata

Download URL: hypercube_worldmodel-1.0.0.tar.gz
Upload date: Sep 10, 2026
Size: 40.1 kB
Tags: Source
Uploaded using Trusted Publishing? Yes
Uploaded via: twine/7.0.0 CPython/3.13.14

File hashes

Hashes for hypercube_worldmodel-1.0.0.tar.gz
Algorithm	Hash digest
SHA256	`32b0d93c3cbe6e18505bfab97fc1f0b9962533be8981163c86502ac0460fc5eb`
MD5	`7e285cd2bce0c6d07628fbde07f52d5e`
BLAKE2b-256	`be3d01649941264ddeda6e2f0aeb5a4084a9b1fcaef17e4f6120edc08df0c7b0`

Algorithm	Hash digest
SHA256	`a2c2f477b07fd207eab8979fcd51d3cc63c2e0d7267f04373e0f9dc0d85ac955`
MD5	`522b24a61742c3c1dd34f7587cf961cf`
BLAKE2b-256	`b731eebbfb7474d1984299e4d50691fa509bb3db45ff532a220e44ebae17fc0e`

Algorithm	Hash digest
SHA256	`4dc80a5ec9aa5557f4b845fbed9fbd344d7eef6b18c5cf2437fce96b544d5a88`
MD5	`188790860484e4517727772b4a1d64db`
BLAKE2b-256	`85bdd60b78022f7aa5d56e2583361b3ee664d70250233224f8c4d30bc8fd71f3`

Algorithm	Hash digest
SHA256	`5bd884c76d9ac923073136961e10d0e746363fcb560beda27e9c467b805c4fea`
MD5	`dd9dbdd403f0dec55d815806050badbe`
BLAKE2b-256	`a1bb6d597ee37c8c0e4176aedb8ff9bc5b4684392acd495d409d4e813130ebdf`

Algorithm	Hash digest
SHA256	`26ffcd35b265d3255d0e431984f26ad3723e6acd2ce211fafddf9c8d3d0146f9`
MD5	`a9714a9700b33fe9858654d212b3fc70`
BLAKE2b-256	`c7803f3908acb6ec1db05d669e19ed32d11520e194ebaf56a4908f2dbd738675`

Algorithm	Hash digest
SHA256	`af7f8855f4e6c1997fdac954ee267df80be65857fdfd86286f0dc27c0e2e4e64`
MD5	`a5fb80b246b3580f83e135d2922ffe29`
BLAKE2b-256	`b5699402115fdc7a6c177c49db1f502ecf2bb785d50f764cb36d1d228faa1fa2`

Algorithm	Hash digest
SHA256	`23c19bcda63879f11f4b8f5c1ab15f91ef95edc212542a1dd4e7b3ee9371bdcd`
MD5	`99f1404871f7a728e8043b73e4947023`
BLAKE2b-256	`5ab9316f78653bdb2f4435076f167baa4caff2a3b0976970db56ef2d700b86c1`

Algorithm	Hash digest
SHA256	`636be74bbd77a74d27b9f8e4acaf429ec8d89cb806017e6f77cda024fb7a6768`
MD5	`30b9574ad4536b6c6db0ab8f8a62012d`
BLAKE2b-256	`bb351726e83cbfa5af8eefe4000f0c852c7da836c1777a15077e048010195151`

Algorithm	Hash digest
SHA256	`71336ed154c885a3045b66bb0c9e944d09933b03c48232749be2205cddade6b8`
MD5	`2d980ff653b581fde4c4f418b0c8c5bc`
BLAKE2b-256	`7da2ad927cbbbad9a7367454b6a014561fa79439640ac29d7f11e593ddc83bab`

Algorithm	Hash digest
SHA256	`6cee96239ac984fac12a7961580c9d1a9af103de883fb536b8bf52aae2498517`
MD5	`6a47e529d43aa6caf12c0ea0f5836cdf`
BLAKE2b-256	`4f591cb35cf6298683c68c116de8c2f2fa74b8565efbe2aa6775a8f79d00516e`

Algorithm	Hash digest
SHA256	`f04f52355c00859bed258fe29c7ae29c759c5433f736f2a25fe775e884c4f5d8`
MD5	`5b6efc2c7ede462b7f4c55d68ebd74a0`
BLAKE2b-256	`3ad0ce6bf40600652675d430e06e70edef31a99caf038fcdf8e15548f8d4a749`

Algorithm	Hash digest
SHA256	`5714960cffed4685dd01beff3733174015730de43dc6558e54efa5ea7fe42905`
MD5	`c713e9f998f9af9b453f933fd8814c6b`
BLAKE2b-256	`6b3da77732afe7109014fd0669d0a38d6279d75b6ad9b18ef32b57747c2fe388`

Algorithm	Hash digest
SHA256	`17e91cfe2ede3c29be63f9ad5fae74b4d7effb264774bb28abc50b0ea387ea27`
MD5	`992ff7dfe587cdba7db640879c613beb`
BLAKE2b-256	`1a778c68989a92106c462671a5a08e88533cc9263c94384c23ce5f8108b3ae17`

Algorithm	Hash digest
SHA256	`723836143f951926920036e41c24d162d4f695401fb63274e2802a4fc5f6f26c`
MD5	`37116f68ea1861a2bf227cf8c16ab07b`
BLAKE2b-256	`10fc1412043d9afa11981ee25c6babe3ab7bde42cfdaaea15052014d1a46499f`

Algorithm	Hash digest
SHA256	`383b948e6378a8b518dbea9849de6dbe90e9deb2caf3a38539bea50c3ce68314`
MD5	`86aaec6dfa1caa657c2fb9f9c569ca51`
BLAKE2b-256	`0fcc753785eb5e5cf1c5b1001314703d0f4010a5233cefdd57fb297e00f079fe`

Algorithm	Hash digest
SHA256	`51ee6f8ce6e1229d6e73178470d10b7b7505441b4d5d775ca25caf8828e896b7`
MD5	`232a27044c4501f94e0de4272139425c`
BLAKE2b-256	`6fe8febeb829ce165ff2aeb1d882269873680e616dd61e7268b69d76ed140ce1`

Algorithm	Hash digest
SHA256	`8fb616aeabffcdaa0d43638418297eb6a586746c52ca97d3d9b06513df93a19d`
MD5	`597505bbd0b1b9493ec97c84f6c97b54`
BLAKE2b-256	`69124aaf9d51173dec3aa215bc1e32b70a134db20586eecf0c18fdfb8d56c9e6`

Algorithm	Hash digest
SHA256	`baf90fc0f22c73008bb8876085cd9f27f3dd23adf7686fd575046dbb39df2153`
MD5	`7860b7a8b0794e47d069791b291c9f48`
BLAKE2b-256	`6d90a3812e9e7eb71c75b5261d7afa01dd8171275cd29db37a14168045980b78`

Algorithm	Hash digest
SHA256	`6d8864c21918f45575a73f123ca0e8acf354ac25198a798707797d71403457fc`
MD5	`960131f6ca6fee5dce0e98c1f98e94ef`
BLAKE2b-256	`b17b424cf0a3fa0ad2286de307574a78e6ed18a7fdef79e0fbf9856819f8e834`

Algorithm	Hash digest
SHA256	`73e78d58e0f4317e2784f22ec59adb0bb1ec7ff2a37b0f49859db2bb6744fc7e`
MD5	`cdb02c0c241efadd13797af113028fb8`
BLAKE2b-256	`cd7454f4de1a8cc111439a8ce7f320c49af1d7f71ea34484cded95e15ba5cb15`

Algorithm	Hash digest
SHA256	`4599a3b32aafed2f0d9ec94f30a1added2e371a2139a83ebbd4c9dd708d396b6`
MD5	`29650d65c68fff037852808abb1b9e82`
BLAKE2b-256	`70485fd871649d3657828d4dc9d745b46d3ec4cbcc6463ad0688801ee22ca4c7`

hypercube-worldmodel 1.0.0

Hypercube World Model

The Encoder

The view

The action

The Predictor

The Decoder

Installation

From source (full repository)

Quick start

Step by step (same loop, more control)

Driving a planner

Features

Examples

Tests and write-ups

Documentation

Ecosystem

License

Project links

Key dates

1 maintainer

GitHub Statistics

License expression

Requires

Provides Extra

Classifiers

Download files

Source Distribution

Built Distributions

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Provenance

File details

File metadata

File hashes

Algorithm	Hash digest
SHA256	`e1dd01f32639d9ed5e5dba14dbfd42bb6ed32bf49bbc05a5017512316a2bfc4a`
MD5	`337e1e1db0175e3f3f61b3f9fb52b35c`
BLAKE2b-256	`482da21eecb528a8f5bbad16a23921d497437735dea2875aa37ebb40dff1ff0c`

Algorithm	Hash digest
SHA256	`1f4422ba9575f1fdcb7a155a0e7b97cf386e984b008ef0ac5b1f3eeb3d17a3f9`
MD5	`a6cb04034abc52998a3f1cc1e04178de`
BLAKE2b-256	`25e645ef5819104b76710244e01ed6aee41ed4b710858b6cbf49cb7f8a69b6e7`

Algorithm	Hash digest
SHA256	`3dac6a9c154f2e016ec9af922f6191985a929a8dae998d35a7417f823bb3f775`
MD5	`6f564279134c92f0479707340ba9030e`
BLAKE2b-256	`6bccea19e6d5ab5534e3945ace8e16d76de9c1e42b35a3df3f545c7c4a814d79`

Algorithm	Hash digest
SHA256	`a3bb88f0a81f566e0d7de3a5378cbadcc578918db9c5a4a21bb083c648b281ce`
MD5	`01ec350e044c61d31fd2c0297c6b45fe`
BLAKE2b-256	`298da0d9f4bc7340db45447ab799402680a82bba8c414aa89cd9cc6c7ecfb9d6`

Algorithm	Hash digest
SHA256	`d3d78eeb53bb43ff9acd0264f9ace9db726b84f15580e8c24855f92cdd66c847`
MD5	`56b6abf8cd98020618b7093b86e0fbe3`
BLAKE2b-256	`f1bb30873c19cf21753a89dcbd622c9009900a2379ad747be63ae860c989faa7`