babylon.engine.dialectics.volume_1

Capital Volume I dialectics — backward-compatibility re-export shim.

Deprecated since version Import: directly from the individual modules instead: babylon.engine.dialectics.commodity, babylon.engine.dialectics.labor_process, etc.

class babylon.engine.dialectics.volume_1.AbstractLabor(**data)[source]

Bases: BaseModel

Properties of labor as abstract, homogeneous substance (V1 Ch1§2).

Abstract labor is the social substance of value — labor stripped of its concrete characteristics and reduced to expenditure of human labor-power in general.

Parameters:
snlt

Socially Necessary Labour Time embodied.

productivity

Labor productivity multiplier (> 1.0 = above average).

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

snlt: float
productivity: float
class babylon.engine.dialectics.volume_1.AccumulationDialectic(**data)[source]

Bases: Dialectic[ConcentrationOfCapital, ReserveArmyExpansion]

Concentration of capital ↔ reserve army expansion (V1 Ch25).

Ch25§1: “accumulation of capital is… accompanied by… a relatively redundant population of labourers.” Rising OCC displaces workers, while accumulation itself creates demand.

Weight semantics:
weight < 0 → concentration dominant (A): capital expanding,

absorbing labor (prosperity phase).

weight > 0 → reserve army dominant (B): labor displacement,

rising unemployment (crisis phase).

Morphism inputs:

Receives rate_of_exploitation, occ, labor_hours_contributed from ProductionDialectic. Receives colonial_extraction from PrimitiveAccumulationDialectic.

Parameters:
model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

observe()[source]

Project accumulation state for downstream consumption.

Emits reserve_army_pressure for WageDialectic and total_labor_pool for macro aggregation.

Return type:

dict[str, Any]

Returns:

Base observation + accumulation-specific fields.

step(inputs, world)[source]

Motion law T for the accumulation contradiction.

Rising OCC from upstream Production shifts weight positive (toward reserve army expansion).

Parameters:

  • inputs (TickInputs) – Upstream outputs. Looks for occ.

  • world (WorldView) – Read-only world context.

Return type:

AccumulationDialectic

Returns:

New AccumulationDialectic with updated weight and tick.

type_tag: str
id: UUID
pole_a: A
pole_b: B
weight: float
parent_id: UUID | None
tick_created: int
tick_updated: int
class babylon.engine.dialectics.volume_1.ColonialExpropriation(**data)[source]

Bases: BaseModel

Active process of dispossessing colonized peoples (V1 Ch26-27, Ch31).

Ch31: “The treasures captured outside Europe by undisguised looting, enslavement, and murder, floated back to the mother-country and were there turned into capital.”

Following Sakai (Settlers) and MIM(P), this is not merely historical but an ongoing process: gentrification, mass incarceration (Ch28’s “bloody legislation” for the 13th Amendment), ICE raids, etc.

Parameters:
expropriation_rate

Rate of ongoing dispossession ∈ [0, 1].

colonial_extraction

Value extracted via extra-economic coercion.

land_theft

Fraction of indigenous/colonized land enclosed ∈ [0, 1].

super_exploitation_rate

Degree colonized workers are paid below the value of their labor-power (W_opc < V_opc).

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

expropriation_rate: float
colonial_extraction: float
land_theft: float
super_exploitation_rate: float
class babylon.engine.dialectics.volume_1.CommodityDialectic(**data)[source]

Bases: Dialectic[UseValue, ExchangeValue]

The use-value ↔ exchange-value contradiction (V1 Ch1).

Weight reflects whether the commodity is currently being held for use (weight < 0, A dominant) or for exchange (weight > 0, B dominant). Zero is equilibrium.

Motion law:

  • Production events shift weight toward exchange (increase, toward B).

  • Consumption events shift weight toward use (decrease, toward A).

The input convention is an upstream dict with keys:

  • event: "production" or "consumption"

  • intensity: float ∈ [0, 1] controlling shift magnitude

Sublation: None in Phase 1 (commodities persist).

Invariants:

  • SNLT ≥ 0 (enforced by pole validation)

