Contents

• Introduction
• Primer
• Notation
  • Directions, lines, and planes
  • Modifiers
  • Nouns
  • Verbs
  • Descriptors
  • User extensions
  • Verbless notation
  • Tips
  • List of special symbols
• Sample annotated formulas
• Notation dictionary (separate file for easy printing)

Introduction

What it is and who should care

• The purpose of this notation is not to instruct beginners. Learning the basic knots is easier than learning this notation. The purpose is to help advanced knotters (1) communicate without illustrations, (2) communicate details difficult to discern from illustrations, (3) record their experiments and discoveries, and (4) analyze different tying methods.
• Even for the simple task of recommending a certain knot to someone else, we can cite the knot's name, a page in a book containing illustrations, or a link to a web page containing an illustration or animation. But some knots have many names and some names apply to many knots; not everyone owns every knot book; and web pages are not accessible in all situations and do not remain accessible forever. Giving a notation formula is more precise than giving a name, more self-sufficient than giving a book citation, and more durable than giving a web link. Moreover, even when a name is unambiguous or a book is at hand, it's more helpful to give tying instructions along with unique identification than merely to give identification.
• For more complex tasks than identification, books and illustrations are not comparable to a precise notation. Non-trivial knot-tying methods cannot be described in words clearly enough to help a stranger —or if they can, at least it is so difficult that the best knot authors fail at it again and again. This is the need the notation is designed to meet.
• Even for those who master the notation, the purpose is not to read it quickly, like prose. The purpose is to have a precise record of a tying method that can be translated into action by anyone giving it the time. Don't be disappointed if you can't "sight read" a formula, or at least not right away. On the other hand, practice helps, and before long you'll be able to read a new formula without looking up any symbols and you'll be be able to scan a formula and zero in quickly on the steps that matter most.
• Mathematical knot theory has several systems of notation for describing the structure of knots already tied. By contrast, the present notation describes methods of tying knots. Identifying a tying method is an indirect way of identifying the knot tied by that method, of course, and its structure. But there's still an important difference between a notation for knots and a notation for tying methods. One reason is simply that there are many different methods for tying the same knot, just as there are many different programs for computing the same function.
• A second reason is that a good notation will be flexible enough to allow more than one formula even for the same tying method. A good notation will capture micro-variations in the method from tyer to tyer, different ways of dividing the method into stages, different decisions about how much optional detail to include, and even fundamentally different ways of representing the same method. This notation is flexible in these ways. In that sense it is like a programming language that allows different programmers to write the same algorithm in different ways.
• Some knot tying methods have many steps, and some of the steps require many symbols to represent precisely. As a result, very few notation formulas are short. They may look more like computer programs than encoded names. But the reason is that they are much more like programs than encoded names.
• If you know some mathematical knot theory, then you might have this question:  Why don't the Reidemeister moves constitute a knot tying notation? Or, if the Reidemeister moves are so simple, and yet provably sufficient to their task, then why is this notation so complex? The answer has two parts. (1) The Reidemeister moves are equivalence-preserving and the steps in a tying method are not. (2) The Reidemeister moves reduce a large set [of equivalence-preserving moves] to a minimal set, but this notation aims to capture as many as possible of the moves actually in use by experienced knot tyers even if a smaller set would suffice to replace them.

  If you're impatient to get on to the notation itself, then jump to the primer.

Adequacy v. manageability

• The more you know about knots, the more you appreciate the vastness of this space. To tie the 10 most common knots, you need many more than 10 basic hand and cord movements. Learning these movements will certainly help with the next 10 most common knots, but they will not suffice. After you know 100 knots, you still won't have learned all the movements needed for the next 100. To tie all the attested useful knots requires an uncharted variety of movements.
• On the one hand, I want this notation to be adequate for most of the knots you will ever want to tie or notate. On the other hand, I want it to be easy to learn and use. Unfortunately, these virtues are in tension. We can have one or the other, probably not both.
• If the notation contained a "verb" for every movement needed in every tying method, then the notation would be huge and difficult to learn. But if it doesn't contain a needed verb, then it isn't adequate. A pessimist would say that either the notation is small and inadequate or large and difficult to learn. An optimist would say that either it's large and adequate or small and easy to learn.
• To make the notation manageable, I've made it inadequate. Unfortunately, while the notation is smaller and easier to learn than an adequate notation would be, it's still large enough to be difficult to learn. On the other side, I've introduced two strategies that effectively bridge the inadequacy gap without complicating the notation (verbless notation and user extensions).
• The trade-off between adequacy and manageability arises from the staggering variety of knot tying methods. It can be mitigated but not eliminated by an elegant and efficient notation. I'm not claiming that this notation is unsurpassable in its efficiency. But after many paradigm shifts in its evolution, and many refinements, I am willing to claim (to borrow a phrase from Robert Nozick) that it's good enough to be worth surpassing. I welcome attempts to do so, and regard the notation as open to further revision and improvement.
• The complexity differs for verbs and nouns. Verbs represent actions to take with hands, cord, and other objects. Nouns represent the hands, cord, and objects. An adequate notation would have a much larger number of verbs than nouns. But on the other side, all the verbs can be specified in advance, which is not true for the nouns. For example, at a given stage in a certain tying method, you might have to reach the thumb and forefinger of your right hand through a certain loop, grab a certain cord, and pull it back through the loop. The fingers can be named in advance and the actions of grabbing something and pulling it in a certain direction can be named in advance. But the loop through which to make the pinch and grab cannot be named until it is created at an earlier stage in the tying process. The same is true with the cord segment to be grabbed and pulled.
• While not all parts of the cord can be named in advance, this notation offers a way to name them as they are created. (Through recursion, it even offers a way to refer to particular structures without naming them.) In fact, the pre-defined nouns in the notation should be adequate for all parts of the hands and cord used in knot tying. If its stock of nouns is inadequate, it's only for other physical objects that might enter a particular tying method, such as spars, sheets, anchors, cleats, bollards, rings, pulleys, carabiners, toggles, fids, and fishhooks. These auxiliary nouns enter the notation through user extensions.
• By contrast, the notation is not adequate for verbs even though, once identified, these can always be named in advance. Here is where we feel the trade-off between adequacy and manageability. An adequate set of verbs would simply be unmanageable. At this stage in the evolution of the notation, my choice of manageability over adequacy means that I'd rather have a fairly simple and learnable notation adequate for about 80% of useful tying methods than an extremely complex notation that is adequate for 98%. Even if we would gladly master the complexity of an adequate notation, it might take a nearly endless approximation process to enlarge the notation's verb stock enough to handle 100% of the known, useful tying methods.
• If we analogize knot-tying verbs to the natural numbers, I've tried to find the prime verbs, or the elemental actions that can be combined to produce the composite verbs used in physical knot tying in three-dimensional space. If the notation omits any prime verbs, then it cannot describe basic actions. If it contains any composite verbs, then it is more complex than necessary. Whether all my verbs are prime, and whether all prime verbs are present, are difficult open questions. I welcome reader feedback on this.
• (While it's useful to know which verbs are composite, it's also useful to pre-define some of them in the notation. This unnecessary complexity can save the labor of rediscovering how to use the prime verbs to describe what they describe. So the notation deliberately contains a few composite verbs —syntactic sugar, as programmers might say— but is careful to label them as such.)
• The notation described here is adequate for the following kinds of knot tying and line handling.
  • tying most practical knots —hitches, bends, loops, lashings, nooses, shorteners, and stoppers
  • untying
  • coiling
  • snubbing
  • frapping
  • flypping (or deliberate capsizing)
  • trambles (or partial untying and retying to make a new knot)
  • fid and spike work other than splicing
  • most knots tied with or around physical objects
  • rigging that uses multiple knots, multiple cords, or both
• The notation is not yet adequate for the following kinds of knot tying and line handling. It could be enhanced to cover these; and if the enhancements were consistent with the rest of the notation and reasonably manageable, they would be desirable. The fact that the notation doesn't yet cover them means either (1) that I haven't had time to incorporate them or (2) that I haven't found adequate enhancements that keep the notation consistent and manageable. But in either case, I welcome suggestions from users. The limit on the notation's adequacy is a moving frontier.
  • fancy or decorative knots, such as sinnets, beckets, and turks heads
  • knots taking advantage of the flatness of webbing or neckties, e.g. the water knot or Windsor knot
  • knots taking advantage of the hollowness of webbing, e.g. the beer knot
  • splicing (nouns and verbs)
  • whippings and seizings
  • related arts such as knitting, macrame, basketry, and string figures
• There's an important difference between the adequacy of the notation to cover a certain method and the ease of discovering how to record that method with the notation. The same distinction applies to every language. Can you describe driving directions from your home to the nearest point exactly 1,000 feet above sea level, the policy differences between Republicans and Democrats on deficit spending, or why a mirror reverses images left to right but not top to bottom? The adequacy of English for each of these jobs can be presupposed, but that does not make the jobs any easier. With difficult tying maneuvers, the notation is no different.
• There is an important difference, of course. When something is hard to describe in English, only poor writers would blame English before blaming themselves. But if something is hard to describe in this notation, the fault might lie in the notator or the notation. I want to know about inadequacies not already on my list above. Nevertheless, the analogy to English holds in this respect:  where the notation is adequate, its adequacy will not make its use easy or automatic. Using a small set of tools for a large set of jobs requires skill, understanding, and practice.
• This notation tames the complexity of knot tying through several strategies and conventions.
  1. It opts for manageability over completeness.
  2. Where it is incomplete, it can be supplemented with user extensions. This not only closes much of the gap of incompleteness, but makes the notation flexible for unusual applications.
  3. Where its stock of pre-defined verbs is inadequate and users would prefer not to define their own, they can use verbless notation. This also closes much of the gap of incompleteness without complicating the notation with extra verbs.
  4. It assumes that the only salient directions are fore, aft, left, right, up, and down. (Call this the FALRUD convention.) This convention greatly simplifies the notation and needn't cramp anyone's tying style.
  5. It construes the shapes of common cord structures as pointing in certain directions. Together with the convention recognizing only six salient directions, this allows us to orient cord structures in space in precise ways.
  6. Not every cord segment and structure is named. Only those that need to be named are named. Of those, the ones that are not pre-defined and pre-named can all be named as soon as they are created.
  7. It makes several verbs and descriptors somewhat complex in order to make them general. That makes the introduction of many more verbs and descriptors unnecessary.

