PMS–LOGIC is a formal application of the Praxeological Meta-Structure (PMS) — a generative operator framework (Δ–Ψ) for modelling praxis, asymmetry, temporality, and self-binding.
While PMS provides the canonical operator grammar for analysing action and non-action, PMS–LOGIC reconstructs a classical philosophical tension as a strictly praxeological configuration:
- the Is–Ought boundary (Hume),
- the intuition that effective capacity entails responsibility,
- and the question why moral language reappears without moral laws, duties, or metaphysical grounding.
Building explicitly on PMS as its structural foundation, this project does not modify or extend the PMS operator set, but uses it strictly as specified to show:
- why logic is indispensable yet reaches a structural boundary at Non-Closure (Λ),
- why “coherence” must not become closure-authority (Σ-totalization risk),
- why responsibility arises post hoc as attributability of consequences under asymmetry (Ω) and irreversibility (Θ),
- why omission and “nothing happened” remain structurally consequential via Λ carried,
- and why “norm-like” statements in practice are best reconstructed as failure-mode constraints (Χ/Ψ restraint), not as “ought.”
In this sense, PMS–LOGIC should be read as:
- conceptually dependent on PMS,
- formally consistent with the PMS operator grammar, and
- focused on structural legibility rather than moral or psychological evaluation.
PMS–LOGIC is:
-
A praxeological reconstruction of responsibility (no prescriptive ethics)
-
A PMS_1.1–conform application of the operator set (Δ–Ψ)
-
A framework for analysing:
- the tripartition pre-moral / logical / post-moral as reduced operator signatures
- non-closure (Λ) as a structural boundary of explanation (not a defect)
- responsibility as attributability (Ω/Θ/Λ/Ψ), distinct from blame or duty
- predictable drift forms: Σ-totalization, Ω→authority capture, pseudo-ought injection, Λ-suppression, □-overconstraint
- “apparent norms” as structural failure-mode constraints (self-binding and restraint), not as prescriptions
-
A bridge between:
- philosophy of action
- meta-ethics (without ethics construction)
- systems thinking
- PMS-based formal modelling (operator-readable annotations)
Guiding formula:
Pre-moral in justification /
Logical in boundary management /
Post-moral in effect
PMS–LOGIC is not:
- An ethical theory
- A moral code or value system
- A theory of duties, virtues, or rights
- A psychological, motivational, or clinical model
- A framework for judging persons
- A system for moral ranking, sanctioning, or legitimacy attribution
No PMS operator generates an “ought.”
No norm is derived, hidden, or implied.
PMS–LOGIC preserves Hume fully:
- No “ought” follows from “is.”
Yet it also shows a structural remainder:
- No irreversible praxis remains innocent (non-innocence is structural, not moral).
Responsibility arises structurally, not normatively, when:
- Asymmetry (Ω) makes effects uneven,
- Temporality (Θ) makes effects irreversible,
- Non-event (Λ) makes omission consequential,
- Self-binding (Ψ) keeps consequences attributable across time.
What appears as morality is therefore not law or command, but the
readability of consequences after the fact.
Responsibility is not commanded.
It is what remains.
PMS–LOGIC is built directly on the canonical PMS operator grammar (Δ–Ψ) as defined in
PMS.yaml
(schema_version: PMS_1.1).
- No new operators are introduced
- No operator is redefined
- All dependency rules are respected
- All claims remain scene-bound, reversible, and non-diagnostic
- Moral phenomena are treated as derived interpretive effects, not primitives
Where PMS provides the grammar of praxis, PMS–LOGIC specifies how that grammar behaves when applied to:
- non-closure and the limits of explanation (Λ under □),
- power and exposure gradients (Ω),
- irreversibility and trajectory costs (Θ),
- omission as consequential structure (Λ),
- and consequence attribution stabilized via self-binding (Ψ).
PMS.yaml gives you the canonical operator system (Δ–Ψ), dependency hygiene, derived axes (where present), and general governance constraints for structural (non-psychological) reading.
pms-logic.yaml adds a domain-specific application profile for logic / responsibility / post-moral readability that makes several things explicitly computable / recordable / comparable across cases and analysts:
PMS–LOGIC defines three explicit level markers:
- PRE_MORAL_justification = Δ + ∇ + □ + Λ + Α
- LOGIC_boundary_management = □ + Λ + Χ + Σ
- POST_MORAL_effects = Ω + Θ + Ψ
With PMS alone, you can describe these chains; with PMS–LOGIC you can treat them as named reference checkpoints (not proof chains) across tooling, cases, and papers.
PMS–LOGIC defines a minimal readability marker:
- MORAL_READABILITY_min = Ω + Θ + Λ + Ψ
This keeps “morality” out of the operator set while making its emergence structurally legible (post hoc, under asymmetry and irreversibility).
PMS–LOGIC encodes an explicit constraint:
- POTENTIAL_effective = □ + Θ
Responsibility presupposes effective, frame-bound capacity with temporal availability. Abstract possibility does not generate responsibility.
PMS–LOGIC formalizes structural failure modes as a drift catalogue, e.g.:
- dogmatism_sigma_totalization (Σ becomes closure-authority; Λ denied)
- authority_capture_omega_inflation (Ω becomes justificatory authority; Χ suppressed)
- moralism_pseudo_ought_injection (responsibility → obligation; Ψ externalized into enforcement)
- nihilism_lambda_suppression (Λ erased; omissions treated as irrelevant)
- technocratic_reduction_frame_overconstraint (□ treated as exhaustive; remainder dismissed)
With PMS alone, you can describe these patterns; PMS–LOGIC makes them named, repeatable descriptors for consistent annotation and comparison.
PMS–LOGIC adds a constraint layer that treats norm-like statements as structural stabilizers (self-binding and restraint), not moral imperatives (no “ought”).
Examples (as constraints, not commands):
- “Do not force closure where Λ persists.”
- “Do not confuse explanatory power with sense-making authority.”
- “Bind yourself to restraint rather than assertion.”
PMS–LOGIC includes scale matrices that project the lens onto derived axes (A, C, R, E, D) as a compact comparative summary:
- high awareness/coherence/responsibility emphasis,
- action deliberately constrained by Χ/Σ discipline,
- dignity-in-practice stabilized under Ω/Ψ/Χ.
PMS–LOGIC explicitly anticipates common misreadings (e.g., “ethics in disguise,” “relativism,” “nihilism,” “theology,” “unfair responsibility”) and provides structural responses that keep the profile inside PMS guardrails.
PMS–LOGIC provides a uniform, scene-bound schema so examples remain:
- operator-readable,
- reversible,
- non-moral,
- non-diagnostic.
In short:
PMS is the operator grammar.
PMS–LOGIC is the logic profile: tripartition + boundaries + drift + constraints + axes projection + case schema.
This repository includes pms-logic.yaml as an addon specification:
-
It DEPENDS on PMS_1.1 and references Δ–Ψ strictly.
-
It defines reduced signatures, drift catalogue, failure-mode constraints, scale matrices, counter-readings, glossary, and example-suite schema.
-
It explicitly separates:
- operator grammar (PMS)
- from application profile (PMS–LOGIC)
scene_label: "Example: policy decision under deep uncertainty"
frame_anchor (□): "government response planning under incomplete data"
structural_trigger (Δ): "mismatch between stakes and available justification"
non_closure (Λ): "irreducible remainder: what cannot be known or settled"
operator_signature: ["□","Δ","Λ","Θ","Ω","Σ","Χ","Ψ"] # reduced signature, not proof
tripartition_tag: "logical_boundary_management"
guardrail_gate: "Χ + reversibility + D"
structural_closure: >
Non-closure persists within the frame and cannot be eliminated without substitution.
Integration coordinates options, but distance prevents closure-authority.
Responsibility remains capacity-bounded and attributable under asymmetry and time.
drift_markers: ["dogmatism_sigma_totalization","technocratic_reduction_frame_overconstraint"]
failure_mode_constraint_refs: ["FMC2","FMC3"]This packet format is optional, but it is designed to make case mappings uniform, reversible, and non-ought.
Alongside the YAML, this repo also contains (or is meant to contain) a human-readable model specification (HTML/PDF) that:
- explains the YAML structure in technical prose,
- makes the tripartition, drift catalogue, and constraint layer legible,
- and clarifies guardrails and non-goals.
Intended reading order:
- PMS base grammar (PMS.yaml)
- pms-logic.yaml (tripartition + drift + constraints + axes projection + case schema)
- Paper text (PMS–LOGIC)
- Example Suite (stress tests)
The repository includes a dedicated Example Suite (/examples) consisting of five structurally uniform case mappings.
These examples are not illustrations, prescriptions, or moral verdicts. They function as operator-legible scene packets that stress-test PMS–LOGIC under load:
- capacity-bounded responsibility (effective, frame-bound capacity rather than abstract possibility),
- Λ carried (non-closure as a structural remainder rather than a defect),
- post-moral readability (attributability under Ω/Θ/Λ/Ψ without prescriptive “ought”),
- and typical failure modes (Σ-totalization, Ω→authority capture, Λ-suppression, pseudo-ought injection).
Included examples:
- Disaster triage (scarcity, allocation, irreducible remainder)
- Whistleblowing (informational capacity, omission, institutional risk)
- Policy under deep uncertainty (non-closure under decision pressure)
- Platform moderation (metrics as authority, opacity as Λ)
- Family care asymmetry (trajectory responsibility without implicit duty)
PMS-LOGIC/
├── README.md
├── LICENSE
├── PMS-LOGIC.md
├── PMS-LOGIC.html
├── PMS-LOGIC.pdf
├── model/
│ ├── Model Specification - PMS-LOGIC.html
│ ├── Model Specification - PMS-LOGIC.pdf
│ └── PMS-LOGIC.yaml
├── css/
│ └── main.css
└── examples/
├── Example 1 - Disaster Triage Without a Moral Code.md
├── Example 1 - Disaster Triage Without a Moral Code.html
├── Example 2 - The Whistleblower Case.md
├── Example 2 - The Whistleblower Case.html
├── Example 3 - Policy Under Deep Uncertainty.md
├── Example 3 - Policy Under Deep Uncertainty.html
├── Example 4 - Platform Moderation.md
├── Example 4 - Platform Moderation.html
├── Example 5 - Family Care Asymmetry.md
└── Example 5 - Family Care Asymmetry.html
The canonical source of the paper remains the Markdown file.
- pms-logic.yaml is the canonical machine-readable addon/profile.
- pms-logic-ext.yaml is optional and reserved for future paper-specific macro additions (non-overriding; non-operators only).
Logic is indispensable for differentiation and integration, but reaches a structural boundary at Non-Closure (Λ).
Forcing closure produces dogma. Carrying non-closure produces stability.
Responsibility is reconstructed as attributability of consequences, not obedience to rules.
The everyday trope “potential obligates” is rewritten as:
Potential removes innocence — not freedom.
(Responsibility is capacity-bounded: effective capacity within □ across Θ.)
Morality is neither objective law nor subjective projection, but an interpretive field that appears once praxis becomes:
- asymmetric,
- irreversible,
- incomplete,
- and self-bound.
What look like “commandments” are shown to be self-binding stability constraints — not moral imperatives.
This repository contains:
-
The PMS–LOGIC paper (Markdown / PDF / HTML)
-
The PMS–LOGIC addon YAML (pms-logic.yaml)
-
A human-readable Model Specification (HTML/PDF)
-
Worked examples intended as structural test vectors
-
Materials intended for:
- philosophy
- systems theory
- AI governance
- structural action theory
It complements — but does not replace — the canonical PMS repository.
PMS–LOGIC is intended for:
- Philosophers working on meta-ethics, responsibility, action theory
- Researchers applying PMS beyond technical or computational domains
- Structural theorists interested in non-normative ethics
- AI / governance researchers exploring responsibility without moral agents
It is not intended for coercive application, person-ranking, or prescriptive enforcement.
Any application must respect the PMS entry condition: Χ (distance) + reversibility + D (dignity-in-practice).
PMS-LOGIC is situated within a broader praxeological ecosystem that connects anthropological theory, formal operator models, applied analyses, and executable specifications.
| Category | Resource | Description |
|---|---|---|
| Model website | https://pms-theory.netlify.app | Canonical PMS theory reference |
| Book websites | https://maturity-in-practice.netlify.app | Maturity in Practice — English edition (praxeological anthropology) |
| https://reife-im-vollzug.netlify.app | Reife im Vollzug — Deutsche Ausgabe | |
| https://pms-stack.netlify.app | PMS-STACK reference architecture | |
| Amazon | https://www.amazon.com/dp/B0G4XBKNNR | Maturity in Practice: A Praxeological Anthropology — English edition |
| https://www.amazon.de/dp/B0G4SPBDQD | Reife im Vollzug: Eine praxeologische Anthropologie — Deutsche Ausgabe | |
| https://www.amazon.com/dp/B0G6G7V38P | PMS-STACK — A Praxeological Operating System Architecture | |
| GitHub (papers) | https://github.com/tz-dev/Praxeological-Meta-Structure-Theory | Canonical PMS grammar, theory & YAML definitions |
| https://github.com/tz-dev/Maturity-in-Practice | Book sources & applied praxeological anthropology | |
| https://github.com/tz-dev/PMS-QC | PMS-QC — Praxeological Meta-Structure for Quantum Computing | |
| https://github.com/tz-dev/PMS-LOGIC | PMS-LOGIC — Structural Responsibility, Logical Limits, and Post-Moral Effects | |
| https://github.com/tz-dev/PMS-ANTICIPATION | PMS-ANTICIPATION — Structural Conditions, Risks, and Viability of Anticipatory Praxis | |
| https://github.com/tz-dev/PMS-CRITIQUE | PMS-CRITIQUE — From Irritation to Correction: A Praxeological Grammar of Critique | |
| https://github.com/tz-dev/PMS-EDEN | PMS-EDEN — Structural Drift from Praxis to Comparison and Reciprocity Loss | |
| https://github.com/tz-dev/PMS-SEX | PMS-SEX — From Impulse to Self-Binding: A Praxeological Grammar of Sexuality | |
| https://github.com/tz-dev/PMS-CONFLICT | PMS-CONFLICT — Conflict as Stabilized Incompatibility: Cost, Binding, and Tragic Non-Integration | |
| Custom GPTs | https://chatgpt.com/g/g-69358a2a4980819183da6a97893389cf-pms-model-assistant | Interactive PMS.yaml exploration & validation |
| https://chat.openai.com/g/g-693460d3def48191ad08647301645a2e-maturity-in-action-a-praxeological-anthropology | Applied praxeological anthropology assistant |
When referencing PMS–LOGIC, please cite both the paper and PMS:
PMS–LOGIC
T. Zöller (2026): PMS–LOGIC — Structural Responsibility, Logical Limits, and Post-Moral Effects.
PMS Framework
T. Zöller (2025): Towards a Praxeological Meta-Structure Theory.
Contributions, critiques, and structural questions are welcome. Please open an issue or submit a pull request.
Contributions are especially welcome for:
- additional example packets that follow the schema and guardrails,
- clarifications to drift signatures (operator-readable, non-moral),
- improvements to interoperability notes (tooling adapters, schema alignment),
- documentation improvements that strengthen reversibility and dignity-in-practice,
- parsers/validators that consume PMS.yaml + pms-logic.yaml without reimplementing operators.
Contributions are out of scope if they:
- introduce new operators,
- redefine PMS operator dependencies,
- add person-typing, motive attribution, or diagnostic language,
- turn drift labels into enforcement or sanction mechanisms,
- translate responsibility into “ought” as if licensed by the model.
- The paper is released under CC BY 4.0.
If the repository contains additional artifacts (YAML, HTML/PDF model specs, examples), their licensing follows the repository’s LICENSE file unless explicitly stated otherwise per artifact.
The name PMS-LOGIC reflects the central thesis of the work — that logic is a beginning, not an end — and is dedicated to Leonard Nimoy.
PMS–LOGIC does not tell you what you ought to do.
It explains why, once something is done — or left undone — it cannot be made morally irrelevant again.
That remainder is not ethics by decree.
It is ethics by consequence.
Maintained by tz-dev. For discussions or questions, please use GitHub issues.