Parameters:
invariants()[source]

Commodity-specific invariants.

Checks:

  • SNLT ≥ 0 (should be guaranteed by pole validation, but we double-check as a runtime safety net).

Return type:

list[str]

Returns:

List of violation descriptions.

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

observe()[source]

Project commodity state for frontend rendering.

Returns:

utility, demand, price, snlt.

Return type:

Base observation dict extended with commodity-specific fields

step(inputs, world)[source]

Motion law T for the commodity contradiction.

Production events shift weight toward exchange (pole B, positive); consumption events shift toward use (pole A, negative).

Parameters:

  • inputs (TickInputs) – Upstream outputs. Looks for own id’s entry with event and intensity keys.

  • world (WorldView) – Read-only world context (unused in Phase 1).

Return type:

CommodityDialectic

Returns:

New CommodityDialectic with updated weight and tick.

type_tag: str
id: UUID
pole_a: A
pole_b: B
weight: float
parent_id: UUID | None
tick_created: int
tick_updated: int
class babylon.engine.dialectics.volume_1.ConcentrationOfCapital(**data)[source]

Bases: BaseModel

Concentration of capital via reinvestment of surplus (V1 Ch25§1).

Ch24: “Accumulate, accumulate! That is Moses and the prophets!”

Parameters:
total_capital

Total capital stock (c + v).

reinvestment_rate

Fraction of surplus reinvested ∈ [0, 1].

fixed_capital

Capital tied up in instruments/machinery.

centralization_index

Degree of capital centralization ∈ [0, 1]. Distinct from concentration: centralization is merger and acquisition, concentration is growth from reinvestment.

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

total_capital: float
reinvestment_rate: float
fixed_capital: float
centralization_index: float
class babylon.engine.dialectics.volume_1.ConcreteLabor(**data)[source]

Bases: BaseModel

Properties of labor as concrete, particular activity (V1 Ch1§2).

Concrete labor creates use-values: spinning produces yarn, weaving produces cloth. It is labor in its specific, qualitative form.

Parameters:
skill

Worker skill level ∈ [0, 1].

intensity

Labor intensity ∈ [0, 1].

hours

Hours of concrete labor performed.

labor_type

Qualitative type of labor (spinning, mining, etc.).

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

skill: float
intensity: float
hours: float
labor_type: str
class babylon.engine.dialectics.volume_1.EmptyPole(**data)[source]

Bases: BaseModel

Placeholder pole when a Dialectic represents a unary transformation or state wrapper.

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

class babylon.engine.dialectics.volume_1.ExchangeValue(**data)[source]

Bases: BaseModel

Properties of a commodity as exchange-value (V1 Ch1).

Parameters:
price

Monetary price of the commodity.

snlt

Socially Necessary Labour Time embodied.

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

price: float
snlt: float
class babylon.engine.dialectics.volume_1.LaborProcessDialectic(**data)[source]

Bases: Dialectic[ConcreteLabor, AbstractLabor]

The concrete ↔ abstract labor contradiction (V1 Ch1§2, Ch7§1).

Every act of labor has a dual character: it is simultaneously concrete (producing specific use-values) and abstract (creating value as expenditure of human labor-power in general).

Weight semantics:
weight < 0 → concrete labor dominant (A): craft production,

skill matters, qualitative differences prominent.

weight > 0 → abstract labor dominant (B): factory production,

labor is homogenized, only quantity matters.

Motion law:

Competitive pressure (from upstream) pushes weight positive (toward abstraction). Absent pressure, weight is stable.

Parameters:
model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

observe()[source]

Project labor process state.

Return type:

dict[str, Any]

Returns:

Base observation + labor-specific fields.

step(inputs, world)[source]

Motion law T for the labor process.

Parameters:

  • inputs (TickInputs) – Upstream outputs. Looks for competitive_pressure.

  • world (WorldView) – Read-only world context.

Return type:

LaborProcessDialectic

Returns:

New LaborProcessDialectic with updated weight and tick.