What's coming

• There are bits and pieces of knot tying notation in various books by other authors, but I believe this is the first attempt at a knot tying notation of general application. As I revise and enlarge these files, I will include a bibliography of the earlier work.
• Although this notation makes illustrations in tying instructions unnecessary, some illustrations would make the notation itself easier to learn. I haven't had time to make these, and will add them in future updates.
• I plan to add an alphabetical or taxonomic index of the pre-defined words and symbols.
• I expect two kinds of syntax revisions: (1) refinements to make the existing syntax more elegant, economical, consistent, or mnemonic, and (2) extensions to make it more adequate. I didn't make the notation public until I thought the number of the former was likely to be less than the number of the latter.

Primer

• The basic unit of this notation is a sentence with predicate-term structure. The predicate is whatever we say about the subject. The subject is a noun or noun phrase. Because noun phrases ("the black dog", "the dog behind the shed") are not nouns, but can function as nouns, the word "noun" does not capture them. So let's use the more general word "term". A term is a noun or a noun phrase. A sentence consists of a term acting as the subject, and a predicate saying something about the subject. Some sentences make claims about more than one object; these sentences have more than one term. We write predicates first, and then list the terms to which they apply, in parentheses.
  Predicate(term, term, term...)

• The number of terms allowed in the parameter list (the list within parentheses) varies from predicate to predicate.

• (Much of this will be familiar to those who know predicate logic. However, no predicate logic is needed to understand this notation.)

• Here's a real example.

  R(RP, SP)

  The running part is to the right of the standing part. Here "R" is the predicate, "is to the right of". RP and SP are terms, standing for the running part and the standing part. Note that for many predicates, such as R, sequence matters in the parameter list. R(SP, RP) would mean the opposite of R(RP, SP).

  If you're a quick learner, or just impatient, skip most of the text and look for the blue and green examples throughout the file. The code is in blue and annotations are in green. If you study the examples, you'll understand just about all you need to know.

• The notation does contains nouns, but the basic role of being the subject of predication is played by terms (nouns or nouns plus their modifiers).

• If we're using more than one cord, for example to tie a bend, then the term RP for the running part is ambiguous. To say that it's the running part of cord #1 we need a way to name different cords and a way name different running parts. We introduce the single-dot modifiers for this purpose.

  C.1	Cord #1. The dot stands between the term being modified and its modifer.
  RP.C.1	The running part of cord #1.

• If we want to say that the running part points up, then we need a second kind of modifier. "Points" is the predicate, "RP" is the term. "Up" is a modifier telling us how how RP points. Modifiers that tell us which one use single dots (as in the examples above). Modifiers that tell us how use double dots.

  PT(RP:U)	The runnning part points up.
  PT(RP.C.1:U)	The running part of cord #1 points up.
  PT(BT.3L:R)	The third bight from the left points right. "BT" is the term for bight.
  PT(RP:R, SP:L)	The running part points right and the standing part points left. Here the parameter list contains two terms. Unlike the R predicate, the order of terms for the PT predicate does not matter.

