# representational reasoning

about reduction of representational complexity in documentation, modeling, problem-solving, and implementation.

simplicity arises from choosing forms that fit their domain. design and simplicity converge when representation matches function.

## subtopics
* [standards and units](simplicity/standards-and-units.html)
* [simplification principles for programming](simplicity/programming.html)
* [documentation templates](simplicity/documentation.html)

## general rules
* ascii only
* lowercase letters only
* even if it is not perfect, prepare it to become so
* remove nonessential parts
* avoid redundancy
* avoid excess abstraction
* make economic use of dimensions carrying information

writing style
* one idea per sentence
* only svo sentences
* no nested clauses
* avoid synonyms and idioms
* prefer declaratives or process actives
* no numbering or other order demarcation of headings. it just makes modification difficult

inquiry
* "what is x always"
* "are there shared fundamentals between these two families that could improve either"
* "does this application or usage expose flaws in the generality or orthogonality"

## algorithmic identity encoding
### what it means to encode identity
an encoding of algorithmic identity provides a language-independent description of a method. sufficient to distinguish algorithmic families such as quicksort versus mergesort.
it abstracts from machine details and retains only defining structure, recurrence, or partitioning.

good encodings are judged by:
* clarity of essential steps
* omission of incidental implementation detail

### variable elements and abstraction
* represent domains abstractly when only their properties matter.
* a concrete representation is needed only if the algorithm depends on those specifics.
* example: quicksort requires a total order but not the bit width of elements.
* if overflow or rounding affects correctness, drop the abstraction and specify concretely.
* the principle is to keep abstraction at the level of properties essential to identity, refining only when representation influences correctness.

### semantic styles
* operational semantics: state transitions, imperative pseudocode, abstract state machines
* denotational semantics: input - output mappings, recurrences, set-theoretic relations
* algebraic semantics: equations and laws, algebraic specifications, horn clauses

### refinement principle
* begin from a high-level specification that defines identity, e.g. "permutation and sortedness."
* refine stepwise into a partition-based recurrence, then pseudocode, then machine code.
* each refinement preserves correctness; the refined form implies the original.

### encodings of identity
* natural language description
* functions (functional form as canonical)
* imperative pseudocode
* mathematical recurrence equations
* horn clauses / logic programming
* algebraic specifications (equational logic)
* set-theoretic relations (input/output and invariants)
* category-theoretic combinators (folds, catamorphisms)
* abstract state machines
* type-theoretic or refinement-type specifications
* flowcharts or control-flow graphs
* state-machine morphisms (mealy or moore; specific reactive subclass)

## reasoning protocols
### primary vectorization
* identify orthogonal primary variables {v₁, …, vₙ} spanning the conceptual space.
* for each variable, define orthogonal subvariables to refine coverage.
* incomplete vectors reveal missing dimensions; formulate questions that resolve them.

### minimum-questions protocol
find the smallest high-leverage fact set that yields broad understanding.
use a "20-questions" framing: each question carves the search space, reduces ambiguity, and links categories.

### triplet completion
recognize that there can exist triplets where any two elements determine the third.

this structure:
* guarantees completeness as any two imply a unique third
* enables inversion-based reasoning: reverse execution, synthesis, recovery
* supports bidirectionality by swapping knowns and unknowns symmetrically
* detects underdetermination early, single known yields multiple completions
* supports automation as one relation serves multiple tasks by permutation
* examples:
  * (query, dataset) -> result
  * (initial, rules) -> final
  * (program, input) -> output

### rationale optimization
* evaluate options against objectives, constraints, and trade-offs.
* choose optimal paths

### representation aids
* create tuples of variables to map conceptual space.
* build word clusters, idea lists, vocabulary and keyword sets, and use cleverly chosen group headings to form categories.