type_tag: str
id: UUID
pole_a: A
pole_b: B
weight: float
parent_id: UUID | None
tick_created: int
tick_updated: int
class babylon.engine.dialectics.volume_1.PriceOfLaborPower(**data)[source]

Bases: BaseModel

Price of labor-power: the wage actually paid (V1 Ch19).

Ch19: “What the labourer sells is not directly his labour, but his labour-power.” The price (wage) may differ from the value.

Parameters:
nominal_wage

Money wage paid.

real_wage

Wage in terms of purchasing power.

relative_wage

Share of total product going to labor ∈ [0, 1].

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

nominal_wage: float
real_wage: float
relative_wage: float
class babylon.engine.dialectics.volume_1.PrimitiveAccumulationDialectic(**data)[source]

Bases: Dialectic[ColonialExpropriation, SettlerFormation]

Colonial expropriation ↔ settler formation (V1 Ch26-33 + Sakai).

The settler-colonial reframing of Marx’s primitive accumulation. Not “dispossession creates proletarians” but “dispossession of colonized peoples creates and sustains a settler class bribed by the spoils” (Sakai, MIM(P), Du Bois).

Weight semantics:
weight < 0 → A dominant: raw colonial violence is primary.

Frontier wars, active genocide, visible extraction.

weight > 0 → B dominant: settler formation is mature.

The bribe is institutionalized, violence structural. “Law and order” replaces open warfare.

Morphism outputs:

colonial_extraction → AccumulationDialectic (capital stock). imperial_rent_generated → WageDialectic (super-wages).

Parameters:
model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

observe()[source]

Project settler-colonial state for downstream consumption.

Emits colonial_extraction for AccumulationDialectic and imperial_rent_generated for WageDialectic.

Return type:

dict[str, Any]

Returns:

Base observation + settler-colonial fields.

step(inputs, world)[source]

Motion law T for primitive accumulation.

Extraction boost (from upstream) shifts weight. Without input, weight is stable.

Parameters:

  • inputs (TickInputs) – Upstream outputs. Looks for extraction_boost.

  • world (WorldView) – Read-only world context.

Return type:

PrimitiveAccumulationDialectic

Returns:

New PrimitiveAccumulationDialectic with updated weight.

type_tag: str
id: UUID
pole_a: A
pole_b: B
weight: float
parent_id: UUID | None
tick_created: int
tick_updated: int
class babylon.engine.dialectics.volume_1.ProductionDialectic(**data)[source]

Bases: Dialectic[DepartmentRow, EmptyPole]

The labor process ↔ valorization process contradiction (V1 Ch7§2).

Ch7§2: “The production of surplus-value is the differentia specifica of capitalist production.” The labor process (creating use-values) is subordinated to the valorization process (creating surplus-value).

Weight semantics:

weight < 0 → labor process dominant (A): production for use. weight > 0 → valorization dominant (B): production for profit.

observe() returns the value tensor [l, c, v, s, r]:

l = v + s (living labor / new value added) c = constant capital transferred v = variable capital (value of labor-power) s = surplus-value r = s/v (rate of exploitation)

Parameters:
invariants()[source]

Production-specific invariants.

Checks:

  • Surplus value ≥ 0.

Return type:

list[str]

Returns:

List of violation descriptions.

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

observe()[source]

Project the value tensor [l, c, v, s, r] + labor pool.

Ch8: Total value = c + v + s = c + l, where l = v + s.

Return type:

dict[str, Any]

Returns:

Value tensor components, OCC, and labor pool contribution.

step(inputs, world)[source]

Motion law T for the production contradiction.

Higher exploitation rates push weight positive (toward valorization). Uses upstream input if available, otherwise falls back to internal state.

Parameters:

  • inputs (TickInputs) – Upstream outputs. Looks for rate_of_exploitation.

  • world (WorldView) – Read-only world context.

Return type:

ProductionDialectic

Returns:

New ProductionDialectic with updated weight and tick.

type_tag: str
id: UUID
pole_a: A
pole_b: B
weight: float
parent_id: UUID | None
tick_created: int
tick_updated: int
class babylon.engine.dialectics.volume_1.ReserveArmyExpansion(**data)[source]