• Naming an object is a "which one" modifier and should use the single dot notation. But we use the "=" symbol because it makes strings of modifiers easier to decipher and it's easier to find when scanning quickly for a name definition.

  ML(RP=LP.1)	Make a loop in the running part and name it LP.1 (loop #1). The naming modifier allows us to name cord structures as they are created, if we need to refer to them again later.
  ML(RP.C.1=LP.1)	Make a loop in the running part of cord #1 and name it LP.1.

• It doesn't always matter whether a movement is a push or a pull. But when it does matter, we need a modifier to tell us how to perform the action. This is a "how" modifier and should use the double dot notation. But use the "^" notation because it makes the difference between pushing and pulling more mnemonic.

  MV(RP:R)	Move the running part to the right. There are no push-pull modifiers.
  MV(RP^:R)	Pull the running part to the right.
  MV(^RP:R)	Push the running part to the right. In short, if the ^ symbol precedes a term (in the MV verb and a few others), then the tyer pushes; if it follows the term, then the tyer pulls.
  MV(RP^:R, SP^:L)	Pull the running part to the right and the standing part to the left. This is a common way to finish a knot.

• When we want to put the running part and standing part together, and treat them as if they were one, we use square-bracket cluster notation.

  MV([RP, SP]^:R)

  Pull the running part and the standing part together to the right. "[RP, SP]" represents the cluster of RP and SP and tells the tyer to treat them as one object. The cluster is a single term. All modifiers to the term go on the outside of the brackets.

• We've now seen nearly every kind of term from the most simple to the structured. Here's a review of the ones covered so far (and preview of the rest) in ascending order of complexity:

  C, E, T, BT, LP, RH...	Simple or unmodified terms. These stand for cord, end, turn, bight, loop, and right hand. There are others below in the section on nouns.
  C.1, E.2, T.1, BT.3, LP.2...	Terms with name modifiers.
  LP.L, LP.3L, BT.D...	Terms with non-name modifiers. These stand for the loop on the left, the loop third from the left, and the bight on the bottom (D for down).
  LP.L(LP.1)...	A term with a predicate modifier. This one means the (unnamed) loop to the left of loop #1.
  LP.L(LP.1:3in)...	A term with a predicate modifier containing both single dot and double dot modifiers. This one means the (unnamed) loop 3 inches to the left of loop #1.
  [RP, SP], [LP.1, LP.2]...	Clusters of terms, which may themselves be complex.

• Now that we've seen the permissible variety of terms, let's return to the general recipe for a notational sentence:
  Predicate(term, term, term...)

• Any kind of term may serve in a term position, from the most simple to the most complex. Learn to identify which symbols in a formula describe terms, and see what role they play in larger sentences.

• The notation asks you, the notator, to break the tying process into stages. This can be somewhat arbitrary, but the arbitrariness creates no problems. If it helps to break a particular tying method into more stages, then do so and write a longer formula. Beginning tyers generally benefit from seeing more stages spelled out and illustrated. Advanced tyers generally get the right idea from a much smaller clue. Details not needed by the intended reader can be omitted.

  * GP(RP, RH)	Grip the running part with the right hand. The initial asterisk marks a new stage.
  *1 GP(RP, RH)	Same as the previous example, but showing that the stages can be numbered.
  * GP(RP, RH), GP(SP, LH)	Grip the running part with the right hand and the standing part with the left hand. These two sentences belong to the same stage. A stage may have as many sentences as you like. Putting them all in one stage means that they are all to be performed, or are all true, at the same time.
  * GP(RP, RH) * PT(E.RP:U)	This example has two stages. First grip the running part with the right hand, then make the end of the running part point up.
  * GP(RP, RH), * PT(E.RP:U)	Same as the previous example, but showing that stages needn't be written on separate lines (though I will write them on separate lines for extra clarity). The asterisks suffice to separate them.

• All the predicates in this notation are either verbs or descriptors. Verbs tell the tyer what to do. Descriptors tell the tyer what things should look like. In standard or verbed notation, stages generally begin with verbs and are followed by descriptors. In verbless notation, stages contain only descriptors. Here's a typical stage in verbed notation:

  * MB(RP=BT.2), R(BT.2, BT.1)	Make a bight in the running part and name it BT.2 (bight #2). It should be to the right of bight #1. MB is a verb telling the tyer what to do (make a bight). R is a descriptor telling the tyer how things should look.
  * MB(RP=BT.2), R(BT.2, BT.1), PN(BT.2:HP)	Like the previous example but with two descriptors. The new descriptor tells the tyer that bight #2 is in the horizontal plane.

• In verbless notation, tyers are left to their own devices to figure out how to make the cord match the descriptions, just as they are when taking instruction from photographs of separate stages of a tying method. I don't cover verbless notation in this primer, though I do cover it later in the document.

• A given formula can have as many stages as you wish. A given stage can have as many verbs and descriptors as you wish. (I'll often use "verb" and "descriptor" as shorthand for "sentence whose predicate is a verb" and "sentence whose predicate is a descriptor".)

• You cannot tell by looking at a predicate whether it is a verb or descriptor; you must know what the predicates mean for this. On the other hand, virtually nothing depends on this classification.

• Similarly, you cannot tell by looking whether sequence in the parameter list matters for a given predicate; you must know what the predicate means for this. But this does matter. As noted, R(SP, RP) and R(RP, SP) have opposite meanings.

• The sequence of predicates within a stage never matters, since they are all true at the same time. However, it's usually clearer for the tyer to see verbs before descriptors.

• Time is what distinguishes one stage from another. All the verbs in the same stage are to be performed at the same time. All the descriptors in the same stage are true at the same time. The asterisk marking a new stage in effect says, "next do this" or "next it should look like this".

• Each term, verb, and descriptor can be written as a whole word or as an abbreviation. The former brings clarity, the latter brevity. Use the style that suits your needs. When you know the abbreviations well, they can bring both clarity and brevity.

  * MakeBight(RunningPart=Bight.2), Right(Bight.2, Bight.1), Plane(Bight.2:HorizontalPlane)

  This is the same as the last example from the previous set, using whole words instead of abbreviations.

• The full-word notation is not case sensitive. With one exception, the same is true of the abbreviation notation. The exception is for "U", which means up, and "u", which means "unit".

• A syntactically correct string of this notation is called a formula. A formula may represent a complete knotting method or any part of one.
  • A formula contains stages. Stages are separated by asterisks. A stage represents actions to perform at the same time, or descriptions that are true at the same time.
  • Stages contain sentences. Sentences start with predicates (verbs or descriptors), followed by parentheses, within which are parameters (terms). Sentences within the same stage are separated by commas. Parameters within the same sentence are separated by commas. Verbs, descriptors, and terms may be whole words or abbreviations for them.
  • Parameters and sentences might have modifiers. If so, the parameter or sentence is immediately followed by a dot (like a decimal point) or two dots (like a colon) and the code (word or abbreviation) for the modifier.

Notation

Directions, lines, and planes

• For simplicity we assume that the only salient directions are fore, aft, left, right, up, and down. Call this the orthogonality or FALRUD convention. (FALRUD = Fore Aft Left Right Up Down.)
  • The six directions are relative to the tyer —or more precisely, relative to the growing knot in front of the tyer. Left, right, up, and down are already clear. Fore is the direction in front of the tyer and knot. Aft is the direction behind the knot, though sometimes in front of the tyer.
  • The six directions form three mutually perpendicular lines (fore-to-aft, left-to-right, up-to-down). Each pair of these lines determines a plane. This results in three mutually perpendicular planes:  the horizontal (determined by the fore-aft and left-right lines), the vertical (determined by left-right and up-down) and what we'll call the edge plane (determined by fore-aft and up-down). Unfortunately, we don't have familiar words to differentiate vertical plane that faces us like a wall from the vertical plane that faces us edge-on. Here I'm calling them the vertical and edge planes, respectively.
  • As far as the notation can tell, all structures of cord that point in some direction, and all actions that move in some direction, point or move in one of these six directions. All crossings are perpendicular. All straight cord segments are parallel to one of the three lines. All two-dimensional cord structures, like loops and bights, are parallel to one of the three planes. In practice, movements are continuous and positions arbitrarily intermediate. But we can't afford separate names for every possible direction, line, and plane, and fortunately we don't need them.

• Directions

  • Direction symbols are usually modifiers. But they can also act as descriptors. They can even act as both at once.

  • Directions relative to the tyer

    • Fore, Aft or F, A
    • Left, Right or L, R
    • Up, Down or U, D

    • Each of these can be preceded by a number. For example, BT.2L means the second bight from the left.
    • Note that the direction U (up) uses the same letter as the unit u which equals the cord's diameter. These two letters are case sensitive, but the rest of the notation is not.
    • For the use of these symbols as descriptors, see the direction descriptors.
    • For the reasons why we only recognize six directions, see the FALRUD convention above.

    BT.L	The bight on the left. The leftmost bight.
    BT.3L	The third bight from the left.
    PT(BT.1:U)	Bight #1 points up.
    MV(BT.1^:A)	Pull bight #1 aft.
    TW(E.RP:CW:R)	Twist the end of the running part clockwise, as viewed from the right.

    • Clockwise, Counterclockwise or CW, CCW

    • When twisting a cord or other object, the two directions are clockwise and counterclockwise. Since a clockwise twist appears counterclockwise when viewed from the opposite side, we must indicate the side from which we are viewing. The viewing direction is relative to the tyer and must be one of the six (F, A, L, R, U, D). For more details, see the Twist verb.

    TW(E.RP:CW:R)

    Twist the end of the running part clockwise, as viewed from the right.

  • Directions relative to the cord

    • End.StandingPart or E.SP
    • End.RunningPart or E.RP

    • When a descriptor tells us that something is "next along the cord" to something else, it could be toward one end of the cord or toward the other. These two directions are indicated by the names of the two ends.
    • Similarly, bights, fingers, spikes, and other objects have ends that can used to indicate a direction along them.

    NX(LP.2, LP.1:E.RP)	Loop #2 is next along the cord to loop #1, when we start with loop #1 and move toward the end of the running part.
    NX(CR.1, CR.2:E.BT.1)	Crossing #1 is next along the cord to crossing #2, when we start with crossing #2 and move toward the end of bight #1.
    NM(E.Toggle.R=E.2), NX(T.2, T.1:E.2)	The end of the toggle now on the right will be named E.2. Turn #2 is next along the toggle to turn #1, when we start with turn #1 and move toward E.2. Here "Toggle" has entered the formula as a user extension.

• Lines

  • Contrary to usage at sea, these lines are imaginary Euclidean lines, not segments of cord.
  • ForeAft or FA
    • This is a horizontal line from in front of the tyer to behind (or through) the tyer or vice versa.
    • If different FA lines have to be named, then we can have FA.1, FA.2, etc.
    • An FA line through a certain point can take the point name as a modifier.

  • LeftRight or LR
    • This is a horizontal line from the tyer's left to the tyer's right or vice versa.
    • If different LR lines have to be named, then we can have LR.1, LR.2, etc.
    • A LR line through a certain point can take the point name as a modifier.
  • UpDown or UD
    • This is a vertical line from above the tyer to below or vice versa.
    • If different UD lines have to be named, then we can have UD.1, UD.2, etc.
    • A UD line through a certain point can take the point name as a modifier.

    LR.CR.1	A left-right line passing through crossing #1.
    FA.E.BT.1	A fore-aft line passing through the end of bight #1.
    NM(UD.ST.1=UD.1)	The up-down line passing through site #1 will be named UD.1.
    PT(BT.1:U), NM(LR.E.BT.1=LR.1), TW(E.BT.1:CW:LR.1:R)	Bight #1 points up. The name of the LR line passing through its end is LR.1. Twist the end of BT.1 clockwise on the axis formed by LR.1 as viewed from the right. It will usually be enough to say TW(E.BT.1:LR:R), i.e. twist the end of BT.1 on an LR axis (without specifying exactly which one), as seen from the right.

• Planes
  • HorizontalPlane or HP
    • This is the plane that passes through the knot and stays parallel to the ground.
  • VerticalPlane or VP
    • This is the vertical plane that passes through the knot and faces the tyer like a wall.
  • EdgePlaneor EP
    • This is the vertical plane that faces the tyer edge-on, or that passes through the knot and through the center of the tyer's body from head to foot.

    PN(LP.1:HP)	Loop #1 lies in the horizontal plane.
    PN(BT.2:VP)	Bight #2 lies in the vertical plane.
    PN(LH:EP)	The left hand lies in the edge plane.

Modifiers

• Modifiers are like subordinate clauses that tell us something about the nouns or sentences they modify. They are introduced by dots (periods and colons) immediately following the codes they modify.
• The single dot (".") means "which one". The double dot (":") means "how".
• Serial or nested dotting is permissible, just as serial or nested subordinate clauses are permissible in English.
• All descriptors may be used as modifiers. (The English equivalent is when a full sentence can be used as a subordinate clause.) When the object being modified is a parameter inside another descriptor, then we have recursion: descriptors nested inside descriptors. Some examples are listed below and others are found throughout the document.
• When a descriptor is used as a modifier, then the object it modifies acts as its first parameter. Hence two-parameter descriptors become one-parameter descriptors, and so on.

  LP.1	A loop, but which one? Loop #1.
  E.RP	An end, but which one? The end of the running part (RP).
  ML(RP.C.2)	Make a loop in which running part? The running part of cord #2.
  MV(E.RP^:L)	Pull E.RP. But how? Pull it to the left.
  RV(E.RP, LP.1:L-R)	Reeve the end of the running part through loop #1. But how? From left to right.
  TW(E.RP:CW:R)	Twist the end of the running part. But how? Twist it clockwise. How clockwise? Clockwise as viewed from the right. (Strings of dotted modifiers are unambiguous if you remember that "." means "which one" and ":" means "how". Be patient in sorting them out.)
  MV(E.RP^:R, E.SP^:L).C.2	Pull the end of the running part to the right and the end of the standing part to the left. Which running and standing parts? Those of cord #2. Here C.2 is a modifier to the whole sentence.
  NM(CS.F(LH)=CS.1)	The cord segment fore of the left hand will be named CS.1. Here a descriptor, F(LH), is used as a modifier. Normally this is a two-parameter descriptor, F(x,y) (x is fore of y), but when used as a modifier, the object it modifies plays the role of its first parameter.
  NM(CS.RV(LP.1)=CS.1)	The cord segment reeving through loop #1 will be named CS.1. Here RV is a descriptor used as a modifier; the object it modifies plays the role of its first parameter.
  MT(RP, Tree.1:CW:U):2	Make turns around tree #1. But how? Clockwise as viewed from above (up). How many? Two. Here the numeral 2 is a modifier to the whole sentence.

Nouns

• Some nouns are pre-defined and some are defined contextually as they are created during a tying method. The former are most like improper nouns, or nouns that point to types of things. The latter are most like proper nouns, or nouns that name individual instances or tokens of the pre-defined types.

• Nouns for parts of the cord

  • Currently the notation should be adequate for all the exterior parts of the cord (ends, loops, bights, etc.) and inadequate only for the interior parts of the cord used in splicing.

  • Bight or BT
    • Bights can be treated as loops, for the sake of their openings. They can also be treated as cords, for tying knots without using the ends. Often they are treated as both in succession.
    • If different bights have to be named, then they are BT.1, BT.2, and so on.

    MB(RP=BT.1)	Make a bight in the running part and name it BT.1 (bight #1).
    PT(BT.1:U)	Bight #1 points up.
    TW(BT.1:CW:U)	Twist bight #1 clockwise (along its pointing axis) as seen from above.
    RV(BT.1, LP.1:D-U)	Reeve bight #1 through loop #1 from down to up.
    RV(E.RP, BT.1:L-R)	Reeve the end of the running part through bight #1 from left to right.
    ML(BT.1=LP.1)	Make a loop in bight #1 and name it LP.1.
    MV(E.RP:L, ST.1:R), RS(BT=BT.2)	Move the end of the running part to the left, and move site #1 to the right. This results in a bight, which will be named BT.2 (bight #2).

  • Cord or C
    • If different cords have to be named (e.g. for a bend or a complex rig), then they are C.1, C.2, and so on.
    • The cord name can always be attached as a modifier to any other noun representing a part of a cord.
    • The cord name can also be attached as a modifier to an entire verb or descriptor.
    • When a verb uses two or more cords, you may use the cord modifier on individual parameters or on the whole sentence.

    ML(RP.C.2=LP.1)	Make a loop in the running part of cord #2 and name it loop #1. After this, we know that LP.1 names a loop on cord #2. Hence, it will be unnecessary to write LP.1.C.2 later in the formula; LP.1 will suffice.
    ML(RP=LP.1).C.2	Same meaning as the previous example. (Putting the modifier outside the whole sentence is most useful when the sentence takes many parameters, and all describe parts of the same cord.)
    MV(E.RP.C.1^:L, E.RP.C.2^:R)	Pull the end of the running part of cord #1 to the left and the end of the running part of cord #2 to the right. We could write the same instruction this way, MV(E.RP.C.1^:L, E.RP^:R).C.2. The cord modifier on the whole sentence modifies all the parameters without their own local cord modifiers (in this case just the second parameter).
    NM(E.RP.C.1=E.1, E.RP.C.2=E.2), MV(E.1^:L, E.2^:R)	Same meaning as the previous example. But here we name the cord structures in advance, making sure that their name definitions tell us which cords they belong to. Then we can the names without further identification of the cord. These two sentences tell the tyer to use the name E.1 for the end of the running part of C.1, and the name E.2 for the end of the running part of C.2; then pull E.1 left and E.2 right.

  • CordSegment or CS
    • If different segments have to be named, then they are CS.1, CS.2, and so on.
    • The length of a cord segment can be indicated in a modifier.

    CS.1:20u	Cord segment #1 is 20 units long. The unit of length is one cord diameter.
    BN(CS.1, CR.1, CR.2)	Cord segment #2 lies between crossing #1 and crossing #2.
    BN(CS:20u, CR.1, CR.2)	The (unnamed) cord segment between crossing #1 and crossing #2 is 20 units long.
    NM(CS.A(LH)=CS.2)	The cord segment aft of the left hand will be named CS.2.

  • Crossing or CR
    • The place where two cords or cord segments cross.
    • If different crossings have to be named, then they are CR.1, CR.2, and so on.
    • To indicate what is over and what is under in the crossing, use the CrossOver (CO) descriptor.

    CR.LP.1	The crossing in loop #1 (i.e. the crossing that closes the loop).
    MV(E.RP:L), RS(CR=CR.1)	Move the end of the running part to the left. This results in a crossing, which will be named crossing #1.
    BN(CS.1, CR.1, CR.2)	Cord segment #1 lies between crossing #1 and crossing #2.
    GP(CR.LP.1, [LF.1, LF.2])	Grip the crossing of loop #1 with the left thumb and forefinger.

  • End or E
    • The end of a cord, bight, finger, or object.
    • If there is more than one end to be named, then we may refer to E.1, E.2, and so on.
    • The end of the running part (E.RP) is often called the "bitter end" or "working end".
    • The end of a bight is the closed rather than the open end. It's the end where the cord changes direction.
    • Nouns for ends may also be used as directions relative to the cord.

    E.RP	End of the running part.
    E.SP.C.2	End of the standing part of cord #2. If this reference is too long for repeated use, then shorten it with a name: NM(E.SP.C.2=E.1), name the end of the standing part of cord #2, E.1 (end #1).
    E.BT.1	End of bight #1.
    MB(RP.C.2=BT.2), NM(E.BT.2=E.2)	Make a bight in the running part of cord #2, name it BT.2. Name its end E.2. (After these two sentences, you may refer to E.2 without specifying which bight or cord the end belongs to.)
    RV(E.Spike.L, LP.1:R-L)	Reeve the left end of the spike through LP.1 from right to left. This assumes that you've already introduced "Spike" as a user extension.

  • Eye or EY
    • Any opening other than a loop or link eye. For example, the interior of a bight forms an eye, as does the hexagonal opening created by six different cord segments in a jury mast knot.
    • See the LinkEye for a special kind of eye.

    EY.BT.2	The eye of (in the center of) bight #2.
    EY.K	The eye in (the center of) the knot.
    ~RV(LF.2, K:R-L), RS(EY=EY.1)	Unreeve the forefinger of the left hand from the knot (i.e. pull it out from what is enclosing it), from right to left. This results in an eye, which will be named EY.1.
    MV(BT.1:L) ® CO(BT.1, BT.2), RS(EY=EY.1)	Move bight #1 to the left until it crosses over bight #2. This results in an eye, which will be named EY.1.

  • Knot or K
    • We need this noun when we are describing multiple knots in a single formula (e.g. the two halves of the grapevine knot, the trucker's hitch secured with two half-hitches, any knot with a safety knot, and any complex rigging with multiple knots) or when we want to perform an action on the entire knot as it exists at a certain stage (e.g. flip it over to work on its other side).
    • If different knots have to be named, then they are K.1, K.2, and so on.

    MV(E.RP^:R, E.SP^:L), RS(K=K.1)	Pull the end of the running part to the right and the end of the standing part to the left. This results in a knot, which will be named K.1.
    RV(K.1, K.2:L-R)	Reeve knot #1 (say, a stopper knot) through knot #2 (say, a loop knot), from left to right.

  • LinkEye or LE
    • A link eye is the opening (eye) where two cords, or two parts of the same cord, link. Picture two intersecting (linked) circles, like a Venn diagram; the oval inside each is the link eye. When two linked cords are pulled in opposite directions, the link eye is closed rather than open; but it's still a link eye.
    • I haven't seen any common terminology for these. Chisnall calls them "elbows", and calls two adjacent elbows a "twist" (Chisnall at p. 18). But since these terms are not in general use, and no others are in general use, I've coined a term that I believe is fairly perspicuous.
    • If different link eyes have to be named, then they are LE.1, LE.2, and so on.

    [Assume that K.1 is an overhand knot.] PT(K.1:U), NM(LE.L=LE.1, LE.R=LE.2)

    Knot #1 points up. (A loop points in the direction of its crossing.) The link eye on the left will be named LE.1, and the one on the right will be named LE.2. (Overhand knots contain two link eyes.)

  • Loop or LP
    • A loop is a closed circle made of one cord segment crossing itself. This notation distinguishes loops from bights, eyes, and link eyes for those occasions when the distinctions matter.
    • If different loops have to be named, then they are LP.1, LP.2, and so on.

    ML(RP=LP.1)	Make a loop in the running part and name it LP.1 (loop #1).
    ML(/RP=LP.1)	Make a "slash" or "Z" or "right-handed" loop in the running part and name it LP.1. We only include the \ or / symbols when it matters whether the loop is a backslash or slash ("S" or "Z", left- or right-handed) loop. The difference between the two kinds of loop is explained more fully under the MakeLoop verb below.
    PT(LP.1:U)	Loop #1 points up. (Loops point in the direction of their crossings.)
    PN(LP.1:VP)	Loop #1 lies in the vertical plane.
    RV(E.RP, LP.1:A-F)	Reeve the end of the running part through loop #1 from aft to fore. This direction of reeving (from aft to fore) only makes sense when the loop lies in the vertical plane.
    NM(LP.R=LP1)	The loop on the right will be named LP.1.
    TW(E.RP:CW:R) ® RS(LP=LP.1)	Twist the end of the running part clockwise, as viewed from the right, until a loop results, and name that loop LP.1.

  • RunningPart, StandingPart or RP, SP
    • The running part is the length of cord closest to the active ("running") end in tying. The standing part is the rest. When a cord has a load at one end a hitch at the other, the load is on the standing part and the hitch is tied in the running part.
    • When a bight is long enough to manipulate like a cord, then it too has a running part and a standing part. The running part of a bight is the part closer to the bight's end. The standing part of a bight is the rest.

    E.RP	The end of the running part.
    RP.C.2	The running part of cord #2.
    RB.BT.1	The running part of bight #1. The running part of a bight is the part closest to its active end, just as with a cord.
    MB(RP)	Make a bight in the running part.
    NM(E.RP.C.2=E.2)	The end of the running part of cord #2 will be named end #2.
    RP.BT.1	The running part of bight #1.
    E.RP.BT.1	The end of the running part of bight #1.
    RV(E.RP.BT.1, LP.1:L-R)	Reeve the end of the running part of bight #1 through loop #1, from left to right.

  • Side or SD
    • This noun refers to the side of any object that has a discernible side, e.g. a loop, bight, eye, link eye, turn, knot.
    • If different sides have to be named, then they are SD.1, SD.2, and so on.

    SD.L	The left side.
    SD.L.LP.1	The left side of loop #1.
    GP(SD.R.LP.2, [RF.1, RF.2])	Grip the right side of loop #2 with the thumb and forefinger of the right hand.
    PT(BT.1:R), GP(SD.U.BT.1, [LF.1, LF.2])	Bight #1 points right. Grip the up side of bight #1 with the thumb and forefinger of the left hand.

  • Site or ST
    • A site is a point or spot on the cord or other object. It could be the point where the cord is gripped or a point x units from another point in a certain direction. The point where two cords cross is better described as a crossing (CR) than a site.
    • If different sites have to be named, then they are ST.1, ST.2, and so on.

    BT(CS:20u, ST.1, ST.2)	The cord segment between site #1 and site #2 is 20 units long.
    NM(ST.R(ST.1:10u)=ST.2)	The site to the right of site #1 by 10 units will be named site #2.
    NM(ST.NX(ST.1:E.RP:20u)=ST.2)	The site which is next along the cord 20 units from ST.1 when moving toward the end of the running part will be named ST.2.
    NM(ST.GP(RF.1, RF.2)=ST.1)	The site where the thumb and forefinger of the right hand are gripping the cord will be named site #1. For shorthand, we will usually name this site in the same instruction telling the tyer to grip the cord, GP(RP, [RF.1, RF.2])=ST.1.

  • Turn or T
    • A cord makes a "turn" around an object (anchor or cord) when it makes a 180-degree wrap around it, so that the approaching and returning cords point in the same direction. A "round turn" is two consecutive turns, although some books confusingly call it 1.5 turns. What really happens with a round turn is that the cord is in contact with a circular object for 1.5 circumferences. We probably call two turns "one round turn" because two is the smallest number of turns that makes the cord pass around all 360-degrees of the anchor. Instead of using the term "round turn", we'll simply say two turns.
    • If different turns have to be named, then they are T.1, T.2, and so on.
    • Note that there is also a verb, MakeTurn (MT).

    NM(T.L=T.1)	The leftmost turn is named turn #1.
    GP(T.3L, [RF.1, RF.2])	Grip the third turn from the left with the right thumb and forefinger
    NX(T.2, T.1:E.RP)	Turn #2 is next along the cord after turn #1 as we move toward the end of the running part.
    MT(RP, SP:CW:R):5, NM(T.L=T.1)	Make five turns with the running part around the standing part, clockwise as viewed from the right. Name the leftmost turn T.1

• Nouns for parts of the tyer's hands

  • The notation should be adequate for all parts of the tyer's hands, but will need user extensions to cover other parts of the tyer's body or the hands of a second person.

  • LefthandFinger, RighthandFinger or LF, RF
    • We number the fingers on each hand starting the with the thumb as #1. Hence, LF.1 is the left thumb. LF.2 is the left forefinger. RF.5 is the right pinky, and so on.

    GP(E.RP, [RF.1, RF.2])	Grip the end of the running part with the thumb and forefinger of the right hand.
    ~RV(LF.2, K.R-L), RS(EY=EY.1)	Unreeve the forefinger of the left hand from the knot (i.e. pull it out from what is enclosing it), from right to left. This results in an eye, which will be named EY.1.

  • LeftHand, RightHand or LH, RH
    • If you are right-handed, your formulas will call on RH to do jobs that lefties do with LH. To accommodate all tyers, you shouldn't specify which hand does a job when you don't have to. But it's often easier to record a formula presupposing our own handedness and make it neutral later than to make it neutral from the start.
    • If tyers encounter formulas presupposing the opposite handedness, then they may convert the formula. But note that it isn't as easy as transposing all occurrences of LH to RH and vice versa. One must transpose LF and RF codes. And one must often, but not always, transpose L and R, and \ and /.

    GP(RP, RH)	Grip the running part with the right hand.
    A(RH, LH)	The right hand is aft of the left hand.
    PT(RH:L-D)	The right hand first points left, then turns to point down. (A hand points in the direction of its palm.)
    NM(CS.A(LH)=CS.1)	The cord segment aft of the left hand will be named CS.1

• Other nouns

  • Unit or u
    • The standard unit of length or distance, u, is the cord's diameter.
    • Note that the unit u uses the same letter as the direction U (up). These two letters are case sensitive, but the rest of the notation is not.
    • When more than one cord is in use, and the cords have different diameters, then the reference cord can be a modifier to the unit.
    • The unit may also be inches, in, or centimeters, cm.

    LG(CS.1:10u)	The length of cord segment #1 is 10 units.
    LG(CS.1:5in)	The length of cord segment #1 is five inches.
    LG(CS.1:10u.C.2)	The length of cord segment #1 is 10 diameters of cord #2.
    BN(CS:10u, CR.1, CR.2)	The length of the cord segment between crossing #1 and crossing #2 is 10 units. You could also write this with the ":10u" modifying the whole predicate, not just the first parameter, BN(CS, CR.1, CR.2):10u.
    NM(ST.R(ST.1:10u)=ST.2)	The site to the right of site #1 by 10 units will be named site #2.

• Noun clusters
  • Often we'll want to perform an action on several objects at once, as if they were one object. To do so, simply list the nouns within square brackets, [...]. The bracketed list is considered a single term. It may occur wherever a term may occur. Modifiers may modify it.
  • Clusters may be assigned names.
  • Clusters normally contain nouns or other terms (including other clusters). The only exception is when they contain entire stages of a tying formula.

    GP([E.RP, E.SP], RH)	Grip the end of the running part and the end of the standing part together (as if they were one end) with the right hand.
    GP([E.RP.C.1, E.RP.C.2, E.RP.C.3, E.RP.C.4], RH)	Grip the ends of the running parts of cords 1-4 together, with the right hand.
    RV(E.RP, [LP.1, LP.2]:L-R)	Reeve the end of the running part through loops #1 and #2 at the same time, from left to right. Note how the ":L-R" modifier modifies the whole cluster.
    RV([E.RP, E.SP], [LP.1, LP.2]:L-R)	Reeve the ends of the running part and standing part together through loops #1 and #2 together, from left to right. Here we reeve a cluster of ends through a cluster of loops.
    NM([LP.1, LP.2, LP.3]=LP.4)	The cluster of loops #1, #2, and #3 will be named LP.4. Naming a cluster will be useful when you must refer to a long cluster more than once in a formula.
    MB([RP.C.1, RP.C.2]=BT.1)	Treat the running parts of cords #1 and #2 as one. Make a bight in that doubled cord and name it BT.1. Hereafter "BT.1" acts like the name of any other bight, even though it is doubled.
    MB([[RP.C.1, RP.C.2], [RP.C.3, RP.C.4]]=BT.1)	Like the last example but with four cords instead of two. Here I deliberately wrote the cluster of four cords as a cluster of two clusters of two cords each. This is unnecessary and confusing, but it illustrates that clusters can go wherever terms can go, including inside other clusters.
    MV(CS.1:L) ® OL(CS.1, CS.2), RS([CS.1, CS.2]=CS.3)	Move cord segment #1 to the left until it overlays (is superimposed on) cord segment #2. This results in a cluster, which will be named CS.3.
    Do([*2, *3, *4]):3	Repeat stages 2-4 three times. Here the cluster contains stages, not nouns.

Verbs

• Do.
  • The "do" verb has two purposes. (1) In verbless notation, it is the "universal verb" which tells the tyer to do whatever it takes to make the cord match the descriptors in the parameter list. (2) In looping or iteration, it tells us to repeat a certain stage of the formula a certain number of times or until a certain condition is met.
  • In the former sort of case, it could be omitted. It would only be included to alert the tyer that the present stage uses verbless notation and not to expect a more specific verb.
  • In programming languages, looping is more useful when the programmer can "pass parameters" to the loop code, and use counter variables, so that each iteration of the loop, and each loop call from different parts of the program, is a variation on a theme rather than an identical repetition. While this might be useful for complex decorative knots, it is not needed for most practical knots. The most common application of it would be to make many wraps (e.g. in tying a noose) and give each wrap a distinct name as it is created. But not all wraps need names, and those that do can be named after the fact. We can name the leftmost wrap, the second from the left, and so on, or the leftmost wrap, the wrap next along the standing part to the right, and so on. Hence, in its present version, the notation only supports iteration without variation.

    Do(L(LP.1, LP.2))	[Do whatever it takes to] put loop #1 to the left of loop #2.
    Do(PT(BT.1:U))	[Do whatever it takes to] make bight #1 point up.
    Do(*3) ® 5	Repeat stage 3 of the current formula five times.
    Do(*3):5	A simpler way to write the previous instruction.
    Do(*3) ® LG(RP:<5u)	Repeat stage 3 (say, wrapping the running part around a spar) until the running part is less than 5 units long.

• Grip or GP. GP(x, y) means that the tyer should grip x with y.
  • The first parameter is a cord segment and the second parameter is the "gripper", usually one of the hands. If there are two or more grippers, such as particular fingers, then we use cluster notation to make them act as a single parameter. See the nouns above for details on how to number the fingers.
  • Add the tilde or negation sign (~) to indicate the release of a grip.

    GP(RP, RH)	Grip the running part with the right hand.
    GP(LP.1, [RF.1, RF.2])	Grip loop #1 with the thumb and forefinger of the right hand.
    ~GP(LP.1, [RF.1, RF.2])	Release the grip on loop #1 by the thumb and forefinger of the right hand.
    GP([CR.LP.1, CR.LP.2], [LF.1, LF.2])	Grip the crossings of loop #1 and loop #2 together with the left thumb and forefinger.
    NM(ST.GP([RF.1, RF.2])=ST.1)	The site where the thumb and forefinger of the right hand are gripping the cord will be named site #1. For shorthand, we will usually name this site in the same instruction telling the tyer to grip the cord, GP(RP, [RF.1, RF.2])=ST.1.

• MakeBight or MB. MB(x) means that the tyer should make a bight out of cord segment x.
  • If you'll want to refer to this bight later, then name it immediately.
  • MakeBight is a composite verb. We could use Move and Point to do the same work, but it is very handy to have.

    MB(RP=BT.1)	Make a bight in the running part and name it BT.1.
    MB(RP.C.2=BT.1)	Make a bight in the running part of cord #2 and name it BT.1.
    MB(CS.BN(LP.1, LP.2)=BT.1)	Make a bight in the cord segment between loop #1 and loop #2 and name it BT.1.
    NM(CS.A(LH)=CS.1), MB(CS.1=BT.1)	The cord segment aft of the left hand will be named CS.1. Make a bight in CS.1 and name it BT.1.

• MakeLoop or ML. ML(x) means that the tyer should make a loop in cord segment x.
  • If you'll want to refer to this loop later, name it immediately.
  • If it matters that one segment should cross over rather than under the other, then indicate this in an optional first parameter which is either / (slash) or \ (backslash). The slash or backslash tells us the direction of the segment which passes over the other at the point of the crossing. In a / loop, the "over segment" lies in the / direction at the crossing. In a \ loop, the "over segment" lies in the \ direction at the crossing. For more details on these two kinds of loop, see below.
  • MakeLoop is a composite verb. We could use Move and Point to do the same work, but it is very handy to have.
  • A short introduction to / and \ loops
    • Slash loops are sometimes called Z-loops (by Chisnall), right-handed loops (by the IGKT), or dextral loops (by Budworth). Backslash loops are sometimes called S-loops (Chisnall), left-handed loops (IGKT), or sinistral loops (Budworwth). (See Chisnall at p. 28.) To see why, think of / as the middle part of a Z, and \ as the middle part of an S. Or think of the / as pointing right and \ as pointing left. I like / and \ better than Z and S, or right and left, because (1) they directly depict the direction of the cord that passes over the other at the crossing, and (2) they are easy to put into notation without confusing the reader with many other left and right references or with additional letters needing translation.
    • Whether a loop is / or \ is invariant with orientation. It doesn't matter whether you are looking at a look from the "front" or "back", or whether the loop is "right side up" or "upside down". Try it. Only when you look at a loop in a mirror will a / loop become a \ loop, or vice versa. (There are four orientations to test in order to be satisfied. If the center of the loop were a coin, then look at the loop so that the "head" faces right, then upside down so that the head faces left. Then look at the same two orientations from the "tail" side.)
    • Simple loops come in / and \ forms. So do overhand knots, slipknots, marlinspike hitches, bowlines, sheetbends, and many other structures built from / and \ loops. In an overhand knot, the / or \ depicts the segment passing over the crossing between the two link eyes. If you play with the other knots, you'll see the / or \ lurking. (When I have time to add illustrations to this file, I'll show where to find them.)

    ML(/RP)	Make a / loop in the running part. In a / loop in the horizontal plane, the segment moving from lower left to upper right at the crossing (the segment like "/" at the crossing) passes over the other segment. If the end of the running part is at our right and the standing part is at our left, then in this loop the running part crosses over the standing part. Since no ambiguity is possible, no comma is needed between the / and RP parameters. See the details above on / and \ loops.
    ML(RP)	Make a loop in the running part. Since the notation does not specify a / or \ loop, then either will do.
    ML(\RP=LP.1)	Make a \ loop in the running part and name it LP.1.
    ML(\RP.C.2=LP.1)	Make a \ loop in the running part of cord #2 and name it LP.1.
    ML(\BT.1=LP.1)	Make a \ loop in bight #1 and name it LP.1.
    ML(/CS.BN(ST.1, ST.2)=LP.1)	Make a / loop in the cord segment between site #1 and site #2 and name it LP.1.
    NM(CS.R(LP.1)=CS.1), ML(/CS.1=LP.2)	The cord segment to the right of loop #1 will be named CS.1. Make a / loop in CS.1 and name it LP.2.

• MakeTurn or MT. MT(x, y) means that the tyer should use x to make a turn around y in the direction indicated by the modifier on y.
  • To make a turn around an object, the cord approaches it, makes a 180-degree wrap around it, and returns in the same direction from which it came. The traditional sailor's term, "round turn", refers to two turns in this sense.
  • When several turns are made consecutively, then by default each remains parallel to its predecessor (as opposed to crossing it).
  • Note that there is also a noun Turn (T).
  • MakeTurn is a composite verb. We could use Move and Point to do the same work, but it is very handy to have.

    MT(RP, Tree.1:CW:U)	Make a turn with the running part around tree #1 (presumably defined at an earlier stage), clockwise as viewed from above.
    MT(RP, Tree.1:CW:U):2	Like the previous example but make two turns (or one round turn). Note the numeral modifying the entire predicate.
    MT(RP, SP:CW:R):9, NM(T.L=T.1)	Make nine turns with the running part around the standing part, clockwise as viewed from the right. Name the leftmost turn T.1. (Note the use of both the MT verb and the T noun.)

• Move or MV. MV(x) means that the tyer should move x in the direction, for the distance, and in the manner (pushing or pulling) indicated by the modifyiers on x.
  • This verb may take any number of parameters, depending on how many movements must be performed simultaneously.
  • The direction is one of the six directions (L, R, U, D, F, A). When the "direction" is 0 (zero), then the cord structure it modifies should not move at all.
  • More than one direction may be indicated in the direction modifier, if the motion is to change direction.
  • Distance is measured in any of several units. See the details under Unit.
  • When the push-pull operator (^) appears before a parameter, then the action is to push the designated object. When it appears after a parameter, then the action is to pull. See the push-pull variations illustrated with the Reeve verb.

    MV(E.RP:R)	Move the end of the running part to the right.
    MV(E.RP:R:20u)	Move the end of the running part to the right by 20 units.
    MV(^E.RP:R)	Push the end of the running part to the right.
    MV(E.RP^:R:10in)	Pull the end of the running part to the right 10 inches.
    MV(E.RP^:R, SP:0)	Pull the end of the running part to the right, and don't let the standing part move at all.
    MV(RP^:R, SP^:L)	Pull the running part to the right and pull the standing part to the right. (This is a common way to finish a knot.
    MV([RP, SP]^:R)	Pull the running part and the standing part together to the right. "[RP, SP]" represents the cluster of RP and SP and tells the tyer to treat them as one object.
    MV(E.RP:U-F)	Move the end of the running part first up and then fore.
    MV(E.RP:U-F-D-A-U-F-D-A)	Move the end of the running part first up, then fore, then down, and so on. This movement traces two circles. If the purpose is to wrap the RP around something, then it's more precise to use (a) the Point verb, with the same parameter list, or (b) the MakeTurn verb, with a different parameter list.

• Point or PT
  • This is both a verb and a descriptor. See the definition of it in the descriptor section.

• Reeve or RV. RV(x, y) means that the tyer should reeve x through y from the direction indicated in modifier on y.
  • "Reeve" is the sailor's term for sticking an end or bight through an opening. In some books the past tense is "reeved" and in some it is "rove".
  • The first parameter is the object passing through an opening. The second parameter is the opening. The first parameter will usually be an end or bight, but it may also be a toggle, fid, finger, or other object. When it is a cord or cord segment, rather than the end of one, then the act of reeving (pushing or pulling it through a loop) turns it into a bight. The second parameter will usually be a loop, but it may also be a bight, eye, or link eye.
  • The modifier on the second parameter contains two direction symbols separated by a hyphen. R-L means right to left. D-U means down to up. F-A means fore to aft. And so on for L-R, U-D, A-F. By indicating the direction of the reeving, we needn't indicate what crosses over or under what.
  • To make this verb unambiguous, a previous stage should make clear in which plane the loop (bight, etc.) in the second parameter lies. If it's in the horizontal plane, then we can only reeve D-U or U-D. If it's in the vertical plane, then we can only reeve F-A or A-F. If it's in the edge plane, then we can only reeve L-R or R-L.
  • When something is to be rove through several loops at once, then the second parameter is simply the cluster consisting of the loop names.
  • When the push-pull operator (^) appears before a parameter, then the action is to push the designated object. When it appears after a parameter, then the action is to pull.
  • Sometimes we stick an end through a loop, but sometimes we push a loop over an end. The resulting topology is the same. But if it matters to the tying method which part is in motion, then indicate the moving part with the ^ operator. Omit it when it doesn't matter which part is in motion.
  • Add the tilde or negation sign (~) to indicate unreeving, or the removal of an end or bight from an opening.
  • RV is also a descriptor, describing the situation in which some x passes through some opening y. This matters only because descriptors can act as modifiers if we drop their first parameter and let the object they modify play that role.

    RV(E.RP, LP.1:A-F)	Reeve the end of the running part through loop #1 from aft to fore.
    RV(E.RP^, LP.1:A-F)	Like the last example except here we specify that the end of the running part is pulled through the loop.
    RV(^E.RP, LP.1:A-F)	Like the last example except here the end of the running part is to be pushed, not pulled, through the loop.
    RV(E.RP, ^LP.1:A-F)	Like the preceding examples except here the loop is pushed over the end of the running part, rather than pushing or pulling the end through the loop. Note that the reeving is A-F even though the motion of the loop is F-A.
    RV(E.RP, [LP.1, LP.2, LP.3]:A-F)	Reeve the end of the running parts through loops #1, #2, and #3 at the same time, from aft to fore. Presumably, these three loops were aligned by actions in previous stages. The code says nothing about pushing or pulling, so it must not matter.
    RV(^[RF.1, RF.2], LP.1:A-F)	Push the thumb and forefinger of the right hand through loop #1 from aft to fore.
    RV(^[RF.1, RF.2], [LP.1, LP.2, LP.3]:A-F)	Push the thumb and forefinger of the right hand through loops #1, #2, and # at the same time, from aft to fore.
    ~RV(^E.RP, LP.1:F-A)	Unreeve (remove) the end of the running part from LP.1 by pulling it out from fore to aft.
    RV(BT.1, LP.1:L-R), RS(EY=EY.1)	Reeve bight #1 through loop #1, from left to right. This results in an eye (the end of the bight sticking through the loop), which will be named EY.1
    RV(CS.1, LP.1:D-U), RS(BT=BT.1, EY=EY.1)	Reeve cord segment #1 through loop #1, from down to up. This results in a bight (the cord segment pushed/pulled through the loop), named BT.1, and also an eye (the end of the bight through the loop), named EY.1.
    MV(E.RP:L) ® RV(E.RP, LP.1:L-R)	Move the end of the running part to the left until it reeves loop #1 from left to right.
    PT(LF.2:A), GP(E.RP, [RF.1, RF.2]), TW(E.RP:CW:R) ® RS(LP=LP.1, RV(LF.2, ^LP.1:A-F))	The left forefinger points aft. Grip the end of the running part with the thumb and forefinger of the right hand. Twist the end of the running part clockwise, as seen from the right, until (1) a loop results, called loop #1, and (2) loop #1 is pushed over the forefinger of the left hand from aft to fore.
    NM(CS.RV(LP.1)=CS.1)	The cord segment reeving through loop #1 will be named CS.1. Here RV is a descriptor used as a modifier; the object it modifies plays the role of its first parameter.

    Summary of the push-pull variations
    RV(^x, y)	x is in motion, pushed
    RV(x^, y)	x is in motion, pulled
    RV(x, ^y)	y is in motion, pushed
    RV(x, y^)	y is in motion, pulled
    RV(x, y)	No push-pull instructions. The tyer may reeve x through y with either kind of motion.

• Twist or TW. TW(x) means that the tyer should twist x along its own axis in the direction indicated by the modifier on x.
  • The direction of the twist is either clockwise (CW) or counter-clockwise (CCW), as viewed from a certain direction (L, R, U, D, F, A). (A rotation that looks clockwise when viewed from one side will look counter-clockwise from the opposite direction.)
  • The axis of the twist (the gudgeon or center line around which a rotating object rotates) is by default the line along which the object points. So for a straight cord segment, it is the cord. For a loop, it is the line from its center to its crossing. And so on for bights and knots. For more details, see the Points descriptor.
  • However, to twist along another axis than the default, simply indicate the desired axis as a modifier to the twisting direction.

    TW(CS.1:CW:L)	Twist cord segment #1 clockwise, when clockwise is determined by looking down CS.1 from the left
    TW(BT.1:CCW:U)	Twist bight #1 counter-clockwise (along its pointing axis), as viewed from above
    PT(BT.1:U), TW(E.BT.1:CW:LR:R)	Bight #1 (BT.1) points up. Twist the end of BT.1 on the axis formed by an LR (left-right) line, clockwise as viewed from the right.

• Until or ®
  • "Until" isn't really a verb, but it belongs with the verbs because it limits the actions they describe.
  • Because "until" allows us to repeat a certain stage of a formula a certain number of times, or until a certain condition is met, it allows what programmers call "looping". But knotters already use the term "loop" for another purpose. I'll feel free to call this kind of repetition "looping" when I think the context makes the meaning clear; otherwise I'll use the programmer's fancy synonym, "iteration".

    MV(E.RP:A) ® A(E.RP, LH)	Move the end of the running part aft until it is aft of the left hand.
    MV(E.RP:L) ® CO(RP, SP)	Move the end of the running part to the left until it crosses over the standing part.
    TW(CS.1:CW:R) ® RS(LP=LP.1)	Twist cord segment #1 clockwise (as viewed from the right) until a loop results, and name that loop LP.1
    TW(CS.1:CW:R) Until(RS(LP=LP.1))	Same as the previous example, but showing how to use the word in place of the symbol. Note that there is no comma after the Twist verb sentence.
    RV(E.RP, LP.1:A-F) ® LG(CS.F(LP.1):20u)	Reeve the end of the running part through loop #1, from aft to fore, until the cord segment fore of loop #1 is 20 units long.
    Do(*3) ® 5	Repeat stage 3 of the current formula five times.
    Do(*3) ® LG(E.RP:<5u)	Repeat stage 3 until the end of the running part is less than 5 units long.

Descriptors

• Descriptors tell us what things look like and how actions are performed.
• Descriptors are not verbs, but may seem verblike. In verbless notation, descriptors don't explicitly tell tyers what actions to perform, but implicitly they say, "Do what it takes to produce these arrangements" or "Do what it takes so that the knot looks like this."
• In ordinary or verbed notation, they describe what the cord should look like after the most recent action. If a half-tied knot doesn't look the way the descriptor says it should, then the descriptor tells the tyer, in effect, to dress the knot until it matches the descriptors. (Some knotters distinguish "dressing" from "setting". To dress a knot is to align all the cords, ends, loops, and bights properly, and to set it is to tighten it.)
• All descriptors may be used as modifiers. When they are, we drop the descriptor's first parameter and let the object it modifies play that role. Letting descriptors function as modifiers creates the possibility of recursion: descriptors inside descriptors. There's no reason except clarity to limit the number of levels we can nest downward through recursion of this kind. One advantage of this kind of recursion is to refer to particular structures without naming them, which is especially important when we want to pick them out in order to name them. See the examples below.

• Between or BN. BN(x, y, z) means that x is between y and z.

  BN(LP.2, LP.1, LP.3)	Loop #2 is between loop #1 and loop #3.
  BN(CS:10u, CR.1, CR.2)	The length of the cord segment between crossing #1 and crossing #2 is 10 units. You could also write this with the ":10u" modifying the whole predicate, not just the first parameter, BN(CS, CR.1, CR.2):10u.
  GP(CS.BN(LP.1, LP.2), RH)	Grip the cord segment between loop #1 and loop #2 with the right hand. Here BN is used a modifer; hence its first parameter is dropped and the object BN modifies plays the role of its first parameter.
  MB(CS.BN(LP.1, LP.2)=BT.1)	Make a bight in the cord segment between loop #1 and loop #2 and name it BT.1.

• CrossOver or CO. CO(x, y) means that x crosses over y.
  • We don't need a CU (Crosses Under) descriptor. Just reverse the order of parameters and use the CO descriptor.

    CO(RP, SP)	The running part crosses over the standing part.
    CO(CS.R, CS.L)	The cord segment to the right crosses over the cord segment to the left.
    CO(CS.R(LP.1), CS.L(LP.1))	The cord segment to the right of LP.1 crosses over the cord segment to the left of LP.1.
    MV(E.RP:L) ® CO(RP, SP)	Move the end of the running part to the left until it crosses over the standing part.
    MV(BT.1:L) ® CO(BT.1, BT.2), RS(EY=EY.1)	Move bight #1 to the left until it crosses over bight #2. This results in an eye, which will be named EY.1.
    NM(CS.CO(SP)=CS.1)	The cord segment that crosses over the standing part will be named cord segment #1. Here CO is used as a modifier; hence we drop its first parameter and let the object it modifies play that role.

• Direction(x, y) means that x lies to the direction of y.
  • Here "direction" can be any one of the six recognized directions (L, R, F, A, U, D). Hence there are six descriptors here.
  • An optional modifier attached to either parameter, or to the whole predicate, can indicate the distance between the two parameter objects.
  • A one-parameter version of this entire descriptor may be used as a modifier.

    R(LP.1, LP2)	Loop #1 is to the right of loop #2.
    A(RP, SP)	The running part is aft of the standing part.
    R(ST.2:10u, ST.1)	Site #2 is 10 units to the right of Site #1. This could also be written R(ST.2, ST.1:10u) or R(ST.2, ST.1):10u.
    NM(CS.F(LH)=CS.1)	The cord segment fore of the left hand will be named CS.1. Note that here the F(LH) descriptor is used as a modifier; hence the object it modifies plays the role of its first parameter.
    NM(ST.F(LH:5u)=ST.1)	The site fore of the left hand by five units will be named ST.1. This could also be written NM(ST.F(LH):5u=ST.1)
    RV(E.RP, LP.L(LP.1):D-U)	Reeve the end of the running part through the (unnamed) loop which lies to the left of loop #1. The direction of the reeving is from down to up.

• Length or LG LG(x) means that the length of x is the number of units indicated by the modifier on x.
  • The length can be measured in many units.. The unit, u, is the diameter of the cord. But it can also be inches, in, or centimeters, cm.
  • Length or distance can also be indicated in many sentences without the LG descriptor. See examples under Between and the direction descriptors.

    LG(CS.1:5in)	The length of cord segment #1 is 5 inches.
    LG(BT.1:>20u)	The length of bight #1 is more than 20 units.
    LG(CS.1:25u.C.2)	The length of cord segment #1 is 25 diameters of cord #2.
    LG(CS.R(LP.1):10u)	The length of the cord segment on the right side of loop #1 is 10 units.
    CS.LG:10u	The cord segment's length is 10 units. Here LG is used as a modifier; hence we drop its parameter and let the object it modifies play that role.

• Line or LN. LN(x) means that x lies on the line indicated in the modifier on x.
  • The parameter is any two-dimensional structure that can lie on a line, such as a cord, cord segment, or bight.
  • The modifier on x tells us whether the structure named by x lies on a LR (left-right), UD (up-down), or FA (fore-aft) line.
  • The Line (LN) descriptor is to the three recognized lines as the Plane (PN) descriptor is to the three recognized planes.

    LN(CS.1:LR)	Cord segment #1 lies on a left-right line.
    LN(CS.A(LH):UD)	The cord segment aft of the left hand lies on an up-down line.
    CS.LN:FA	The cord segment that lies on fore-aft line. Here LN is used as a modifier; hence we drop its parameter and let the object it modifies play that role.

• Name or NM. NM(x) means that x has the name indicated after the "=" symbol.
  • This descriptor can take any number of parameters. Each parameter specifies the thing to be named and its name.
  • This descriptor is needed when we want to name something later than the sentence creating it, or when one act creates more than one object needing a name. In these cases, the contextual use of the "=" notation for naming cannot precisely pick out the objects to be named.
  • Note that this descriptor uses the "=" naming operator. This is not strictly necessary; we could have used a comma instead of the equals sign to separate the thing to be named from its name, treating the name as a separate parameter; we we could have used a dot, treating the name as an ordinary modifier. By retaining the contextual naming operator inside the naming descriptor, it is easier to remember what is going in inside the parameter list to this descriptor: "=" always means naming and naming always uses "=".
  • Syntactically, the "=[name]" notation is a modifier. But using the "=" instead of the dot is justified if only to make reading formulas easier. Moreover, when one encounters a name late in a formula, one commonly scans the earlier stages to see how it was defined. The equals sign stands out more than just another instance of dot notation hidden among many others.
  • The "=[name]" notation can occur wherever modifiers can occur —after parameters within sentences, or after the closing parentheses of whole sentences. In the NM descriptor, it always occurs within the parentheses, attached to a parameter.
  • The NM descriptor assigns a name and doesn't merely report a name already assigned. Hence it is properly a verb. But since it does not describe an action manipulating the cord, I've omitted it from the set of verbs and classified it with the descriptors. (But of course, its classification doesn't affect its use.)

    NM(LP.R=LP.2)	The loop on the right, or the rightmost loop, is named loop #2.
    NM(LP.3L=LP.3)	The loop third from the left is named loop #3.
    NM(CS.A(LH)=CS.1)	The cord segment aft of the left hand is named cord segment #1.
    NM(LP.F=LP.1, LP.A=LP.2)	If an earlier act created two loops, one fore and one aft (e.g. the first step in making a cow hitch or girth hitch), then this code tell the tyer that the fore loop will be called LP.1 and the aft loop will be called LP.2.
    NM(ST.R(ST.1:10u)=ST.2)	The site to the right of site #1 by 10 units will be named site #2.

  • Here are some examples of the naming operator ("=") when it is used without the Name or NM descriptor.

    MB(RP=BT.1)	Make a bight in the running part and name it BT.1.
    ML(RP=LP.1)	Make a loop in the running part and name it LP.1.
    TW(CS.1:CW:R) ® RS(LP=LP.1)	Twist cord segment #1 clockwise (as viewed from the right) until a loop results, and name that loop LP.1
    GP(RP, [RF.1, RF.2])=ST.1	The site where the thumb and forefinger of the right hand are gripping the running part will be named site #1. It would also be correct, but unnecessarily complex, to write the instruction this way, NM(ST.GP([RF.1, RF.2])=ST.1).

• Next or NX. NX(x, y) means that x is next to y in direction indicated in the modifier on y.
  • "Next" here means next along the cord, or next along any other object, such as a bight, finger, spike, or toggle. Indicate the direction by indicating the end toward which we are to move.

    NX(LP.2, LP.1:E.RP)	Loop #2 is next along the cord to loop #1 as one moves from loop #1 toward the end of the running part.
    NX(CR.1, CR.2:E.BT.1)	Crossing #1 is next along the cord to crossing #2, when we start with crossing #2 and move toward the end of bight #1.
    NX(LP.2, LP.1:E.1)	Loop #2 is next along the relevant object to loop #1 as one moves from loop #1 towards E.1. This presupposes that E.1 has already been defined, e.g. as the end of a marlinspike or bollard.
    NM(LP.NX(LP.1:E.RP)=LP.2)	The loop next to LP.1 along the cord toward E.RP will be called LP.2. Here a one-parameter version of NX is used as a modifier; the noun it modifies acts as its implicit first parameter.

• Overlay or OL. OL(x, y) means that x overlays y.
  • This descriptor applies to structures like loops, bights, and eyes, as well as to points (sites). For loops, it means not only that the two loops are roughly the same size and shape (congruent), but that they are arranged with the first on top of the second. In practice it will normally suffice that the two loops overlap so as to create a single opening through them both. For points, it means that the first is on top of the second, though in practice it will normally suffice if the two sites can be gripped by the same pair of fingers.

    OL(LP.1, LP.2)	Loop #1 overlays (is superimposed on) loop #2
    OL(CR.1, ST.1)	Crossing #1 overlays site #1.
    OL(LP.1, LP.2), RV(^E.RP, [LP.1, LP.2]:D-U)	Loop #1 overlays loop #2. Push the end of the running part through the two superimposed loops at the same time, from down to up.
    OL(ST.1, ST.2), GP([ST.1, ST.2], [RF.1, RF.2])	Site #1 overlays site #1. Grip the two superimposed sites between the right thumb and forefinger.
    LP.OL(LP.1)	The loop that overlays loop #1. Here OL is used as a modifier; hence we drop its first parameter and let the object it modifies play that role.

• Parallel or PL. PL(x, y) means that x is parallel to y.
  • This descriptor can apply to any objects that can be parallel: cords, cord segments, fingers, hands, spikes and other tools, spars and other anchors. The objects may be two- rather than one-dimensional, such as loops, bights, and eyes.

    PL(RP, CS.1)	The running part is parallel to cord segment #1.
    PL(RF.1, RF.2)	The thumb and forefinger of the right hand are parallel.
    PL(LP.1, LP.2)	Loop #1 and loop #2 are parallel.
    CS.PL(SP)	The cord segment that is parallel to the standing part. Here PL is used as a modifier; hence we drop its first parameter and let the object it modifies play that role.

• Plane or PN. PN(x) means that x lies in the plane indicated by the modifier on x.
  • This descriptor can take any number of parameters. Each parameter indicates some knot structure and indicates the plane in which it lies.
  • We have to know the plane of a loop in order to be able to describe the direction of reeving when we reeve something through it. For example, a loop in the horizontal plane only allows reeving D-U or U-D. Often it won't matter which plane you pick, but for reeving it always matters that you pick one.
  • The Plane (PN) descriptor is to the three recognized planes as the Line (LN) descriptor is to the three recognized lines.

    PN(LP.1:HP)	Loop #1 lies in the horizontal plane.
    PN(LP.1:HP, LP.2:VP)	Loop #1 lies in the horizontal plane and LP.2 lies in the vertical plane.
    PN(LP.1:VP), RV(E.RP, LP.1:A-F)	Loop #1 lies in the vertical plane. Reeve the end of the running part through loop #1 from aft to fore. A common use for the PN descriptor is to orient a loop so that the reeving direction will be unambiguous.
    LP.PN:HP	The loop that is in the horizontal plane. Here PN is used as a modifier; hence we drop its first parameter and let the object it modifiesd play that role.

• Point or PT. PT(x) means that x points in the direction indicated by the modifier on x.
  • This descriptor takes any number of parameters. Each parameter indicates some knot structure and the direction in which it is pointing.
  • An end of cord points in the direction of its end. A bight points in the direction of its turn or curve. A loop points in the direction of its crossing. A knot points in the direction of its running end (when the running and standing ends are pulled taut in opposite directions). A finger points in the direction of its tip. A hand points in the direction of its palm. Eyes and link eyes have no natural pointing direction.
  • When direction symbols are linked by hypens, then this descriptor becomes a verb telling us to change the direction in which something points.
  • For greatest clarity, changes of direction should be indicated in 90-degree steps. That is, U-F-D, not U-D. This shows that the wrap takes place on the "fore" side of the object being wrapped, rather than the other "aft" side.

    PT(RP:R)	The running part points to the right.
    PT(BT.1:F)	Bight #1 points fore.
    PT(LP.1:U)	Loop #1 points up.
    PT(K:R)	The knot points to the right.
    PT(LF.1:L)	The thumb of the left hand points left.
    PT(LH:D)	The left hand points down.
    PT(RP:R, SP:L, BT.1:F)	The running part points right, the standing part points left, and bight #1 points fore.
    PT(RP:U-F-D-A-U)	Make the running part point first up, then fore, then down, then aft, and then up, i.e. wrap it 360 degrees around the spar or cord segment at the center. When multiple directions are included, separated by hyphens, then PT is a verb, telling the tyer to make the direction change in that sequence. Otherwise PT is a descriptor, reporting the direction in which an object is already pointing.
    BT.PT:U	The bight that points up. Here PT is used as a modifier; hence we drop its first parameter and let the object it modifies play that role.

• Reeve or RV
  • This is both a verb and a descriptor. See the definition of it in the verb section.

• Results or RS. RS(x) means that x results from the previous action.
  • The RS descriptor allows us to use indirect means to supplement direct means, or to use verbs for one action in order to get (and name) a desirable side-effect. If we want a loop, we could instruct the tyer directly through the MakeLoop verb, or instruct the tyer to make certain twists and moves and then notice that a loop has been created.
  • Note that RS is not a verb. It doesn't tell the tyer what to make, only to notice (and perhaps name) what has already been made.

    PT(RP:U), MV(E.RP:D, SP:0), RS(BT=BT.1)	The running part points up. Move the end of the running part down, without letting the standing part move at all. This results in a bight, which will be named BT.1
    TW(E.RP:CW:R), MV(E.RP.L), RS(LP=LP.1)	Twist the end of the running part clockwise, as viewed from the right. At the same time move the end of the running part to the left. This results in a loop, which will be named LP.1.
    TW(E.RP:CW:R) ® RS(LP=LP.1)	Similar to the last example but using "until". Twist the end of the running part clockwise, as viewed from the right, until a loop results, which will be named LP.1.
    RV(CS.1, LP.1:D-U), RS(BT=BT.1, EY=EY.1)	Reeve cord segment #1 through loop #1, from down to up. This results in a bight (the cord segment pushed/pulled through the loop), named BT.1, and also an eye (the end of the bight through the loop), named EY.1.
    MV(E.RP:L) ® CO(RP, SP), RS(CR=CR.1)	Move the end of the running part to the left until it crosses over the standing part. This results in a crossing, which will be named CR.1. If there were other side-effects we could add them as well.

• Tight or TT. TT(x) means that the knot (or cord) should have x degree of tightness (or tautness).
  • The bad news is that there is no familiar scale of knot-tightness. The good news is that we probably don't need one. Three degrees will suffice for most purposes:  loose, snug, and tight. Indicate these as t, tt, and ttt, respectively.

    TT(t)	The knot should be loose. If this were verbless notation and the knot were already snug or tight, this code instructs the tyer to loosen it.
    MV(SP^:L, RP^:R), TT(ttt)	Pull the standing part left and the runnning part right. Make very tight. This is a common way to finish a knot.
    RV(E.RP, LP.1:D-U), TT(t)	Reeve the end of the running part through loop #1, from down to up. Leave it loose.
    MV(RP.C.1^:A), TT(tt)	Pull RP.C.1 (the running part of cord #1) aft. Pull it to moderate tautness. Here TT applies to the line or cord, not to a knot. When the standing part is anchored somewhere fore, this is a common way to start knots.
    K.TT:ttt	The knot that is pulled tight. Here TT is used as a modifier; hence we drop its parameter and let the object it modifies play that role.

User extensions

• Users may introduce their own nouns, verbs, and descriptors. This brings three major advantages. (1) These extensions greatly increase the adequacy of the notation, rendering it virtually complete. (2) Because the extensions are natural-language words and phrases, they enlarge the notation without cluttering it with symbols or making it more difficult to use. (3) They make the notation flexible for individual needs.
• Users may also introduce natural-language sentences into the middle of notation formulas. It doesn't matter whether we consider these to be user extensions or decisions to depart from the notation temporarily.

  Let my marlinspike =Spike.1. RV(Spike.1, LP.1:R-L)	Name my marlinspike Spike.1. Reeve Spike.1 through loop #1 from right to left.
  Let the large red oak =Tree.1. MT(RP, Tree.1:CW:U):3	Name the oak Tree.1. Make three turns around Tree.2, clockwise as viewed from above.
  Let tie an overhand =TOV. TOV(RP=K.1)	Let "TOV" be a verb for the action of tying an overhand knot. Tie an overhand knot in the running part