Part A - Choose and relate constructions
MATH.16 - Choose a Mathematical Construction from Its Required Maps (Universal Property)
Type: Method Status: Stable Normativity: Normative
MATH.16:1 - Problem frame
Use this pattern when you need a mathematical object but have not decided how to construct it. You can describe what should be recoverable from it, what data should determine it, or which functions it must support. The difficulty is choosing among constructions that can all look plausible while supporting different uses.
For example, a result may need to carry two answers together, carry either kind of answer, or combine answers that agree about a shared quantity. These requests lead to different mathematical objects. Choosing a familiar representation first can hide the difference until a later operation fails.
Start by naming one operation the new object must support and the information that should determine its result. Draw the corresponding functions, including their directions. A useful first result is a requirement that distinguishes two candidate constructions. Continue to a construction and its use when the question needs them.
The method develops a universal property: a specification of an object through the maps it must admit and the equations those maps satisfy. The main route uses sets and all functions between them. The reader needs elementary sets, function composition and equality; the remainder example also explains the modular arithmetic it uses. Paragraphs marked Additional structure are optional and assume knowledge of the named mathematical theory.
If an available object and operation already answer the question, use them. A universal specification becomes useful when choosing, explaining, comparing or changing the construction is part of the work. Establishing the property for every allowed input needs an argument; working a few examples can expose a failure but cannot establish that general claim.
MATH.16:2 - Problem
A familiar notation can suggest an object without explaining why it has the right structure. A pair of entries, a sequence, an equivalence class and a tagged alternative may all hold related information, yet the operations available on them differ.
Even an apparently adequate requirement can leave the object underdetermined. An object from which two entries can be recovered might also contain an extra entry. To say that the first two entries determine the whole, we need a further condition. Without it, a later map may require information that the proposed construction never supplied.
The problem is to turn the intended use into a mathematical specification, construct an object that satisfies it, and derive the maps and comparisons needed next.
MATH.16:3 - Forces
| Force | Tension |
|---|---|
| Familiar representation and needed operations | A convenient notation can make calculation easy while omitting a required construction or recovery. |
| Recoverable data and additional choice | Recovering the inputs leaves open whether they determine the complete result. |
| General specification and existence | A universal property can identify the desired object even when it has no realization in the chosen setting. |
| Structural sameness and computational effort | Two constructions can support the same maps while requiring different work to calculate with them. |
MATH.16:4 - Solution
Local mantra: start from the use; choose maps and laws; construct the object; derive its uses; revise the changed requirement.
MATH.16:4.1 - Express the needed use as maps and equations
Describe what a user of the mathematical object will put in and obtain. Introduce symbols after those meanings are clear. A function f:X -> A takes an input in X and returns one element of A. Its direction matters: receiving an A and returning an X is another operation.
Ask what information completely determines the proposed result. If later use needs an extra choice, include that choice in the input. If the supplied data should suffice, require the resulting map to be unique.
These examples show how the required use determines which maps to seek.
| Needed use | Maps and question to formulate |
|---|---|
| Carry two components together and recover each one. | Seek maps from the new object to both component objects. What combined map is determined by supplying the two components? |
| Carry either kind of input, then process it according to that kind. | Seek maps from each input object into the new object. Do the two processing rules determine one rule on the combined object? |
| Combine components that must agree about a common quantity. | Express both accounts of that quantity in one codomain and require equality. |
| Identify inputs while retaining selected answers. | Which maps give the same answer on identified inputs, and therefore can operate on classes? MATH.2 supplies that quotient construction. |
| Interpret everything built from generating operations. | Which assignment to generators extends to a map preserving the operations? MATH.5 supplies the extension and its uniqueness. |
Choose the mathematical setting along with the maps. In the main route, the objects are sets and the permitted maps are all functions between them. A category specifies a setting through its objects, maps, identity maps and associative composition.
Additional structure – groups and topology. For groups, choose homomorphisms preserving the group operation; for topological spaces, choose continuous functions. These choices change what must be constructed and proved.
MATH.16:4.2 - State the universal property before choosing an encoding
Turn the use into a requirement by comparing the proposed object with arbitrary permitted ways of supplying or processing its data:
- Fix the objects already given by the question, together with their maps and laws. They remain the same throughout this comparison.
- Introduce a variable object X for a possible source of data, or Z for a possible destination. Describe the maps and equations that make it an allowed instance of the needed use. Consider every permitted instance. For example, a source of two components supplies functions from X to each fixed component set.
- Seek an object P with the maps through which it will be used. Ask how an allowed instance should relate to P: should its data assemble into P, or should processing extend from P to a destination? Draw that comparison map in the corresponding direction.
- Combine the comparison map with P’s use maps in the order their domains require, and equate the resulting routes with the original maps. Require a comparison map for every allowed instance, and uniqueness when the supplied data should determine it completely.
This specifies the behavior a construction must realize. If the intended use leaves the maps or agreements undecided, return to that choice before asking for a universal object. The prepared-function case in :5.4 follows these steps for a use beyond pairing or tagging.
Suppose the question requires two recoverable components in A and B, and those components must determine the entire result. A and B are fixed; a trial source X supplies maps to both. Seek an object P with projections pA:P -> A and pB:P -> B.
For every allowed object X and maps f:X -> A, g:X -> B, require a unique map <f,g>:X -> P such that:
pA composed with <f,g> = f;
pB composed with <f,g> = g.
These equations say that forming the combined result and reading either component returns the supplied component. Uniqueness says there is no further choice in that combination. Any map h:X -> P is consequently recovered from its components:
<pA composed with h, pB composed with h> = h.
An object with these projections and property is a product of A and B. Its specification describes both how to construct a result and how to use it.
Now suppose the components must agree through maps s:A -> C and t:B -> C. Seek projections that satisfy:
s composed with pA = t composed with pB.
Require a unique combined map only for f and g satisfying s composed with f = t composed with g. This is a pullback of s and t: it combines precisely the data compatible under that equation.
To choose an object for either kind of input, reverse the mapping question. Seek maps iA:A -> S and iB:B -> S that place the inputs in the new object. For maps f:A -> Z and g:B -> Z, require a unique map [f,g]:S -> Z with [f,g] composed with iA = f and [f,g] composed with iB = g. This is a coproduct. In sets, a tag can preserve which input was supplied, so the processing rule can select the correct branch.
The comparison points into the product or pullback and out of the coproduct. Its direction follows the needed operation: assemble supplied components or extend supplied processing rules.
MATH.16:4.3 - Construct an object and establish the property
In sets, the product is the set of ordered pairs A x B. Use the coordinate projections and define <f,g>(x)=(f(x),g(x)). Both projection equations follow by reading the corresponding coordinate. Any function with those projections must return that same pair at every x, which proves uniqueness.
For the pullback, form the subset:
Q={(a,b) in A x B | s(a)=t(b)}.
The same pairing formula lands in Q exactly when the compatibility equation holds. Reading the coordinates again proves uniqueness. If no pair meets the compatibility requirement, Q is empty and is still a valid pullback in sets.
For a coproduct of sets, distinguish the two input branches with tags 0 and 1:
S=({0} x A) union ({1} x B).
The injections are iA(a)=(0,a) and iB(b)=(1,b). Define [f,g](0,a)=f(a) and [f,g](1,b)=g(b). Every element has one of these forms, which establishes existence and forces the rule uniquely. Even when A and B are the same set, the tags keep the two branches distinct. For A=B={0}, handlers f(0)=0 and g(0)=1 therefore extend to a function taking (0,0) to 0 and (1,0) to 1.
Additional structure – groups and topology. Establish that the object and maps have the chosen structure. For groups, define product multiplication componentwise. If f and g preserve multiplication, then their paired map does too, because each coordinate does. For a pullback of group homomorphisms, the compatibility equation is preserved by multiplication and inverses. A construction with continuous maps requires the appropriate topology and continuity arguments.
Use a known applicable construction when available. For quotient and generator questions, MATH.2 and MATH.5 provide the detailed operations. If the required object cannot yet be constructed, identify the unresolved existence or construction question. An existence theorem may supply a result for reasoning while leaving an effective way to obtain its elements for further work.
MATH.16:4.4 - Derive the next map, comparison or operation
Use the universal property to build the map the question needs. For a product, give the two component maps. For a pullback, also establish their agreement in C. For a coproduct, give a processing rule for each input kind.
The property also supplies equality tests. Two maps into a product or pullback are equal when both their projections agree. Two maps out of a coproduct are equal when composing each with iA gives equal maps and composing each with iB gives equal maps. This lets you compare an entire map through its required parts.
It can compare different constructions of the same object. If P and P’ satisfy the same product property for A and B, the projections of each determine a map to the other. Composing these maps preserves both projections. The identity does too, so uniqueness makes the composites identities. Thus the two constructions are isomorphic by the maps that preserve their projections. MATH.7 develops the transport of further structure when a usable bijection has been obtained.
A new operation on the components needs a compatibility test. Here take Q to be the pullback of sets and u:A -> A, v:B -> B to be functions proposing updates. They induce a function (a,b) -> (u(a),v(b)) on Q exactly when:
s(u(a))=t(v(b)) whenever s(a)=t(b).
The original agreement does not settle the changed one. A failed pair identifies which update or agreement condition must change. This gives a way to work on operations themselves while keeping their required uses visible.
Additional structure – groups. When the update must also be a homomorphism, establish preservation of the group operation. Agreement of the updated components alone establishes only a function on the set of compatible pairs.
MATH.16:4.5 - Use the result and return to a changed requirement
Return the construction with the maps and conditions needed by its consumer. A name such as “product” helps recognition; the projections, formation rule and applicable laws let the receiver use it.
For a mathematical question, stop with the required map, equality, usable construction or demonstrated obstruction. For computation, obtain the procedure and resources needed for the chosen representation through C.29.2. A finite pullback can be enumerated by testing pairs, while a large or infinite one needs an appropriate computational method.
For an application to another subject, C.29 supplies the correspondence that gives the mathematical objects and equations their subject meaning. A compatibility equation must represent the agreement the work requires. A pairing of functions on one input describes a different operation from two executions that modify a shared input. For the latter use, first specify which values each step reads and changes, and which intervening steps are permitted. Use that account to decide whether a function construction represents the work; the pairing alone leaves those interactions unspecified.
When the question changes, return to the affected mapping requirement. Adding agreement can turn a product question into a pullback question. Needing to accept either input can call for a coproduct. Needing only selected answers can call for a quotient. Retain the earlier construction while it still serves its question.
MATH.16:5 - Archetypal Grounding
MATH.16:5.1 - Two classifications, then one shared integer
Two separately chosen integers have been classified. The first report gives its remainder modulo 2; the second gives its remainder modulo 4. The task is to combine the reports so that both can be recovered, and to add combined reports by adding their corresponding remainders. The two reports should determine the complete combined result.
Let A={0,1}, with addition reduced modulo 2, and B={0,1,2,3}, with addition reduced modulo 4. Adding the two reported numbers into one number loses recovery: reports (0,1) and (1,0) both give 1. Keeping a pair supplies both projections and requires no additional choice. All eight pairs are possible because the original integers may be chosen separately.
Now both reports must describe the same integer. The pair (0,1) fails: an integer with remainder 1 modulo 4 is odd. The modulo-4 report determines parity through t(b)=b modulo 2. Set s to the identity on A and construct the compatible pairs:
Q={(0,0),(1,1),(0,2),(1,3)}.
Every member comes from an integer. Addition stays within Q: (1,1)+(1,3)=(0,0). A report determines the original integer only modulo 4.
Additional structure – groups. With the stated modular additions, A and B are groups. The identity on A and the parity map t preserve addition, so Q with componentwise addition is also their pullback in groups.
The projection (a,b) -> b has inverse b -> (t(b),b). If the next calculation is easier with one modulo-4 value, MATH.7 transports it through these maps. If the next question is which integers may be identified while retaining both reports, MATH.2 instead constructs their quotient modulo 4.
Returning to functions on the underlying sets, a proposed update exposes another choice. Incrementing the modulo-4 component alone sends (0,0) to (0,1), outside Q. Incrementing both components gives (1,1) and preserves agreement for every pair in Q. The intended change to the underlying integer determines which component updates belong together.
Additional structure – groups. The joint increment is not a homomorphism: it takes the identity (0,0) to (1,1). It is suitable for updating the represented integer, but fails a requirement to preserve the group operation.
MATH.16:5.2 - Process both results or either result
One calculation returns an integer count; another returns a text label. A report containing both results needs a product. Its projections recover the count and the label, and the two values determine the report.
A different interface accepts either an integer count or a text label. It must display a count numerically and leave a text label as supplied. A tagged union, the coproduct of these sets, allows both handlers to determine one display function. An input tagged as a count follows the numeric handler; a text-tagged input follows the text handler.
The word “combine” did not decide which object to build. The question about formation and use did: recover two components from one report, or process either input through its own rule. These constructions describe values and functions. Whether executing the calculations reads or changes shared state is a further question about their execution.
MATH.16:5.3 - Two views of one quantity
A model has candidate states A and B for two component descriptions. Each description specifies the value of a shared quantity in C. For example, the two ends of an ideal connection may be required to have equal potential.
The product contains arbitrary state pairs. Requiring agreement selects the pullback of the two quantity maps. Its projections retain both component states, so a later calculation can still use their other quantities.
The physical account must justify the ideal connection and the meaning of that potential. If the connection has a relevant drop, the equality premise changes. A relation involving the drop and other quantities must be modeled before constructing its compatible states. Use the justified physical relation to construct the compatible states.
MATH.16:5.4 - Construct an object that can itself be applied
A function can be prepared by supplying a setting, then used with different inputs. We want a mathematical object representing the prepared function. Fix the input set A and output set B. A possible set of settings X supplies behavior eX:X x A -> B: it returns an output for a setting x and input a. Different X and eX describe different ways to prepare such behavior.
Seek a set E of prepared functions and an evaluation rule ev:E x A -> B for applying them. Preparing from a setting should give a map h:X -> E. To retain the original behavior, require:
ev(h(x),a)=eX(x,a) for every x and a.
Here prepared functions are equal when they give the same answer for every input. Thus the behavior specified by eX should determine h completely. Require a unique such h for every X and eX.
Construct E=B^A, the set of all functions from A to B. Define ev(k,a)=k(a), and let h(x) be the function sending a to eX(x,a). The required equation follows by evaluation. Any other proposed value for h(x) must give that same answer at every a, so it is the same function. This proves uniqueness.
For example, take A, B and X to be the integers and eX(n,a)=n+a. Then h(3) is the function that adds 3; ev(h(3),6)=9. The construction allows us to pass, apply and compare that function as an object. The conversion from a two-input function to a function returning a function is called currying. Distinguishing procedures with the same answers but different costs requires a further computational description of those procedures.
MATH.16:6 - Bias-Annotation
Recognizing a familiar construction can make its requirements seem inevitable. In :5.2 the same informal request to combine results leads to a product or a coproduct depending on the needed operation. Write that operation before naming the construction.
The set examples make existence easy to see. Other choices of objects and allowed maps can change existence or require additional structure. Carry that choice into the argument rather than relying on the appearance of paired entries.
MATH.16:7 - Conformance Checklist
- The working question identifies what must be formed, recovered or compared.
- Each map has a domain, codomain and meaning; its direction matches the required operation.
- The permitted maps and their preservation conditions are stated.
- Fixed objects are separated from the allowed varying instances of use.
- The universal property identifies the supplied data, the comparison map for every allowed instance, its equations and why uniqueness is wanted.
- A construction or applicable existence result supplies the object; a claimed construction has its existence and uniqueness arguments.
- A changed requirement is reflected in the construction or its admissible maps.
- Any computational or subject use obtains the additional operations and premises it needs.
MATH.16:8 - Common Anti-Patterns and How to Avoid Them
Recovery mistaken for full determination. Take A=B={0}. Recovering both components from A x B x {0,1} works, but forming an element also requires choosing 0 or 1. If only A and B should determine the result, require the unique combining map. If the extra choice is useful, name it as part of the input.
Compatible components processed incompatibly. A map on each component need not preserve their agreement. Test the equation in :4.4; the one-component increment in :5.1 supplies a failing case and its repair.
A familiar encoding chosen before its use. A pair and a tagged alternative support different functions. Recover the intended formation and processing operations before selecting either.
MATH.16:9 - Consequences
The result can be specified and compared through its permitted uses. Construction, extraction and equality arguments become connected, and a changed requirement identifies which mathematical work must be revisited.
The universal property leaves room for different implementations. Their mathematical correspondence can be established through the property, while their computational costs remain a separate reason for choosing one implementation.
MATH.16:10 - Architectural Rationale
Organizing the choice around maps makes the required operations explicit before committing to an encoding. Including uniqueness expresses when the supplied data determine the whole result. It also gives reusable arguments for comparing maps and comparing realizations.
A direct representation remains economical for a single familiar calculation. The universal-property method earns its additional abstraction when several constructions are plausible, a representation must be changed, or later maps and arguments need to be derived. The product, pullback and coproduct cases expose different requirements. The prepared-function case shows how to formulate another requirement by varying its settings and behavior while keeping the input and output sets fixed.
Detailed quotient, generator-extension and structure-transport methods remain separately usable. They supply constructions and proofs after this method has identified the needed property.
MATH.16:11 - SoTA-Echoing
For choosing an object through the maps it must support, the adopted line is universal construction in category theory. Riehl’s Category Theory in Context, §§2.3, 3.1 and 3.2, gives the general account and concrete set constructions. The present method uses that line to move from a working requirement to a construction, then to its derived maps and equality arguments.
Fong and Spivak’s Seven Sketches in Compositionality, especially the chapter on databases and categories, develops the use of these constructions across applications. Its contribution here is the attention to what transformations and queries the constructed object supports. Example 3.72 supplies the function-as-object construction through currying used in :5.4.
At comparable effort, a direct pair or tagged union is often enough when the operation is already settled. Use the universal account when the ambiguity or later reasoning makes it useful.
The elementary examples use ordinary equality and functions. If the work changes the permitted maps or the meaning of equality, reformulate the comparison and its equations in that setting. A requirement to compute the result can also reopen the choice of construction.
MATH.16:12 - Relations
- MATH.1 constructs composable paths when the required object retains generating steps and their order.
- MATH.2 constructs quotients while preserving the selected operations and answers.
- MATH.5 extends generator assignments to operation-preserving maps and proves their uniqueness.
- MATH.7 transports structure through a bijection when a different representation is useful.
- B.5.FM and B.5.TU connect the working question, construction and use at the common reasoning level.
- C.29 and C.29.2 supply subject correspondence and computational formulation.
MATH.16:End
MATH.17 - Construct Mathematical Spaces of Operations and Operations on Them
Type: Method Status: Stable Normativity: Normative
MATH.17:1 - Problem frame
Use this pattern when the rule for constructing or transforming something has itself become the object of work. You may need to combine allowable rules, apply a rule to a different kind of input, compare ways of repeating it, or change the rule while retaining a useful property. Knowing how to execute each individual rule leaves these questions open.
Start with the operation you want to perform on rules and the consequence you need from it. For example: “Can these permitted updates be composed?” or “Can I transform each stage separately and obtain the same result as transforming their composite?” One constructed operation, together with its applicability and the law or counterexample that answers that question, is a useful result.
Here a space of operations is a specified collection of operations with the equality, composition and further structure needed by the question. The main route uses sets and functions; it requires understanding function application, composition, sets and elementary equality arguments. MATH.16 explains functions as mathematical objects, evaluation and currying. The polynomial example is an optional branch using polynomial arithmetic.
Use an existing rule directly when its application settles the question. Construct a space of operations when you need to reason about, generate or change rules. A topology, metric or order on that space becomes part of the construction when the question needs continuity, approximation or comparison in that sense.
MATH.17:2 - Problem
An operation can be permissible on its own yet leave the permitted class when combined with another. A transformation of operations can produce a valid operation yet alter the result of a sequence. These failures occur at different places: membership, composition, or the proposed transformation.
To locate the failure, specify the rule’s domain, construction and relevant laws. These supply the mathematical questions: which operations belong to the permitted collection, what can be done with them, and which conclusions follow?
MATH.17:3 - Forces
| Force | Tension |
|---|---|
| Individual applicability and composition | Two allowable operations can have a composite that violates the condition used to select them. |
| Useful abstraction and needed distinctions | Functions expose input-output behavior; questions about construction steps or cost need a representation retaining those distinctions. |
| Changing rules and retaining consequences | A higher-order operation may preserve some laws, replace others, or require a narrower domain. |
| Uniform construction and branch-specific structure | One construction can work across many sets, while continuity, differentiability or other additional requirements need their own arguments. |
MATH.17:4 - Solution
Local mantra: state the change to the rule; construct its admissible inputs; establish composition; construct the higher-order operation; derive its consequence; use or revise it.
MATH.17:4.1 - Specify the operations and the question about them
Name the inputs and outputs of an operation. Write f:A -> B when f assigns an element of B to every element of A. Write g∘f for “first f, then g”; this is a function on all of A if g is defined at every value f takes.
Choose what counts as equality for the present question. In the main function route, f and g are equal when they have the same domain and codomain and f(x)=g(x) for every input x. If the question concerns the steps used, resource cost or another distinction between ways of producing that function, retain a construction or program representation carrying that distinction. A function value alone leaves it unavailable. MATH.1 supplies constructions retaining ordered steps; MATH.2 handles an identification when the needed operations respect it.
Formulate the intended operation on rules. It might take two operations and compose them, send an operation on individual inputs to an operation on collections, or turn an expression for a function into another expression. State which result matters: admissibility, an identity, a comparison, a changed construction, or a failed requirement.
MATH.17:4.2 - Construct the admissible collections
For each relevant pair A, B, specify Adm(A,B), the collection of operations allowed from A to B. Give a condition that can be used to establish membership. Examples include preserving an order, maintaining a relation between components, or mapping a designated subset into itself.
When the operations are functions, MATH.16 supplies the function object and evaluation ev(f,x)=f(x). Restrict that object by the required condition. A rule with several inputs can be represented by a function on their product when a tuple contains all the inputs it needs.
For a partial operation, include its domain of definition. If f is defined on D within A and g on E within B, their composite is defined on {x in D | f(x) in E}. Whether this is an acceptable domain belongs to the current question.
Changing the admissibility condition changes the collection. An update preserving a set of possible states and a map preserving an algebraic operation answer different requirements. State the requirement before using either as an admissible rule.
MATH.17:4.3 - Establish the composition that the work needs
Try to construct:
Adm(B,C) x Adm(A,B) -> Adm(A,C), (g,f) -> g∘f.
The formula already defines a function composite. To obtain the displayed operation, establish that the composite satisfies the selected admissibility condition. Establish identity membership when doing nothing must be an allowable operation. Associativity then follows from function composition.
For example, fix a subset P of X and admit every f:X -> X with f(P) contained in P. If f and g are admitted and x lies in P, then f(x) lies in P and g(f(x)) lies in P. Thus their composite is admitted, as is the identity. These operations form a monoid: a set with associative composition and an identity. Several object types with identities and compatible associative composition form a category. These names make the established structure reusable.
If closure fails, use the failing input or pair to choose the repair. You might restrict the operations, enlarge the permitted result class, or keep a sequence of operations whose total admissibility is checked separately. For a cumulative resource bound, for example, retain the sequence and accumulated cost needed to assess the whole. Calling each step allowable leaves that total unresolved.
An interchange of steps is another claim. Establish g∘f=f∘g when a proposed reordering needs it; associativity by itself only changes the grouping of a fixed order.
MATH.17:4.4 - Construct an operation on operations and its law
Give the higher-order operation its own input and output types. For a transformation sending a function f to a new function T(f), start with an arbitrary input x of the desired new function. Express its required output using f and the available operations. That expression defines T(f)(x). Then establish that the constructed function belongs to the promised output collection.
Choose the law from the needed use. If T is meant to translate a sequence stage by stage, test:
T(g∘f)=T(g)∘T(f) and T(id)=id.
The types on both sides must agree. When T also changes the objects, specify that object assignment and the corresponding operation collections. An assignment preserving these compositions and identities is a functor.
For instance, we want to apply f:A -> B separately to each entry indexed by a fixed set I. Represent the input by s:I -> A; the set of such inputs is A^I. At index i the input is s(i), so the required output is f(s(i)). Collecting these outputs gives the function i -> f(s(i)) from I to B. We have constructed:
L_I(f):A^I -> B^I, defined by [L_I(f)(s)](i)=f(s(i)).
To derive the composition law, take arbitrary s and i:
[L_I(g∘f)(s)](i)=g(f(s(i)))=[(L_I(g)∘L_I(f))(s)](i).
Equality at every index proves the composition law. The identity law follows by applying the identity at every index. If admissibility requires each entry to remain in P, the earlier membership argument applies entry by entry. A condition relating different entries needs a further preservation argument.
A different higher-order operation can have a different useful law. Differentiation of polynomials preserves sums and scalar multiples and obeys the product and chain rules. Use those laws when deriving a derivative; a composition-preservation requirement would ask it to do a different job. The needed mathematical operation determines which laws to establish.
MATH.17:4.5 - Use the construction to change or compare rules
Compute the proposed changed operation and derive the consequence that motivated it. When comparing “transform each step” with “transform the whole”, keep both expressions until their equality is established or a separating input is found.
The result consists of the usable construction and the conditions supporting the consequence. For a finite example, a counterexample can settle a failed universal claim. A general preservation claim needs an argument over its stated inputs.
Return to the affected condition when the task changes. A new interaction between entries may invalidate pointwise lifting. A narrower resource budget may invalidate closure. A new question about how the operation was obtained may require retaining the construction that an input-output function discarded.
When this mathematics describes a working method, use C.29’s correspondence to identify what the mathematical operations represent and which practical distinctions they retain. A proposed program transformation also needs its execution semantics. Those connections let the result inform the work while keeping the mathematical and subject claims recoverable.
MATH.17:5 - Archetypal Grounding
MATH.17:5.1 - Individually permitted changes and a permitted whole
Let X={0,1} x {0,1}. An update is allowed to change at most one coordinate of each input pair. Flipping the first coordinate is allowed; flipping the second is allowed. Their composite sends (0,0) to (1,1) and changes two coordinates. The proposed collection is not closed under composition.
If the requirement limits each elementary step, keep a sequence of these steps and inspect intermediate states. If it limits the difference between initial and final states, test the composite against that bound and reject this pair. The same counterexample distinguishes the two intended uses.
Now take another requirement: the two coordinates must stay equal. Put P={(0,0),(1,1)} and admit functions sending P into P. The joint flip belongs; either single-coordinate flip fails. Closure follows from :4.3. This change of admissibility supplies a composable class suited to the equality requirement.
MATH.17:5.2 - Lift a rule, then change how repetition is distributed
Take integer operations f(n)=n+1 and g(n)=2n. Pointwise lifting to pairs is the case I={1,2}. Applied to (1,3), the lifted composite produces (4,8). Lifting f and g separately and then composing produces the same pair. The proof in :4.4 establishes that agreement for arbitrary inputs and functions.
Consider a different change: S(h)=h∘h, meaning repeat an operation twice. This always gives another integer endofunction, but the two sequencing proposals give:
S(g∘f)(n)=4n+6;
(S(g)∘S(f))(n)=4n+8.
At n=0 the answers are 6 and 8. To repeat the complete sequence, retain (g∘f)∘(g∘f). To run each stage twice, use g∘g∘f∘f. If f and g commute, rearrangement proves the two proposals equal; the present f and g do not.
The construction therefore returns both a valid operation on operations and a failed composition-preservation claim. That failure determines which changed rule implements the intended repetition.
MATH.17:5.3 - An operator whose useful law has another form
Let P=R[x], the real-coefficient polynomials in one variable, and define D:P -> P by differentiating each monomial: D(a*x^n)=n*a*x^(n-1) for n>0, and D(a)=0 for constants. This constructs an operation on functions through their polynomial expressions.
For p=x^2 and q=x+1:
D(p*q)=3*x^2+2*x.
The product of derivatives is D(p)*D(q)=2*x. The applicable law is instead:
D(p*q)=D(p)*q+p*D(q),
which gives the required result. To establish the law generally, first expand two monomials: differentiating a*b*x^(m+n) gives coefficient (m+n)*a*b, the sum of the two product-rule contributions. Distributing over the finite sums proves it for polynomials.
The same method of working is used as in :5.2: construct the operator, identify the law needed for the proposed use, and establish that law. Here it enables transforming a product expression into its derivative.
MATH.17:5.4 - Change a function while preserving its increments
Given a function f from the real numbers to the real numbers and a chosen point c, construct a function g that fixes c and preserves every increment of f. The requirements are g(c)=c and g(x)-g(y)=f(x)-f(y) for every x,y.
Set y=c in the second requirement. It forces g(x)=f(x)-f(c)+c. This defines a real-valued function; substituting c establishes the fixed point, and subtracting its values at x and y cancels the added constant and preserves the required increment. Thus the formula supplies the unique function under these requirements.
The transformation takes f itself as an input and returns g. Fixing a point and preserving increments do not settle an additional question about composition or cost. The repetition case in :5.2 shows how different requested changes lead to different operations on the same input rules.
MATH.17:6 - Bias-Annotation
A familiar collection of “valid operations” can conceal an unproved closure claim. A familiar higher-order operation can conceal the choice of law used to combine its results. Work with the membership condition and proposed equation; the failing inputs in :5.1 and :5.2 locate those different errors.
The set-and-function route makes these questions accessible. A question involving topology, approximation, randomness or an alternative equality calls for the corresponding additional structure and argument.
MATH.17:7 - Conformance Checklist
For the construction being used:
- The operations have recoverable inputs, outputs, equality and admissibility conditions.
- The needed compositions land in the claimed collection, or a concrete failure has changed the proposed use.
- The higher-order operation has a construction and returns an admissible output.
- Each law used to derive the result has the required scope and an argument. A counterexample can refute a universal law. To infer the law from finite tests, cover its stated domain or justify the extension.
- The resulting comparison or changed rule answers the starting question.
- A subject or computational application supplies the correspondence or execution account needed by that use.
MATH.17:8 - Common Anti-Patterns and How to Avoid Them
Inferring closure from individual permission. The two flips in :5.1 each meet the step condition but fail it when composed. Decide whether the requirement concerns a step, a sequence or the whole input-output change, and construct the corresponding collection.
Moving a transformation through composition without its law. Repeating each stage twice changed the answer in :5.2. Derive the transformation equation before using it to reorganize a sequence.
Demanding the wrong preservation law. Polynomial differentiation supplies a useful operator through linearity and the product rule. Choose the law from the intended transformation instead of requiring every operator to preserve multiplication or composition.
MATH.17:9 - Consequences
Operations become available for construction, comparison and change. A law established for the higher-order construction can replace repeated case-by-case reasoning, while a counterexample can identify a proposed change that needs revision.
The abstraction has a cost: the operation collection and its laws must be constructed. It pays when the rule itself is changing or when one result will organize many operations. Questions about implementation, approximation or real interaction can require further structure beyond the function account.
MATH.17:10 - Architectural Rationale
Separating membership, closure and higher-order transformation locates three different sources of failure.
MATH.16 supplies the function-object construction. Here the practitioner selects a collection of allowable operations and constructs further operations whose arguments are members of that collection. Monoid and category language make the established composition reusable; the derivative example shows why other higher-order operations need other laws. The choice follows the problem about rules.
The same structure can support mathematical work, computational transformations and mathematical accounts of methods. To use it for computation or for a working method, obtain or establish an applicable interpretation of the operations and their consequences.
MATH.17:11 - SoTA-Echoing
Riehl’s Category Theory in Context, §§1.1 and 1.3, supplies the algebraic account of composable maps, monoids and functors. The adopted contribution is the ability to study transformations of operations by their preserved structure. This pattern turns that account into a method for selecting admissible operations, finding a failed closure condition and constructing the transformation required by the question.
A direct formula is sufficient when one operation settles the task. The structured account helps when rules must be combined or changed. Polynomial operators illustrate the alternative: linearity and a product rule may provide the useful calculus even when composition preservation is inapplicable. Additional mathematical structure is selected by the needed consequence.
MATH.17:12 - Relations
- MATH.16 constructs function objects, evaluation, products and maps selected by their required uses.
- MATH.1 retains generating steps and their order; MATH.5 extends an assignment to generators through the operations it must preserve.
- MATH.2 establishes when an identification of operations supports the proposed further operations.
- MATH.7 transports structure through a bijection. Comparing broader mathematical accounts uses interpretations of their objects, operations and assertions.
- MATH.11 and MATH.13 develop invariant and symmetry consequences once the transformations are specified.
- B.5.FM, C.29 and C.29.2 connect the mathematical construction with a working question, subject correspondence and computational use.
MATH.17:End
MATH.1 - Build a Mathematical Structure of Composable Paths
Type: Method Status: Stable Normativity: Normative
MATH.1:1 - Problem frame
Use this pattern when you know elementary steps and their permitted connections, but still need mathematical objects for their finite combinations. Typical questions are: which steps form a permitted sequence, how can two sequences be joined, and which distinctions must remain available for a later operation?
The construction below makes paths from generating arrows. An arrow has a starting object and an ending object; these can be states, types or mathematical objects. A path is a finite ordered list of arrows whose adjacent endpoints agree. The resulting structure can describe formal words as well as possible routes through a process. Its mathematical laws come from the construction.
Start by writing two steps you want to join and their endpoints. If the first ends where the second starts, their ordered pair is already a useful first path. If the written endpoint hides a condition that changes whether the second step is available, refine the endpoint before joining them.
You need elementary sets, ordered lists and equality. If an existing structure already supplies the combinations and distinctions your question needs, use its operations directly. This pattern is useful when constructing or changing those operations is itself the difficulty.
MATH.1:2 - Problem
A list of elementary steps leaves the composite objects and their operations undecided. Joining names that merely look compatible can produce a combination that the generating rules do not permit. Collapsing two paths to the same endpoint can also erase their different steps, costs or available continuations.
The mathematical task is to construct the combinations, define when composition is possible, and establish the laws that follow. The result should let the recipient reproduce a path and reason about a longer combination from its parts.
MATH.1:3 - Forces
| Force | Tension |
|---|---|
| Finite description and unbounded reuse | A few generators can produce arbitrarily long paths; listing all paths is usually impossible. |
| Keeping distinctions and economical reasoning | Remembering the generators preserves information, while a later question may need only a quotient or a numerical value. |
| Local compatibility and later use | An endpoint sufficient for today’s composition may hide a condition needed by a changed continuation. |
| Composition and interpretation | Concatenation has laws by construction; a physical or computational interpretation has further conditions of its own. |
MATH.1:4 - Solution
Local mantra: name the endpoints; form paths; join matching paths; use the composition laws; retain the distinction needed by the next operation.
MATH.1:4.1 - Choose objects and generating arrows
Write the objects at which the elementary steps start and end. For each generator a, give a source s(a) and a target t(a). Several generators may have the same source and target.
Include conditions that determine the availability of the selected continuations. A location may be enough for one problem; another may require a pair such as (location, permission). Use a failed attempted continuation to find the needed distinction.
The generating arrows and endpoints form a directed graph in the mathematical sense. A drawing can display it, but the vertices, arrows and endpoint functions define the structure. A physical network or an organization’s work may be interpreted through this graph; that application supplies its own claims about what the arrows can represent.
MATH.1:4.2 - Form finite paths
A path of length n>0 is a list [a1,…,an] with t(ai)=s(a(i+1)) for every adjacent pair. Its source is s(a1) and its target is t(an).
At each object x, add an empty path id_x. It starts and ends at x and contains no generator. Keeping its object matters: the empty path at one object cannot serve as the identity at another.
Initially, two nonempty paths are equal when their lists contain the same generators in the same order. The empty paths are equal only at the same object. This choice retains the sequence used to construct the path. A later identification can deliberately forget part of it, using MATH.2.
Construct only the paths needed for the immediate question, or describe a family by its formation rule. Cycles make infinitely many paths possible, but each path remains finite.
MATH.1:4.3 - Define composition by concatenation
For paths p:x→y and q:y→z, write p;q for the path obtained by putting the list of q after the list of p. Here the semicolon is read in execution order: first p, then q.
Composition is defined when the full intermediate object agrees. Its source is x and its target is z. If the endpoints disagree, repair the proposed sequence, supply a connecting arrow that the rules permit, or return the failed connection.
Concatenation gives two laws:
id_x;p=p=p;id_yforp:x→y, because an empty list adds no generator.(p;q);r=p;(q;r)for three consecutively composable paths, because both sides contain the same three lists in the same order.
These arguments establish identity and associativity for this construction. They can be reused while the definitions stay unchanged. They leave the order of the generators intact: p;q and q;p can differ or one can be undefined. A structure with objects, arrows and these laws is a category; the path construction gives the free category on the generating graph.
MATH.1:4.4 - Use the path at the needed level
Return the path that answers the immediate composition question, or the formation and composition rules when the receiving work needs a reusable family.
If each generator has a supplied additive cost, obtain a path’s cost by adding the costs of its generators; the empty path has cost zero. Keep the path as well when the receiver needs to execute it or inspect why it is available. Two paths with the same cost can contain different generators.
If a representation hides an intermediate object, test the attempted composition that made the distinction matter. Refine the objects or retain the paths until the subsequent operation is well defined. MATH.2 constructs an identification that preserves selected operations; it can reduce the structure when those distinctions are no longer needed.
An interpretation can associate generators with transformations in another setting. The mathematical path then specifies their composition. Whether those transformations are available and adequate in that setting is the application’s question, using such common methods as FPF C.29 and B.5.MPC.
Stop when the receiving question has a permitted path, a reusable construction, or a specific failed connection. Constructing every possible path or proving an unchanged concatenation law again adds no result to that use.
MATH.1:5 - Archetypal Grounding
MATH.1:5.1 - A continuation that needs a permission
Two routes p and q start at S and reach location V; their costs are 1 and 4. A final step r costs 2. Under the first rule, r is available after either route, so p;r and q;r are paths and their costs are 3 and 6.
Now change the rule: only q grants the permission needed for r. Keeping a single endpoint V would still make p;r appear composable.
Construct two intermediate objects, V0=(V,0) and V1=(V,1). Set:
| Generator | Source | Target | Cost |
|---|---|---|---|
p | S | V0 | 1 |
q | S | V1 | 4 |
r | V1 | T | 2 |
The path q;r exists and costs 6. The expression p;r fails the endpoint test. Selecting the cheaper prefix first would therefore lose the available completion. The useful result is the permitted path and its cost; the refined endpoint explains why it is permitted.
If a further generator a:V0→V1 grants permission at cost 1, a new path p;a;r becomes available at cost 4. The former failure has opened a construction question: what additional arrow would connect the available prefix to the required continuation?
MATH.1:5.2 - Natural numbers from repetition
Take one object X and one generating loop a:X→X. The paths are the empty word, a, a;a, and longer repetitions. Write a^n for the list containing n copies, with a^0=id_X.
Concatenating a^m and a^n gives a^(m+n). Thus lengths supply an arithmetic account of this structure: the identity corresponds to 0 and composition corresponds to addition. Every path is determined by its length in this one-generator case.
Adding a second loop b changes the situation. The paths a;b and b;a both have length 2 but are different lists. Counting generators now loses their order. It still answers a length question; a question about which generator acts first requires the path.
MATH.1:5.3 - Order matters under interpretation
On integers let f(x)=x+1 and g(x)=2*x. Both generators start and end in the integer type, so both orders are composable. Starting from 0, f;g returns 2, while g;f returns 1.
The associativity argument allows regrouping a longer list. It does not authorize exchanging f and g.
MATH.1:5.4 - Keep the intermediate states of interacting updates
Two updates to a counter each read its current value, retain that reading and later write the reading plus one. From zero, finishing one update before the other gives two. If both read zero before either writes, the final value is one.
To represent the difference, a state retains the counter, each update’s saved reading and whether its read and write have occurred. A read copies the counter into that update’s saved value; its later write replaces the counter by that saved value plus one. Form paths in which each read precedes its own write. The paths read-A, write-A, read-B, write-B and read-A, read-B, write-A, write-B return two and one respectively.
Treating each update as one indivisible arrow would lose the second path. If the work can require one complete update to finish before the other, the restricted paths preserve both increments. FPF C.29 establishes how these transitions describe the implemented work; Method Engineering B.1.5.CM helps change its composition. Choosing an implementation also depends on how it handles waiting, interruption and failure.
MATH.1:6 - Bias-Annotation
A familiar drawing can make location seem like the whole state. The permission case exposes the omitted condition through a failed continuation, then repairs the mathematical object.
The construction also favors retaining history. This is useful while the role of the generators is unsettled, but it can be unnecessarily expensive when only a value or an equivalence class is needed. When using a quotient or evaluation, state the operation or question it preserves.
MATH.1:7 - Conformance Checklist
- Can the reader identify each generator’s source and target?
- Does each constructed path satisfy the adjacent-endpoint condition, including any action-changing refinement such as permission?
- Are empty paths attached to their objects and composition defined in one stated order?
- Are the claimed identity and associativity laws supported by the construction used?
- Does the returned path retain the detail required by its next use? If only a cost, length or class is returned, is that sufficient for the receiving question?
- When a connection fails, is the missing or incompatible endpoint recoverable without inventing an available generator?
MATH.1:8 - Common Anti-Patterns and How to Avoid Them
Join by location while losing an enabling condition. In :5.1, replacing V0 and V1 by V creates an apparent connection that the permission rule excludes. Restore the condition in the intermediate object and try the composition again.
Use a path value as a substitute for a path. The same length can describe a;b and b;a. Return the list when order matters; return the value when the question only consumes that value.
Read associativity as permission to reorder. Parentheses choose grouping. They leave generator order unchanged, as the f;g example shows.
MATH.1:9 - Consequences
The construction turns elementary connections into reusable mathematical objects and an operation on them. It provides a witness for a permitted combination and a precise location for a failed one. Different contributors can prepare subpaths and compose them at shared endpoints.
Retaining all generator lists can produce a much larger structure than the final question needs. A quotient can remove selected distinctions; a cost calculation can compare alternatives. Each reduction has to preserve what its receiving use consumes.
A new continuation may reveal an inadequate object description. The repair then changes the endpoint distinction and the affected paths, while unchanged generating rules and concatenation arguments remain reusable.
MATH.1:10 - Architectural Rationale
Generating first and identifying later separates two mathematical decisions: which composites exist and which of them count as the same. It gives a small constructive starting point when an application or theory has elementary steps but no satisfactory account of their combinations.
The empty path and endpoint conditions make composition uniform. An already completed segment can be treated like an elementary arrow in a larger composition. This is why the same construction supports words, typed transformations and possible routes through a process.
A concrete transformation structure can be more economical when only its resulting transformations matter. Paths earn their additional detail when the sequence, its formation conditions or its later reinterpretation affects the answer. The examples expose both uses: with one object and one generating loop, length determines the path; adding a second loop permits paths of equal length with different orders.
This method constructs paths from elementary connections. FPF B.5.RC helps recover a construction already described, and C.29 helps relate a mathematical structure to another subject. Their results can be used before or after this construction.
MATH.1:11 - SoTA-Echoing
Question: how can permitted elementary connections generate reusable composites while retaining their order and formation conditions?
Adopt the free-path construction in Fong and Spivak’s Seven Sketches in Compositionality, §3.2.1, pp.82-83, 2018 manuscript: arrows generate finite paths, with empty paths and concatenation. It supplies the constructive definitions used in :4.2-:4.3.
An alternative is to compose the interpreted transformations directly. Retaining permission in the state can make the required continuation’s availability explicit; the functions in :5.3 already distinguish the two orders. By comparison, a location-only summary in :5.1 loses permission, and length alone in :5.2 loses order.
Adapt the construction by retaining generator history when the receiving question needs it. On the integers let f(x)=x+1 and h(x)=x-1. The path f;h and the empty path induce the same identity function. With unit cost for each generator their costs are 2 and 0. Direct function composition answers the transformation question; the paths retain the steps for inspection or replacement, while a cost-only question can use their calculated costs. The trade-off is the larger space of paths in exchange for recoverable history.
Section 3.2.2, pp.84-85, supplies the later option of imposing path equations; MATH.2 develops operation-preserving identification. The route and permission cases here are authored applications of the mathematics. Reconsider this choice if a quotient or an interpreted structure supports the same required continuations with less retained detail, or if the problem’s compositions are not finite sequential paths.
MATH.1:12 - Relations
- Uses FPF B.5.RC when needed: recover an unfamiliar source’s objects and construction rules before choosing generators.
- Supplies MATH.2: paths and composition can be the objects and operation whose identification is tested.
- Connects with FPF C.29 and B.5.MPC: carry a mathematical path or obstruction to an interpreted subject, and revisit the subject formulation when the correspondence fails.
- Connects with FPF B.5.QD and C.39.RO: a missing connection can motivate a new generating operation or a new mathematical question.
MATH.1:End
MATH.2 - Treat Objects as the Same While Preserving Operations (Quotient)
Type: Method Status: Stable Normativity: Normative
MATH.2:1 - Problem frame
Use this pattern when you want to treat several mathematical objects as one because a working question appears not to distinguish them. You still intend to apply operations to the resulting classes. The recurring difficulty is that two apparently interchangeable inputs can produce different classes of output, or permit different next operations.
Start with the proposed identification and one operation the receiver will use. Find two identified inputs and apply that operation. A differing output class, or availability after only one input, is already a useful counterexample. Repair the identification or change the intended use before calculating with the classes.
The method constructs a quotient: a set of equivalence classes with operations inherited from the original objects. You need elementary sets, relations and functions. It applies to specified total operations, and to partial operations under the additional domain condition in :4.3. When individual objects already support the question economically, use them directly.
MATH.2:2 - Problem
An equivalence relation makes classes, but by itself it does not determine usable operations on those classes. An operation defined by selecting a representative is ambiguous if a different representative changes the returned class.
There is a second loss to check: even a mathematically sound quotient may discard the quantity or distinction the receiver wants. The task is to construct an identification that preserves both the selected operations and the intended class-level question, or to expose why the proposed identification cannot do so.
MATH.2:3 - Forces
| Force | Tension |
|---|---|
| Fewer objects and retained operations | Merging objects simplifies reasoning but may erase a distinction used by an operation. |
| A convenient resemblance and an equivalence relation | Closeness or one shared property may suggest a grouping without giving reflexivity, symmetry and transitivity. |
| Total and partial operations | Matching returned classes is enough for a total operation; a partial operation also has an availability condition. |
| Valid quotient and useful answer | An operation can descend to classes while the receiver’s requested quantity cannot. |
MATH.2:4 - Solution
Local mantra: choose what may be identified; test the operations; repair the distinction; form the classes; answer only what those classes determine.
MATH.2:4.1 - Specify the carrier, operations and receiving question
Name the set A of objects and the operations to retain. An n-ary total operation f maps every tuple in A^n to an element of A. A partial operation has a stated domain D_f⊆A^n.
When an operation takes inputs from different sets or returns a result in another set, choose an equivalence relation on each participating set. Compare corresponding inputs under their sets’ relations and the resulting outputs under the output set’s relation. A transition on states and concatenation of paths are different operations; choose the one used by the proposed identification.
State the receiving question. For example, the receiver may need the parity of a sum, the cost of a continuation, or whether a next step is available. This determines which distinctions a useful quotient can lose.
MATH.2:4.2 - Make the proposed equality into an equivalence relation
Write a~b for the proposed identification. An equivalence relation is reflexive, symmetric and transitive. Its class [a] contains all objects identified with a; these classes partition A.
If the candidate is a resemblance, test the missing law before forming classes. For instance, on integers a~b defined by |a-b|≤1 is reflexive and symmetric but fails transitivity: 0 is related to 1 and 1 to 2, while 0 is not related to 2.
You can refine a proposed relation by retaining an additional property. Requiring both a~b and h(a)=h(b) remains an equivalence relation when ~ was one. Choose h from the failure that matters to the operation or query. The repaired relation still needs the operation test.
MATH.2:4.3 - Test compatibility, including the domain of a partial operation
For a total operation f, compare tuples whose corresponding entries are equivalent. The compatibility condition is:
a1~b1, …, an~bn ⇒ f(a1,…,an)~f(b1,…,bn).
An equivalence relation satisfying this condition for every retained total operation is a congruence for those operations.
For a partial operation, first require agreement about whether it can be applied:
a1~b1, …, an~bn ⇒ ((a1,…,an)∈D_f ⇔ (b1,…,bn)∈D_f).
Where both tuples are in the domain, require equivalent outputs as above. This pattern uses the resulting quotient convention in which availability is independent of the representative. A set-valued or approximate account that deliberately combines differing possibilities is another construction.
Use an algebraic argument for a general claim, or exhaustive checking when the specified carrier is finite. A few successful examples can suggest the relation; one failure is enough to refute compatibility.
If the test fails, keep the distinguishing information in the objects or narrow the operation/question being claimed. For a finite partition, split the failing class using the exposed distinction and retest the affected operations. This is a local repair.
MATH.2:4.4 - Define the quotient operation and show that it is well defined
When the conditions hold, form A/~, the set of classes, and define the inherited operation by:
f_bar([a1],…,[an])=[f(a1,…,an)].
The right side is independent of the chosen representatives precisely because compatible inputs return equivalent outputs. For a partial operation, agreement of domains also makes its availability independent of that choice.
This argument is reusable for unchanged conditions. The useful result is an operation on classes, together with the relation and the reason it is valid.
Preserve a representative or a way to construct one when later work needs an individual object. Knowing only a class may be sufficient for one answer and insufficient for a later request about a member.
MATH.2:4.5 - Check which answers can be recovered and use the result
A value q(a) can be recovered from [a] when it is constant on that class: a~b ⇒ q(a)=q(b). Then define q_bar([a])=q(a). If this fails, return to the original objects, retain more information, or return the range of possibilities when that answers the question.
Use the quotient for the declared operations and answers. A new operation or query can require a finer relation. The old quotient retains its earlier use; revise the part that the new question distinguishes.
Stop with a valid class-level operation and usable answer, or with a counterexample identifying the lost operation or quantity. Additional formalization is useful only when it resolves a remaining mathematical or receiving question.
MATH.2:5 - Archetypal Grounding
MATH.2:5.1 - Absolute value fails, parity works for addition
Suppose integers are identified when they have the same absolute value. Then 1 and -1 are identified. Add the same integer 1 to both: the results are 2 and 0, which have different absolute values. This equivalence relation therefore cannot support addition inherited from integer representatives.
For a question about parity, choose a different relation: n~m when n-m is even. Reflexivity, symmetry and transitivity follow from the corresponding facts about differences divisible by 2.
If n~n' and m~m', then (n+m)-(n'+m')=(n-n')+(m-m') is even. Addition therefore preserves the relation. There are two classes:
+ | Even | Odd |
|---|---|---|
| Even | Even | Odd |
| Odd | Odd | Even |
The class of 7 plus the class of 4 is Odd. This answers the parity question using two classes. It does not determine whether the sum is 11 or another odd integer; a request for the sum itself requires the operands or more information.
Now request multiplication as well. The earlier addition argument does not settle the new operation. Here a separate calculation does:
n*m-n'*m'=(n-n')*m+n'*(m-m').
Both terms on the right are even when the corresponding inputs have the same parity. The quotient can therefore also support multiplication. The changed request led to a new compatibility argument while preserving the earlier addition result.
MATH.2:5.2 - A location class loses availability
Let V0 and V1 be states at location V, without and with permission. A partial transition r is defined at V1 and returns T; it is undefined at V0.
The proposed location-only relation identifies V0~V1. Output comparison alone would find no conflicting pair of returned values, because one value does not exist. The domain test detects the failure: V1∈D_r and V0∉D_r.
Refine the relation to retain permission. The two states are now in different classes, and the inherited transition is available only on the class containing V1. In MATH.1’s route case, this retains the permitted q;r of cost 6 and excludes the apparent p;r of cost 3.
A convention that declares a class enabled whenever any representative is enabled would answer a different question: a transition is possible from some member. To execute it from the actual state, that convention still needs a suitable member or an enabling step. The present construction preserves the availability of the given operation at the represented state.
MATH.2:5.3 - Identifying words changes the question they answer
Take the one-generator paths a^n from MATH.1, with concatenation a^m;a^n=a^(m+n). Impose a^2~a^0 and choose the smallest equivalence relation compatible with concatenation that contains this equation.
Compatibility propagates this equation under concatenation. Adding one a gives a^3~a, and repeated deletion of a pair reduces every even-length word to the empty path and every odd-length word to a. These two groups remain distinct: parity itself is a compatible relation satisfying the imposed equation, as :5.1 shows, so the smallest such relation cannot identify opposite parities. This yields two classes and a composition table identical to the addition table above.
The quotient can describe the parity of repeated toggling. It discards the number of toggles. If each use takes time, elapsed cost cannot be recovered from those two classes alone. Retain the length or accumulated cost for a question that consumes it.
MATH.2:5.4 - Normalize labelled values before identifying them
A temperature-checking method accepts values labelled Celsius or kelvin. It converts them to kelvin, then tests membership in the inclusive interval [273.15,303.15]. Grouping inputs by their numeral alone loses the answer: 20 Celsius becomes 293.15 kelvin and passes, while 20 kelvin fails.
Let n(v,C)=v+273.15 and n(v,K)=v. Identify inputs when their n-values agree. Every input has a normalization result, and identified inputs have equal results; both the normalization and the following interval test therefore descend to these classes. This uses the separate input and output sorts of :4.1.
A later question about the original unit cannot be answered from the class alone. Retain the label when that question matters. If the description of the working method places comparison before normalization, Method Engineering A.3.1.CC:4.4 helps locate and repair that contradiction. The mathematical compatibility test and the repair of the described work answer different parts of this example.
MATH.2:6 - Bias-Annotation
A shared appearance or outcome can make identification seem self-evident. The absolute-value case tests that intuition through an operation, and the permission case tests it through availability.
Compression can also look like improvement simply because there are fewer classes. The query condition in :4.5 keeps the receiving answer in view. A larger description can be preferable when it retains a consequential distinction.
MATH.2:7 - Conformance Checklist
- Are the carrier, retained operations and receiving query identifiable?
- Does the relation used to form classes satisfy equivalence, rather than only resemblance or proximity?
- Do equivalent input tuples give equivalent outputs for every operation claimed on the quotient?
- For each retained partial operation, is availability also independent of the representative?
- Does the quotient definition return one class without requiring an unstated representative choice?
- Is the requested answer constant on the relevant classes, or is the lost information explicitly retained or returned as possibilities?
- Has a changed operation or query been checked at the condition it changes?
A counterexample closes a failed proposed identification. It does not require a completed replacement quotient before it can be useful.
MATH.2:8 - Common Anti-Patterns and How to Avoid Them
Use a resemblance as if it partitioned the set. The distance-at-most-one example fails transitivity. Establish the relation being used before computing with its classes.
Check outputs but ignore availability. In the permission case, the absence of one output is the failure. Include the domain condition when operations are partial.
Treat any valid quotient as adequate for every query. Parity supports addition of classes while losing the numerical sum. Check the value the receiver asks for.
Impose one equation but ignore its consequences under composition. Identifying a^2 with the empty path also identifies a^3 with a. Carry the equation through the retained operation, or keep the objects distinct.
MATH.2:9 - Consequences
A successful construction gives equivalence classes on which the retained operations remain meaningful. It can reveal a simpler mathematical structure, such as addition on two parity classes.
A failure identifies the information that the proposed grouping would erase. This can improve the original formulation, expose an unavailable continuation, or suggest a better question before an algorithm is built.
Refinement preserves more information and can increase the cost of representation and calculation. Deliberate approximation or set-valued abstraction can be worthwhile alternatives when their weaker answer is useful; they require their own stated operation and result conditions.
MATH.2:10 - Architectural Rationale
Quotient construction and result transfer answer related but different questions. Here the mathematical operation on equivalence classes is constructed and its well-definedness established. A subsequent interpretation determines whether those classes and operations answer a question about another subject.
The domain condition is explicit because partial operations can fail before returning a value. The permission example would pass an output-only test vacuously, yet the intended next step would depend on the representative. Preserving availability repairs that defect.
The receiver’s query remains separate from operation compatibility. A congruence can make addition well defined and still lose the requested sum. This separation lets one quotient remain useful for parity while a different use retains the individual numbers.
Test the proposed identification. Broader search for an optimal quotient, automated state minimization or a learned abstraction can reuse these conditions while supplying additional algorithms and selection methods.
MATH.2:11 - SoTA-Echoing
Question: when can operations be inherited by classes without depending on an arbitrary representative?
Adopt congruence and quotient algebra from Burris and Sankappanavar, A Course in Universal Algebra, corrected 2012 edition, Chapter II §5, pp.35-36. The compatibility condition and quotient definition supply :4.3-:4.4 for total operations.
The serious alternative is an equivalence relation chosen only by a shared property. It costs less to state, but the absolute-value example cannot support the required addition. The compatibility argument adds work where the quotient operation is claimed and resolves that ambiguity.
Adapt the construction to the partial-operation use by preserving domain membership as well as output classes. The alternative existential convention permits an operation when some class member permits it. That is useful for a possible-transition question but loses availability at the represented state. The permission case selects the stronger convention and places its added condition in :4.3. The cited total-algebra passage does not supply this partial-operation convention.
Adopt the composition consequences of imposed path equations from Fong and Spivak’s Seven Sketches in Compositionality, §3.2.2, pp.84-85, in :5.3. Reopen the choice if the receiving question accepts a weaker bound or set of possibilities at lower cost, or a new operation distinguishes members of an existing class.
MATH.2:12 - Relations
- Uses or follows MATH.1: a generated path structure provides objects and composition to identify.
- Connects with FPF C.29.1: use the quotient and its map in a wider result correspondence; check the subject interpretation separately.
- Connects with FPF A.3.3.PI: a description can lose a distinction needed to predict continuation; the present method supplies the quotient-side operation and domain test.
- Connects with FPF B.5.RR and B.5.QD: revise the argument after a changed operation, or turn a counterexample into a new construction question.
MATH.2:End
MATH.5 - Extend a Generator Assignment While Preserving Operations (Homomorphism)
Type: Method Status: Stable Normativity: Normative
MATH.5:1 - Problem frame
Use this pattern when you know what the basic elements of a mathematical construction should become and need a compatible map on everything built from them. A value assigned to a variable, a transformation assigned to a command, or a cost assigned to a generating step must extend to composite expressions in a way that preserves the chosen operations.
The needed map is a homomorphism: it carries each source operation to the corresponding target operation. To construct it, evaluate composite expressions from the assigned generator values. If the source identifies different expressions, establish that those expressions receive the same value.
Start with one generator and one composite expression. Return their images and the rule that extends the assignment, or a source equality that the proposed images cannot preserve. A first calculation can expose an incompatible assignment before a large translation is attempted.
The reader needs functions, finite expressions and the operations used in the chosen construction. The method covers total operations with finitely many inputs, finite words with associative composition, and the finite typed paths built by MATH.1. A typed path starts and ends at named objects; its interpretation must supply their images as well as the images of its arrows.
If the required map or one needed value is already available, use it. An arbitrary map on a small finite set can be simpler to specify directly when preserving operations is not part of the question.
MATH.5:2 - Problem
A list of corresponding symbols leaves most compound expressions unassigned. Filling them independently can violate the operation that made the correspondence useful. Two source expressions may also denote the same object while their proposed target values differ.
The task is to obtain a reusable mapping rule and identify its scope. The assignment on generators must determine the composites, and every source identification used by the map must remain valid after evaluation.
MATH.5:3 - Forces
| Force | Tension |
|---|---|
| Few generators and many composites | A compact assignment can govern arbitrarily large finite expressions, provided the extension rule is established. |
| Free construction and imposed equations | Syntax permits independent construction; equations identify expressions and restrict their possible images. |
| Preserved operations and retained information | A homomorphism can preserve composition while forgetting distinctions needed by another question. |
| Reusable translation and one calculation | Building the general map costs more than evaluating one expression, but supports substitutions and repeated use. |
MATH.5:4 - Solution
Local mantra: name the generators and operations; assign their images; extend by construction; preserve the equations; use the resulting map.
MATH.5:4.1 - State the source construction and target operations
List the generators and the rules for building finite expressions from them. An expression can be a generator, a constant, or an operation applied to constituent expressions. State each operation’s number of inputs. With generators x,y, constants 0,1 and binary operations + and *, the expression (x*y)+1 is obtained by two construction steps.
Distinguish the freely formed expressions from any equations imposed on them. For example, treating x*y and y*x as the same requires a commutativity equation. The written resemblance of the expressions does not supply that equation.
Name the target set and a corresponding operation for each source operation, including the value of each constant. Every required target operation must be defined on the inputs it receives. This pattern’s total-operation construction does not supply a partial operation’s domain.
For a word construction, state the target composition star and its identity e. The operation must be associative for unparenthesized words to denote a composition independently of grouping. MATH.1 constructs the source words or paths; here the task is to build their map into the target structure.
For typed paths, assign each source object X a target object F(X). The target must supply arrows, associative composition on matching endpoints, and an identity at each object. Assign each generator a:X -> Y an arrow a_target:F(X) -> F(Y). A target can consist of sets and functions; different source objects may then receive sets of different kinds of values. Check these domains before composing.
MATH.5:4.2 - Extend the assignment recursively
Assign a target value a(x) to every generator x. Define the evaluation E on finite expressions:
- a generator
xreceivesa(x); - a constant receives its named target value;
op(t1,...,tn)receivesop_target(E(t1),...,E(tn)).
Each recursive call uses a constituent expression. MATH.4 supplies the finite-construction argument and the treatment of a result that needs additional information.
For a word [x1,...,xk], the same move evaluates the assigned generator values in order. The empty word receives e; extending a word by x changes its value from v to v star a(x). Associativity and the identity laws make this evaluation preserve concatenation:
E(p;q)=E(p) star E(q).
For a typed path, set E(id_X)=id_F(X). If p:X -> Y has been evaluated and a:Y -> Z is the next generator, set E(p;a)=E(p) star a_target, where star is again read in execution order. The intermediate object F(Y) makes this composition defined. Recursing by path length evaluates every finite path while keeping its endpoints. In a target of sets and functions, this means applying E(p) first and a_target second.
These rules determine the image of a composite from the images of its parts.
MATH.5:4.3 - Establish preservation and uniqueness
For freely formed expressions, preservation follows from the defining clause: evaluating an operation on expressions gives the target operation on their evaluations. The generator and constant clauses cover the starting cases.
Suppose another operation-preserving map H has the same assigned generator values. It agrees with E on generators and constants. If it agrees on the constituents of an expression, preservation forces agreement on the whole expression. Induction therefore gives H(t)=E(t) for every expression.
The conclusion is uniqueness among maps preserving the named operations and agreeing with the given assignment. Changing the assignment or required operations changes that question.
For words, the corresponding argument starts with the empty word and extends by one generator. Every concatenation-preserving map with the same identity and generator images must return the same ordered product.
For paths, the base case uses the identity at each F(X). Induction on the second path’s length, using target associativity, gives E(p;q)=E(p) star E(q) for every permitted join. A map preserving identities and composition with the same object and generator assignments must follow those recursive clauses, so it is unique. Such an object-and-arrow map between categories is called a functor. The one-object word construction is its monoid case.
MATH.5:4.4 - Make the map respect identified expressions
If the source equates expressions, test the equations under E. To define E_bar([t])=E(t) on an equivalence class, require:
t~u implies E(t)=E(u).
MATH.2 supplies the quotient and representative-independence construction. Here it is applied to the evaluation just obtained.
For typed paths with the objects retained, impose equations between paths having the same source and target. Compare their target arrows, including the appropriate identity for an empty path. Closure under permitted composition makes the evaluation descend just as above. Identifying different source objects changes this setup and requires a construction that also accounts for their identities and permitted joins.
When the source equivalence is generated by stated equations and their use inside larger expressions, show that each generating equation has equal evaluated sides. Equality is preserved when equal values enter the same target operation. It is also preserved along reversal and a finite sequence of equation replacements. These facts extend the result to the generated equivalence.
An equation schema such as s*t=t*s ranges over its permitted substitutions. Checking one numerical substitution leaves the other instances unresolved. Establish the target law for the required range or return a failing instance. If the source also has additional identifications, include them in the comparison.
A failed equation gives a concrete choice: change the generator assignment, change the target operations, or use a source construction that retains the distinction. Each option changes the mathematical account. Select the one that still answers the receiving question.
MATH.5:4.5 - Use the map and inspect what it forgets
Evaluate the needed expression or pass the reusable map to its consumer. The preservation argument permits calculation by parts and supports substitution of an equivalent source expression.
Equal target values can still come from different source objects. If the receiver needs to recover a source object, obtain an inverse, a retained representative, or another construction that supplies it. A homomorphism by itself does not provide such recovery.
After a changed generator value, reuse the recursive definition and preservation proof for freely formed expressions. Recheck any imposed equation whose evaluated sides can change. After a changed target operation, revisit the clauses and laws that used it.
Stop with the needed value, the reusable homomorphism, or an equation that prevents the proposed extension. A mathematical map can then contribute to FPF C.29’s interpretation-and-return method when the receiving question concerns another subject.
MATH.5:5 - Archetypal Grounding
MATH.5:5.1 - Evaluate expressions, then test an equation
Build expressions from x,y,0,1,+,*. Assign x=2 and y=3, and use ordinary integer addition and multiplication. Evaluation returns E((x*y)+1)=7. The same rules evaluate every finite expression and preserve its two operations.
Now let the source identify expressions using the usual commutative-semiring laws: associativity, the two identities, commutativity of both operations, distributivity, and multiplication by zero. Integer arithmetic satisfies those laws, so evaluation also defines a map from the identified expressions.
Change the assignment to matrices:
A=[[0,1],[0,0]], B=[[0,0],[1,0]].
Use matrix addition and multiplication, the zero matrix and identity matrix. This still evaluates freely formed expressions. But:
A*B=[[1,0],[0,0]]
B*A=[[0,0],[0,1]].
The source’s equation x*y=y*x therefore fails under this assignment. A substitution into the commutative quotient would give two answers for one source element.
If ordered multiplication is needed, use expressions whose equations retain its order. Matrix addition, multiplication, zero and identity support the remaining semiring laws. If commutative multiplication is essential to the original question, retain a target and assignment that satisfy it instead. The failed equation identifies the mathematical change required.
MATH.5:5.2 - Calculate the combined effect of a word of operations
Let a word contain commands I and D. Their mathematical effects on an integer are:
I(x)=x+1, D(x)=2*x.
Represent an affine transformation x -> s*x+t by the pair (s,t). Thus I receives (1,1) and D receives (2,0).
For (s,t) followed by (u,v), define:
(s,t) star (u,v)=(u*s,u*t+v).
Substitution derives this rule: u*(s*x+t)+v=(u*s)*x+(u*t+v). The identity is (1,0). For a third pair (w,z), either grouping gives (w*u*s,w*u*t+w*v+z), so the rule is associative.
Extend the two generator assignments to words. Then:
I;Dreceives(2,2), meaningx -> 2*x+2;D;Ireceives(2,1), meaningx -> 2*x+1;I;D;Ireceives(2,3), meaningx -> 2*x+3.
The third word sends 10 to 23. The pair describes its effect for every integer, allowing it to be composed with another affine operation without expanding the whole word again.
A different map can send each generator to cost 1 and concatenate by addition. It gives both I;D and D;I the value 2. This is a valid cost homomorphism but loses their different effects. Requiring the source equation I;D=D;I would preserve that cost map while preventing the stated effect map. The receiving question decides which distinction must remain.
If a command’s availability depends on intermediate state, the all-words construction is no longer the intended source. Use state-sensitive paths under MATH.1 and preserve their interfaces when constructing the interpretation.
MATH.5:5.3 - Interpret paths with different kinds of values
Take source objects A and B, with generators u:A -> B and v:B -> A. Interpret A as the integers and B as pairs of integers. Assign u_target(n)=(n,0) and v_target(n,m)=n. The empty path at A becomes the identity on integers; the empty path at B becomes the identity on integer pairs.
Extension gives E(u;v)(n)=n, whereas E(v;u)(n,m)=(n,0). The first composite therefore equals E(id_A). The second differs from E(id_B): it sends (7,5) to (7,0). The interpretation can descend through the source equation u;v=id_A, together with the equations generated from it by permitted composition. It keeps the information that the return path loses the second component.
Now require v;u=id_B as well. The same assignment fails that new equation. Keep the free-path interpretation or the first quotient, change the assigned maps, or change the required identification. Both composites are valid paths; the failed assertion concerns their values, not whether they can be formed. This distinction lets a representation carry construction followed by recovery without claiming recovery in both directions.
MATH.5:6 - Bias-Annotation
Recognizable notation can encourage an unexamined substitution. Matrix multiplication retains order even when the same multiplication sign denotes commutative arithmetic elsewhere. Test the law that the source expression uses.
A compact target value can also be mistaken for a reversible description. The cost example preserves concatenation while merging words with different effects.
A few successful evaluations can hide an equation schema’s range. The reusable extension depends on preservation for every admitted instance of the equations it consumes.
MATH.5:7 - Conformance Checklist
-
For typed paths, do the object assignments, generator endpoints and identities determine the extension, and do imposed equations compare arrows with the same endpoints?
-
Are the generators, constants and source operations specified?
-
Does each source operation have a defined target operation with the required inputs?
-
Do the evaluation clauses determine every finite expression?
-
Does the preservation argument cover the named operations and the identity?
-
Is any uniqueness claim restricted to maps with the same assignment and preservation requirements?
-
If expressions are identified, do their evaluated values agree for every required equation instance?
-
Does the returned value retain the information needed by its consumer?
-
Does a changed assignment, equation or operation lead to the affected comparison?
MATH.5:8 - Common Anti-Patterns and How to Avoid Them
Assign unrelated values to composites. Define their values through the target operations. Otherwise the map can fail the very composition it is intended to represent.
Carry commutative arithmetic into ordered operations. The matrix and command cases supply counterexamples. Keep the source order or justify the commutativity required by the quotient.
Check one instance of a general equation. Recover its substitution range. Establish the law there or return a failing instance.
Infer reversibility from operation preservation. The cost map returns the same value for different effects. Retain a suitable source representative or construct the additional inverse needed for the question.
Drop a composition precondition. An unavailable word is not repaired by assigning it a numerical image. Use a source that represents permitted joins.
MATH.5:9 - Consequences
A small assignment determines a map over arbitrarily large finite constructions. Its evaluation rule supports calculation, substitution and comparison of composite effects. A failed equation can locate the required change before the entire map is used.
The map may deliberately discard distinctions. Preserving operations and recovering original objects are separate results. Equality checks on complicated presentations can remain difficult even when the recursive evaluation itself is simple.
MATH.5:10 - Architectural Rationale
The method connects three mathematical contributions: recursive construction, preservation of operations, and compatibility with imposed equations. Their combination answers a different question from constructing the source objects alone: how a chosen interpretation extends across that whole source.
The free-expression step makes evaluation and uniqueness accessible. The quotient step then exposes the obligations introduced by an identification. Keeping them separate lets a failed equation leave the valid free-expression map available.
For one small expression, direct evaluation can be sufficient. The general construction earns its cost when many expressions, substitutions or a reusable representation are needed. A ready homomorphism can supply the same result without reconstructing its proof.
The affine-pair case gives the same composition a second mathematical description. Its equation connects the descriptions.
MATH.5:11 - SoTA-Echoing
Question: how can a generator assignment determine an operation-preserving map, including when the source equates different constructions?
Burris and Sankappanavar’s A Course in Universal Algebra, corrected 2012 edition, II §10, definitions 10.1-10.5, lemma 10.6 and theorem 10.8, supplies term formation, recursive evaluation and unique extension. Adopt that construction. The examples apply it to arithmetic expressions and composed affine transformations. The pattern’s quotient step uses the congruence construction supplied by MATH.2 and gives its preservation argument.
The Mathlib free-monoid implementation gives an executable formalization of the word case. FreeMonoid.lift extends generator values by the product of their images; hom_eq states uniqueness from generator agreement. Adapt that presentation into ordinary mathematical instructions, retaining the monoid premises.
The Mathlib path-category construction formalizes the typed branch: Paths.lift extends an object-and-generator assignment; lift_nil, lift_cons and lift_unique establish the identity, recursive composition and uniqueness clauses. The pattern spells out those operations for use after MATH.1. The integer/pair case derives a consequence and a failed additional equation directly from its assigned functions.
The useful comparison is with a supplied map or independent evaluation of a small number of expressions. Extension by generators improves repeated compositional use, while an imposed equation adds an obligation to show that the evaluation respects it. Reopen when a partial operation has a domain beyond the path-endpoint construction supplied here, the source admits infinite constructions, an equation fails, or a simpler available map supplies the receiving result.
MATH.5:12 - Relations
- Uses MATH.1 where the source is a path construction: assign images to its objects and generators, then extend to its identities and permitted composites.
- Uses MATH.4: construct the evaluation on finite expressions and prove its recursive clauses and uniqueness.
- Uses MATH.2 when equations identify expressions: obtain representative-independent evaluation on the quotient.
- Connects with FPF C.29: use the mathematical map in a subject correspondence and recover the result needed there.
- Connects with Method Engineering: a mathematical account of composed methods can use the affine-effect construction; B.1.5.CM develops the proposed composition account; A.3.1.CC checks its claims and returns a correction to the description or construction that needs it.
MATH.5:End
MATH.7 - Transport a Mathematical Structure Through a Bijection
Type: Method Status: Stable Normativity: Normative
MATH.7:1 - Problem frame
Use this pattern when another representation makes a mathematical construction easier to work with and you need to carry its operations and results across a reversible map. You may want to calculate with coordinates, encode sets by bit vectors, or give a familiar carrier a different algebraic structure.
A bijection pairs every element of one set with one element of another and has an inverse that recovers each starting element in either round trip. It can be used to define operations and relations on the receiving set. With those definitions, the map becomes an isomorphism of the chosen structures: it preserves their operations and reflects their relations.
Start with one needed operation and one input. Recover the input in the source, perform the source operation, and map its result back. Return the resulting operation and its domain, or the part of the proposed correspondence that cannot be reversed.
The reader needs functions, composition, inverse functions and elementary algebra. The main construction covers operations with finitely many inputs, constants and relations on sets. The worked coordinate example also uses squared Euclidean length. If the map and the needed preservation result are already available, use them. A one-way representation or a summary that deliberately forgets distinctions can instead use MATH.2, MATH.5 and FPF C.29.1 for the result it preserves.
MATH.7:2 - Problem
Changing the names or coordinates of elements leaves the receiving operations undecided. Reusing the familiar operation on the new labels can produce a different result. Even when one operation survives unchanged, another quantity or relation may require a different formula.
The task is to construct the receiving structure, establish what it preserves, and use that preservation to calculate or solve a problem. If the receiver already requires operations of its own, the transported construction must be compared with them.
MATH.7:3 - Forces
| Force | Tension |
|---|---|
| Familiar carrier and chosen structure | The same set can carry several operations with different identities and laws. |
| Reversible elements and preserved work | Recovering elements supplies the means to transport operations; it does not choose which operations matter. |
| One convenient representation and several quantities | A change can simplify one calculation while complicating another. |
| Reusable proof and computing cost | Transport can reuse an algebraic argument, while repeated encoding and decoding can make a calculation expensive. |
MATH.7:4 - Solution
Choose the structure to carry → establish both inverse equations → transport operations and relations → derive the retained laws → calculate and return the result.
MATH.7:4.1 - Choose the source structure and the receiving use
Name the source set X and the operations, constants or relations needed by the question. For an additive structure these might be addition, zero and negation. For an ordered structure the comparison relation matters too. Include a quantity such as length when the requested conclusion depends on it.
Name the receiving set Y and distinguish two tasks: constructing its operations, or showing that operations already required there correspond to the source. In the second task, retain those required operations for the comparison. Replacing them with different transported operations changes the proposed mathematical structure.
For a single update, C.29.1’s correspondence comparison can be sufficient. Use the construction below when you need the related operations, their laws, a reusable representation or a way to move solutions between the two structures.
MATH.7:4.2 - Establish the reversible map on its declared sets
Give h:X→Y and r:Y→X and establish both equations:
r(h(x))=x for every x in X;
h(r(y))=y for every y in Y.
They establish that r is the inverse of h. A formula, a complete finite table or an existing applicable result can supply the maps and these equations.
If h only covers part of the proposed Y, you can take its image h(X) as the receiving set when that answers the question. If h combines distinct source elements, returning the whole original element requires more information or a different map. A quotient may still retain the requested operation under MATH.2. MATH.6’s left-inverse examples show why recovery in one direction alone leaves the other direction open.
Keep restrictions in the sets. For example, squaring is reversible from nonnegative real numbers to nonnegative real numbers, with the nonnegative square root as inverse. Squaring on all real numbers combines opposite inputs and cannot support that inverse construction for the whole source.
MATH.7:4.3 - Define the receiving operations and relations
For a source operation op_X:X^n→X, define:
op_Y(y1,...,yn)=h(op_X(r(y1),...,r(yn))).
Decode each input, perform the source operation, then encode the output. Constants have no inputs, so a source constant c becomes h(c). A source relation R becomes:
R_Y(y1,...,yn) holds exactly when R_X(r(y1),...,r(yn)) holds.
The construction can have different input and output sets. For op:X1×...×Xn→Z, use a bijection h_i:Xi→Yi for each input and k:Z→W for the output. Then:
op_target(y1,...,yn)=k(op(h_1^-1(y1),...,h_n^-1(yn))).
An unchanged scalar result uses the identity map on that scalar set. Thus transporting a length calculation changes its input coordinates while retaining the numerical length.
For a partial source operation, transport its domain too. The receiving tuple is allowed precisely when its decoded tuple is in the source domain; define its output there by the same formula. A larger independently supplied receiving domain needs its own comparison before its extra inputs are used.
Calculate one small case in both descriptions. Use it to check the direction of the maps, the constants and the operation being performed. The general preservation result comes from the defining formula and inverse equations.
MATH.7:4.4 - Derive the laws that the chosen structure retains
For each operation, substituting h(x_i) into its definition and cancelling r(h(x_i)) gives:
op_Y(h(x1),...,h(xn))=h(op_X(x1,...,xn)).
Any other receiving operation with this equality must coincide with the constructed one: every receiving input has the form h(x_i). Thus the source operation and h determine the transported operation uniquely on Y.
To carry an equation built from these operations, follow its expressions from the variables and constants through each operation. Variables are mapped by h, constants by their specified images, and the displayed equality carries each composite expression. This is an induction on the expression’s construction; MATH.4 supplies that form of argument.
For expressions s and t in one carrier, it yields:
s_Y(h(x1),...)=h(s_X(x1,...)) and t_Y(h(x1),...)=h(t_X(x1,...)).
An equality of the source expressions therefore gives equality of the receiving expressions. Conversely, h is injective, so equality of those receiving values gives equality of the source values. Surjectivity covers all assignments in Y. The same reasoning with the map for each sort treats operations with different input and output sets.
This transfers equational laws such as associativity, an identity law or distributivity for the operations carried. A further order, distance or other relation must use its own transported definition or an established compatibility result. For partial operations, compare the definedness of the compound expressions as well as their values.
MATH.7:4.5 - Calculate in the useful representation and recover the answer
Translate the inputs, constants and requested relation. Calculate or solve the corresponding problem using the receiving operations. Map the result back with the inverse appropriate to its kind.
For example, a source equation t_X(x)=b becomes t_Y(y)=h(b), where y=h(x) and all other parameters in t are translated too. A receiving solution y returns x=r(y). The correspondence gives both directions, so it also carries absence or uniqueness of a solution when the equations range over the declared sets.
Use a simpler formula for a transported operation after establishing equality with its defining formula. This can avoid repeated encoding and decoding. Compare the resulting calculation effort with direct source calculation when the representation is being chosen for efficiency.
If Y already had a required operation, compare it with the constructed one before transferring its laws or solutions. A disagreement can lead to a changed map, a different receiving structure, or continued use of the original description.
MATH.7:4.6 - Revisit only what the changed question uses
When h changes, derive the affected receiving operations and constants again. When the question adds a quantity or relation, construct its receiving form even if the earlier operations are unchanged. When a domain restriction changes, revisit both inverse equations and the allowed operation inputs.
Return a failed equation or two source cases that the map cannot distinguish through MATH.6 or MATH.2 as appropriate. Use C.29 when the mathematical representation is being related to another subject. Stop with the needed calculation, reusable transported structure, or identified obstruction.
MATH.7:5 - Archetypal Grounding
MATH.7:5.1 - Shifted numbers with a shifted addition law
Start with real numbers under addition. Let h(x)=x+1 and r(y)=y-1. Both inverse equations hold on all real numbers. The transported addition is:
u ⊕ v=h(r(u)+r(v))=u+v-1.
The source zero becomes h(0)=1, and source negation becomes neg_Y(u)=h(-r(u))=2-u. Thus u⊕1=u and u⊕(2-u)=1. Associativity follows directly because both groupings of three inputs give u+v+w-2; it also follows from the general transport argument.
To solve x+3=7, translate it as y⊕4=8. The receiving equation gives y=5, and decoding gives x=4. Using ordinary addition on the new labels would instead solve y+4=8 and return x=3, which fails the original equation.
The transported operation is useful as a representation of the source addition. If ordinary addition on Y is part of the receiving requirement, this h does not preserve that requirement; the construction has exposed a different operation.
The same map can transport real division, defined when the source denominator is nonzero. Its receiving formula is u⊘v=(u-1)/(v-1)+1, with domain v≠1. The label 1 decodes to the forbidden denominator zero; the label 0 decodes to the allowed denominator −1. For example, 3⊘0=-1 decodes to −2, the result of the source calculation 2/(-1). Using the familiar restriction v≠0 would exclude an allowed input and admit a forbidden one.
MATH.7:5.2 - Sets represented by bit vectors
Let X be the subsets of {a,b,c}. Map a subset to its membership vector in {0,1}^3; for example, {a,c} maps to (1,0,1). Decode by selecting the positions marked 1. These maps are inverse on all eight subsets and all eight vectors.
Take symmetric difference as the source operation: an element belongs to S△T when it belongs to exactly one of S and T. Its transported operation is coordinatewise XOR, whose output bit is 1 exactly when the two input bits differ. The empty set becomes (0,0,0).
For S={a,c} and T={b,c}, symmetric difference gives {a,b}. In coordinates:
(1,0,1) XOR (0,1,1) = (1,1,0).
Decoding returns {a,b}. This gives a way to perform the set operation in a binary representation and recover its result. The inverse map and operation formula explain why the method works for every subset pair; the eight-by-eight table is a finite check if needed.
If the next question asks for union instead, derive its operation: coordinatewise OR. Reusing XOR would discard an element present in both inputs. The same bijection supports both operations once each is defined.
MATH.7:5.3 - Addition survives a coordinate change while length needs a new formula
In X=R^2, let h(x,y)=(x+y,y). Its inverse is r(u,v)=(u-v,v). Transported vector addition coincides with ordinary coordinatewise addition because h is linear.
Now ask for squared Euclidean length, L_X(x,y)=x^2+y^2. The result is a real number whose interpretation stays unchanged, so its output map is the identity. The transported quantity is:
L_Y(u,v)=(u-v)^2+v^2.
The source vector (0,1) has squared length 1 and maps to (1,1). The transported formula still returns 1. The familiar formula u^2+v^2 would return 2.
A length bound L_X(x,y)≤1 consequently becomes (u-v)^2+v^2≤1. It does not become u^2+v^2≤1 through this coordinate map. The example separates an unchanged operation from a quantity whose receiving formula must be constructed. A later physical interpretation of these coordinates uses C.29 for its subject correspondence.
MATH.7:6 - Bias-Annotation
Bijections give full recovery on the declared sets. Many useful summaries and approximate models intentionally retain less information. They can still answer a specific question through a different correspondence method. The elementary examples also make the maps cheap to calculate; a complicated inverse may remove the computational benefit of a representation while leaving its mathematical validity intact.
MATH.7:7 - Conformance Checklist
- The receiving question determines the operations, constants and relations to carry.
- Both inverse equations hold on the sets used by the result.
- Each receiving operation uses the appropriate input and output maps, including transported domains for partial operations.
- The claimed laws concern the transported structure or operations shown to coincide with it.
- The calculation translates its parameters and returns a result of the required kind.
MATH.7:8 - Common Anti-Patterns and How to Avoid Them
Change the labels and retain an incompatible operation. In :5.1 ordinary addition on the new labels solves a different equation. Construct the receiving operation and compare any required incumbent.
Recover source elements and assume every target element is covered. Establish the second inverse equation or restrict the target to the image, as :4.2 requires.
Transfer every property after checking one operation. The coordinate example preserves addition while squared length needs another formula. Include the quantity or relation used by the requested result.
Choose a familiar operation for a new question. The bit-vector example needs OR for union and XOR for symmetric difference. Translate the operation the question asks for.
MATH.7:9 - Consequences
A reversible correspondence becomes a constructive way to obtain operations, laws and solutions in another representation. The same carrier can support a newly useful structure, and the proof of preservation can be reused across many calculations.
One representation may simplify an expression or proof, while another reduces computation. More than one representation may remain useful for different parts of the work.
MATH.7:10 - Architectural Rationale
Encoding the result of a decoded operation determines the structure that the bijection preserves. Uniqueness prevents an independent choice of a familiar operation from being silently treated as the same construction. The expression-induction argument then explains why equations and their solutions travel.
C.29.1 already gives the common correspondence method and conjugation of a single update. This pattern develops the mathematical structure construction: constants, operations of several arities, relations, their laws and solution return. A single-update use can stay with C.29.1. MATH.5 starts instead with generator images and builds a homomorphism, which may forget information; here a supplied reversible map determines the receiving operations.
Transport is preferable when an available source structure and a useful bijection save construction or reasoning work. Direct definitions can be simpler or faster. A pre-existing isomorphism can supply the result without repeating the derivation.
MATH.7:11 - SoTA-Echoing
Question: how can a reversible map supply a usable mathematical structure and carry its calculations?
Burris and Sankappanavar’s A Course in Universal Algebra, corrected 2012 edition, II §2, definition 2.1, states algebraic isomorphism through a bijection and operation preservation. Adopt that mathematical relation. The pattern makes the receiving operations constructive and gives an expression-based argument for the transferred equations.
The maintained Mathlib algebraic-structure transfer definitions implement transport of constants, operations and their laws through an equivalence. Adapt this as the general construction here. Its library note also identifies an implementation cost from repeated unfolding; mathematical equivalence does not choose the most efficient computational representation. The module-transfer construction further illustrates retention of a fixed scalar domain while carrying vector structure.
A direct definition or an existing isomorphism can provide the same result with less work. Transport earns its cost when the correspondence and reusable law matter. Reopen when the inverse, the selected operations, or the required result domain changes.
MATH.7:12 - Relations
- Uses MATH.4: extend preservation through finite expression construction.
- Connects with MATH.5: distinguish extending generator images from constructing structure through an already reversible map.
- Returns to MATH.2 when the representation combines elements: construct the quotient and determine the retained operation.
- Uses MATH.6 for a failed preservation claim: exhibit the incompatible input or missing inverse direction.
- Specializes the mathematical construction used by C.29.1: construct operations, relations and laws through a bijection. Use C.29 for their interpretation in another subject.
- Connects with A.6.3.RT.OE: use the available expression rules to make the transported calculation operable; invention of a notation language is a further notational method.
MATH.7:End
MATH.18 - Compare Mathematical Accounts through Interpretations
Type: Method Status: Stable Normativity: Normative
MATH.18:1 - Problem frame
Use this pattern when two mathematical descriptions appear to address the same construction or question but use different objects, primitive operations, relations or notions of equality. You need to know which calculations, arguments or changes can be carried from one description to the other.
Begin with one consequence you want to transfer. It may be a constructed object, an equation, a solution, or a way of composing operations. An interpretation of that consequence, with its supporting construction or a reason it fails, is the first useful result. A broader equivalence claim requires correspondingly broader comparison.
A mathematical account here consists of the objects, operations, relations and assumptions used to describe the question. An interpretation specifies how to read those ingredients through another account and establishes the consequences needed for the proposed use. The main route requires functions, elementary algebra and reasoning with “for every” and “there exists”. It explains the order and algebra used in the first worked case. The vector-and-matrix case is an optional branch requiring elementary linear algebra.
If a supplied bijection and its transported operations already settle the change of representation, use MATH.7. Use the present method when primitives must be reconstructed, only part of an account transfers, or the round trip needs a structural comparison rather than literal equality.
MATH.18:2 - Problem
Matching names or formulas can conceal different allowed objects, operations or solutions. Two descriptions may recover the same objects while allowing different transformations between them. A translation may preserve calculations for the translated inputs while a target quantifier ranges over additional objects and changes the answer.
The task is to construct the interpretation, determine the scope of the resulting agreement, and use it to transfer a consequence or locate the distinction that prevents transfer.
MATH.18:3 - Forces
| Force | Tension |
|---|---|
| Different primitives and recoverable structure | An operation in one account may be definable through a relation in another, but its existence and uniqueness need an argument. |
| Object correspondence and allowed maps | Matching objects leaves open whether the accounts permit the same transformations of them. |
| Useful one-way translation and equivalence | An interpretation may carry the needed result without supporting a reverse interpretation or a broader equivalence. |
| Comparison scope and effort | A local consequence may need only a short argument; comparing entire theories requires their logical and structural conditions. |
MATH.18:4 - Solution
Local mantra: choose the consequence; interpret the ingredients; derive what transfers; compare the round trips; use the agreement or its failure.
MATH.18:4.1 - Set the scope of the comparison
Name the source account, target account and intended use. Identify the objects involved, their operations and relations, and what counts as an answer. If transformations between objects matter, include those transformations in the comparison.
For each ingredient that the intended consequence uses, ask how the target will express it. Keep optional additional structure separate. For example, an additive operation, an order and a distance support different questions even when carried by the same underlying set.
Decide the strength of the needed conclusion. Transferring one equation, constructing a solution, comparing all compositions in a selected family, and establishing equivalence of two presentations are different claims. Inspect the ingredients and reasoning needed for that claim. Expand the comparison when the next use expands it.
MATH.18:4.2 - Construct the interpretation
Specify the source objects’ target counterparts and the operations or relations that interpret each required primitive. Give a construction rather than a matching name. If an operation is to be recovered through a defining condition, establish that a result exists and is determined to the degree required by the source.
Respect the domains and arities. A binary operation needs two admitted inputs; a relation needs the participants on which it is asserted. When the source uses equivalence classes, establish that different representatives give equivalent interpreted results. MATH.2 supplies the detailed quotient test.
Extend the interpretation through constructed expressions. Interpret each input, then interpret the operation applied to those inputs. A composite expression is handled by repeating this rule through its construction. MATH.5 develops the extension from generators when the source is presented that way.
An assertion also has a construction. Translate equality, conditions and quantifier ranges. For there exists x in A with P(x), the target must express both the interpreted domain A and the interpreted condition P. Enlarging that range can admit a solution that the original problem excludes; :5.2 works this failure.
When an interpretation uses a basis, representative or another choice, supply it or a means of obtaining it. Determine whether changing the choice changes the result, or only changes a representation with a known comparison.
MATH.18:4.3 - Establish what the interpretation preserves and reflects
For the consequence being transferred, follow its construction or argument through the interpretation. Establish that the required operations remain applicable and that each used equality or relation remains valid.
Distinguish the two directions. Preservation takes a source consequence to a target consequence. Reflection takes an interpreted target consequence back to the source. To use a target calculation as the source answer, obtain the required recovery and reflection argument.
For operations composed as maps, give F an action on maps: assign F(f):F(A) -> F(B) to each source map f:A -> B. To translate a sequence stage by stage, establish:
F(g∘f)=F(g)∘F(f) and F(id_A)=id_F(A).
Such an assignment is a functor. Fix source objects A and B. To recover maps, determine which target maps F(A) -> F(B) have counterparts A -> B. To recover an equality, take two source maps f,g:A -> B and determine whether F(f)=F(g) implies f=g. The equality test concerns maps with these same endpoints. Recovery of the objects themselves is a further question, handled in :4.4.
Formal-theory branch. When the intended result is transport of theorems, give the translation of the relevant syntax and logic. Establish the interpreted axioms and justify the inference rules used by the theorem. Comparing collections of models through maps supplies a different mathematical result until its connection to this theorem-translation claim is established.
A failed preservation or reflection equation is useful. Work its inputs far enough to show what answer or construction changes. Then restrict the claim, enrich the interpretation or keep the accounts distinct for that purpose.
MATH.18:4.4 - Construct the return and examine the composites
When two-way use is needed, construct a return interpretation G. Apply G∘F to source ingredients and F∘G to target ingredients. Inspect what each round trip returns.
Sometimes the ingredients are recovered literally, as in the order-and-operation case below. Sometimes a specified isomorphism supplies recovery: an invertible map preserving the structure used by the comparison.
When whole systems of objects and maps are compared, pointwise isomorphisms need compatibility with the maps. If eta_A:A -> G(F(A)) provides source recovery, require for every source map f:A -> B:
G(F(f))∘eta_A = eta_B∘f.
Both routes start in A and finish in G(F(B)). This equation means that applying f and then the recovery isomorphism at B agrees with first applying the recovery isomorphism at A and then G(F(f)). Require the corresponding compatibility on the target side as well. In categorical language, functors with these natural isomorphisms give an equivalence of categories.
Use that equivalence for properties supported by the chosen structure and invariant under its isomorphisms. If a later question uses additional structure, include it in the comparison. The length question in :5.3 shows why this return matters.
If only one direction is constructed or needed, retain that useful interpretation at its established scope. If two-way recovery fails, name the unrecovered operation, assertion or distinction that matters to the work.
MATH.18:4.5 - Transfer the result and reopen only the changed demand
Carry the intended calculation, construction or argument into the receiving account and recover its answer where required. State the conditions that make the transfer usable. A receiver needs the interpretation and relevant consequence; an equivalence label alone leaves the work to be reconstructed.
A changed primitive, quantifier range or allowed-map class can change the comparison. Revisit the affected construction and its argument. Keep conclusions whose ingredients and conditions are unchanged.
For mathematical work, the result may be an equivalence at the selected scope, a useful one-way interpretation or a separating consequence. For a computational or working-method application, C.29 and C.29.2 supply the further correspondence and execution questions. Mathematical agreement can then inform the application through those explicit connections.
MATH.18:5 - Archetypal Grounding
MATH.18:5.1 - Recover an order from an operation, then compare allowed maps
One account starts with a set S and a binary operation a∨b satisfying associativity, commutativity and idempotence:
(a∨b)∨c=a∨(b∨c); a∨b=b∨a; a∨a=a.
Another starts with a partial order in which every pair has a least upper bound. An upper bound of a and b is an element z with a<=z and b<=z. The least upper bound lies below every such z. Antisymmetry makes it unique. We want to move constructions between these descriptions.
From the operation, define a<=b to mean a∨b=b. Idempotence gives reflexivity. If a∨b=b and b∨a=a, commutativity gives a=b, establishing antisymmetry. If a∨b=b and b∨c=c, associativity gives:
a∨c=a∨(b∨c)=(a∨b)∨c=b∨c=c.
Thus the relation is transitive. Also a∨b is an upper bound of a and b. If z is any upper bound, then (a∨b)∨z=a∨(b∨z)=a∨z=z. So a∨b<=z and the original operation supplies the least upper bound.
Conversely, define a∨b to be the least upper bound in the ordered account. Uniqueness makes the operation commutative and idempotent. Both (a∨b)∨c and a∨(b∨c) are the least upper bound of the same three elements, giving associativity.
The round trips recover both primitives. Starting from the operation returns it as the least upper bound just proved. Starting from the order returns it because a<=b holds exactly when b is the least upper bound of a and b.
Now the intended use expands: can every order-preserving map be used as a map preserving the binary operation? A join-preserving map is monotone: apply it to a∨b=b. The converse fails. Take subsets of {u,v} ordered by inclusion, with union as join, and target {0,1} with its usual order. Define h to return 1 only on the full set and 0 on all other subsets. It is monotone, yet:
h({u} union {v})=1, while max(h({u}),h({v}))=0.
For constructions that combine joins, select join-preserving maps in both accounts. If all monotone maps are needed, retain that broader ordered account and its different transformation class.
MATH.18:5.2 - An enlarged domain changes the available solution
The natural numbers N={0,1,2,...} embed in the integers Z. Inclusion preserves 0, addition and equality of expressions evaluated on natural-number inputs. It also reflects those equalities: two included natural numbers are equal in Z precisely when they were equal in N.
Suppose the next task is to solve x+1=0. The integer solution x=-1 is outside N. The interpretation useful for additive calculations therefore has not supplied a natural-number solution.
To express the original existential question in Z, retain its range: “there exists an integer x with x>=0 and x+1=0.” That statement remains false. To use Z as a calculation space for another natural-number equation, compute there and test the recovered candidates against the source domain.
The revised use keeps the beneficial integer calculations and makes their return condition explicit. A demand to identify all natural-number and integer solution questions would instead fail this comparison.
MATH.18:5.3 - Compare linear maps with matrices, then add a length question
Additional structure – finite-dimensional real vector spaces. In one account, each space comes with a specified ordered basis, and maps between spaces are all linear maps. In the other, an object is a nonnegative integer n and a map n to m is an m-by-n real matrix. Maps compose by matrix multiplication.
For a space V with basis (b1,...,bn), let c_V:V -> R^n send a vector to its coefficients in that basis. Interpret f:V -> W by the matrix of c_W∘f∘c_V^(-1). Composition agrees because the adjacent coordinate conversion and its inverse cancel. Identity maps become identity matrices.
The return takes n to R^n with its standard basis and a matrix to its linear map. The round trip on matrices is literal. The round trip on V returns its coordinate space, with recovery supplied by c_V. For each f, the equation matrix(f)∘c_V=c_W∘f establishes the required compatibility. This compares the entire selected system of linear maps, including their compositions, rather than only matching vector values.
Now ask for lengths in Euclidean space. With basis b1=(1,0), b2=(0,2), coordinates (0,1) represent a vector of length 2; their ordinary coordinate length is 1. The linear comparison did not include the inner product. Carry it as a Gram matrix: here G=diag(1,4) and squared length is c^T*G*c. Retaining G lets us calculate the same vector’s length after changing coordinates.
A different question asks which linear maps preserve lengths. For a map from V to W represented by matrix M, with Gram matrices G_V and G_W, require M^T*G_W*M=G_V. This follows by comparing the squared length c^T*G_V*c of every input with (M*c)^T*G_W*(M*c) of its output. Use that condition to select the length-preserving maps. The earlier interpretation of arbitrary linear maps remains available when length preservation is not required.
MATH.18:5.4 - Recover an operation using a chosen origin
On the integers, one account supplies the ternary operation t(x,y,z)=x-y+z and a marked origin 0. It recovers addition as t(x,0,y) and negation as t(0,x,0). Conversely, addition and negation recover t. Substitution verifies both returns for every integer input.
Now remove the marked origin. Choosing any integer c gives an addition x+_c y=t(x,c,y)=x-c+y, identity c and inverse 2c-x. Combining these operations again gives the same t(x,y,z). The ternary operation alone therefore permits several choices of origin and corresponding binary operations.
For example, c=0 makes the sum of 2 and 3 equal 5; c=1 makes it equal 4 under +_1. Both choices recover the original ternary operation. A question using only t can continue without selecting an origin; recovering the former addition needs its marked origin again. This distinguishes a usable one-way interpretation from a return that silently supplies extra structure.
MATH.18:6 - Bias-Annotation
Familiar terminology can encourage an equivalence claim before the allowed operations and quantifiers have been compared. Follow one consequential construction through both accounts, then enlarge the claim only as far as its arguments support.
The categorical branch is useful when objects and maps are already the subject of comparison. Algebraic definitions, order relations and explicit logical translations can provide more direct constructions for other questions. Select the form that makes the required transfer inspectable.
MATH.18:7 - Conformance Checklist
For the comparison being used:
- The source, target, intended consequence and claimed scope are recoverable.
- Each required primitive has a constructed interpretation with its domain and assumptions.
- Needed preservation, reflection and recovery claims have arguments at that scope.
- Two-way claims inspect both composites and the compatibility required by the allowed operations.
- A failed claim identifies a changed answer or unavailable construction and determines the retained use or repair.
- The receiver can perform the intended transfer with the supplied result and conditions.
MATH.18:8 - Common Anti-Patterns and How to Avoid Them
Matching objects while silently widening maps. The order-and-join comparison recovers the objects, but its operation-preserving maps form a narrower class than all monotone maps. Select the class required by the next construction.
Solving the translated equation in an enlarged domain. The integer solution in :5.2 fails the original domain condition. Translate the quantifier range and check the return of any computed candidate.
Using an equivalence for added structure. The linear comparison in :5.3 supports linear operations. A length question adds an inner product and the obligation to carry it through the coordinate change.
MATH.18:9 - Consequences
Different mathematical descriptions can become usable alternatives with known transfers and returns. The comparison can also expose a useful one-way interpretation or a distinction that a proposed equivalence would erase.
The cost follows the scope. Recovering one primitive may settle a local use; comparing whole families of constructions requires their maps and compatibility laws. A changed task can reuse earlier results while examining the additional structure it now needs.
MATH.18:10 - Architectural Rationale
Organizing the method around a consequence keeps interpretation connected to mathematical work. Comparing objects, assertions and transformations prevents an object-level match from silently becoming a claim about every use.
The operation-and-order case reconstructs different primitives on the same carrier. The natural-number case exposes domain-sensitive assertion transport. The matrix case compares families of objects through compatible isomorphisms.
MATH.5 and MATH.7 remain direct construction methods for generator extension and bijective transport. This pattern supplies the wider comparison in which those methods may solve one part. MATH.17 supplies operations on operations when the interpretation itself must be constructed or transformed that way.
MATH.18:11 - SoTA-Echoing
Fong and Spivak’s Seven Sketches in Compositionality, §§1.2-1.3, develops order, joins and what their maps preserve. The adopted contribution is to compare an observation or transformation by the operations it carries, including the ones it loses. The order-and-operation construction here makes that question usable when the accounts start from different primitives.
Riehl’s Category Theory in Context, §1.5, supplies equivalence through functors and compatible isomorphisms. It supports the family-level comparison. A claim about translated theorems additionally depends on the chosen logic and interpretation.
For a prepared change of coordinates, explicit inverse maps can be enough. A broader account comparison becomes useful when available operations, assumptions or quantifiers differ. The present method combines these alternatives according to the consequence to be transferred.
MATH.18:12 - Relations
- MATH.5 constructs the interpretation of generated objects from its values on generators.
- MATH.7 transports mathematical structure through a supplied bijection.
- MATH.2 establishes when an interpretation and its operations descend through identification.
- MATH.16 constructs objects and comparison maps from required uses.
- MATH.17 constructs operation collections and higher-order transformations, including composition-preserving assignments.
- MATH.6 constructs a countermodel when an asserted transfer or equivalence fails.
- B.5.RA and B.5.TU recover an unfamiliar argument and carry a theoretical consequence into its intended case.
- C.29 and C.29.2 supply subject correspondence and computational formulation for applications of the mathematical comparison.