Bases: BaseModel

Industrial reserve army produced by accumulation (V1 Ch25§3).

Ch25: “The greater the social wealth… the greater is the industrial reserve army… The more extensive, finally, the lazarus-layers… the greater is official pauperism.”

Parameters:
unemployed_fraction

Fraction of labor force unemployed ∈ [0, 1].

wage_pressure

Downward pressure on wages from reserve army. Negative = tight market (upward pressure on wages).

absorption_rate

Rate at which reserve army is absorbed.

total_labor_pool

Total available labor-hours in the economy.

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

unemployed_fraction: float
wage_pressure: float
absorption_rate: float
total_labor_pool: float
class babylon.engine.dialectics.volume_1.SettlerFormation(**data)[source]

Bases: BaseModel

Creation and maintenance of the settler nation (Sakai, MIM(P)).

Sakai: The white working class is not a proletariat — it is a settler nation. Their material interests are tied to the colonial project. Du Bois/Roediger: “The wages of whiteness.”

MIM(P): First World “workers” are net exploiters when Wc/Vc > 1.

Parameters:
settler_share

Fraction of colonial surplus distributed as imperial rent (super-wages, land, state services) ∈ [0, 1].

labor_aristocracy_ratio

Wc/Vc for settler workers. > 1.0 means they consume more than they produce = labor aristocracy.

settler_identity

Degree of identification with colonial project vs. recognition of shared class interest ∈ [0, 1].

immiseration_resistance

How resistant settlers are to actual proletarianization ∈ [0, 1]. High when bribe flows.

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

settler_share: float
labor_aristocracy_ratio: float
settler_identity: float
immiseration_resistance: float
class babylon.engine.dialectics.volume_1.UseValue(**data)[source]

Bases: BaseModel

Properties of a commodity as use-value (V1 Ch1).

Parameters:
utility

How useful the commodity is to its possessor, ∈ [0, 1].

demand

Aggregate demand (labor-hours or units).

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

utility: float
demand: float
class babylon.engine.dialectics.volume_1.ValueOfLaborPower(**data)[source]

Bases: BaseModel

Value of labor-power: cost to reproduce the worker (V1 Ch6).

Ch6: “The value of labour-power is determined by the value of the necessaries of life habitually required by the average labourer.”

Parameters:
reproduction_cost

Total value needed to reproduce labor-power.

subsistence_hours

Labor-hours of the necessaries of life.

historical_moral_element

The “historical and moral element” that varies by country and epoch (Ch6). ∈ [0, 1].

model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

reproduction_cost: float
subsistence_hours: float
historical_moral_element: float
class babylon.engine.dialectics.volume_1.WageDialectic(**data)[source]

Bases: Dialectic[ValueOfLaborPower, PriceOfLaborPower]

The value ↔ price of labor-power contradiction (V1 Ch19-22).

Ch19: The daily price of labour-power does not coincide with its daily value. The wage mystifies the relation by concealing the division between necessary and surplus labor.

Weight semantics:
weight < 0 → tight labor market (“buy” market for labor-power).

Workers have bargaining power, W approaches V.

weight > 0 → loose labor market (“sell” market for labor-power).

Reserve army is large, W falls below V.

Parameters:
model_config: ClassVar[ConfigDict] = {'frozen': True}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

observe()[source]

Project wage state for downstream consumption.

Return type:

dict[str, Any]

Returns:

Base observation + wage-specific fields.

step(inputs, world)[source]

Motion law T for the wage contradiction.

Reserve army pressure (from AccumulationDialectic) pushes weight positive (toward sell market / depressed wages).

Parameters:

  • inputs (TickInputs) – Upstream outputs. Looks for reserve_army_pressure.

  • world (WorldView) – Read-only world context.

Return type:

WageDialectic

Returns:

New WageDialectic with updated weight and tick.

type_tag: str
id: UUID
pole_a: A
pole_b: B
weight: float
parent_id: UUID | None
tick_created: int
tick_updated: int