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 and name it K.1 (knot #1).
  Do(TOV(RP)):4	Repeat the action of tying an overhand knot in the running part four times.
  Let tie a safety knot = TSK. MV(RP^:R, SP^:L), TSK(RP)	Let "TSK" be a verb for tying a safety knot. Pull the running part to the right and standing part to the right. Tie a safety knot in the running part.
  Let cleat #1 =CL.1. Let cleat #2 =CL.2. Let tying in to a cleat =TC. TC(RP, CL.1), TC(SP, CL.2)	Tie the running part to cleat #1 and the standing part to cleat #2. The method of tying to a cleat is not defined, but need not be defined if the user is notating for an audience that knows how to tie in to a cleat.
  Assume that the cord is anchored somewhere fore.	This is an English sentence that doesn't introduce a coded noun, verb, or descriptor. If the method of anchoring this cord mattered, the notator would have notated it.

Verbless notation

• In verbless notation, you simply describe what is where and let the tyer figure out how to make it happen. Stages consist almost entirely of descriptors. It uses no verb except the "universal verb" to do whatever it takes to arrange the cord as described in the descriptors.
• You may use verbless notation as much or as little as you wish. You may mix verbed and verbless notation in the same formula, or stick to just one style.
• The chief virtue of verbed notation is that it is explicit on the actions required at a certain stage; its chief vice is that it doesn't have enough verbs to be adequate to all the actions required for all tying methods. The chief virtue of verbless notation is that it doesn't require verbs and is adequate for a much larger domain; its chief vice is that it is it is not explicit on the actions needed to bring about a certain result.
• We shouldn't overstate the disadvantages of verbless notation. It leaves the tyer no worse off than books that show photographs of a tying method at several different stages. They omit the verbs and leave tyers to their own devices to make the cord look like the pictures. Just as books make tying easier if they photograph more stages with smaller differences between them, verbless notation will be easier for tyers if the notator breaks the method into more stages.
• In principle, all tying methods could be described in verbless notation. But there are two reasons not to use verbless notation all the time. (1) Some tying methods are interesting precisely because of the hand movements (verbs) they use, and (2) some tying instructions are useful precisely because they describe these movements. For the same two reasons, it's not a bargain to drop all the verbs, even though that would vastly simplify the notation without diminishing its adequacy. Verbed notation is usually more helpful to tyers than verbless notation, and the primary purpose of the notation is to be helpful to tyers.
• On the other hand, we should appreciate that verbless notation does make the notation adequate in an important way. When I've called the notation "inadequate", I've generally meant inadequate to cover all the verbs. Verbless notation not only fills that gap, but can also replace the verbs.
• When verbless notation is desirable.
  1. When you need a verb not already in the notation, and when you don't want to define a a new one (as a user extension) to fill the hole.
  2. When you want to describe a tying method through the geometry (topology) of the cord at different stages (i.e. shapes and crossings) rather than through the operations that bring them about these arrangements (i.e. fingers, hands, and movements) —i.e. when you want to make your description of a method more mathematical than physical. Conversely, avoid verbless notation when you want to make your description more physical than mathematical.
  3. When you want to skip the early steps in a method and jump to a later step. Verbless notation tells the tyer what things should look like at the stage where you want to begin.
  4. When there are many ways to achieve a certain result and you don't care which one the tyer uses —and when the intended audience can be assumed to know at least one.

  L(E.RP, E.SP)	The end of the running part is to the left of the end of the standing part. If it isn't already so, then make it so.
  Do(L(E.RP, E.SP))	Same as athe previous example but using the "universal verb" to alert the tyer that this is verbless notation and that the omission of other verbs from the present stage was not inadvertent.
  L(/LP=LP.1, /LP=LP.2)	A / loop, which will be named LP.1, lies to the left of another / loop, which will be named LP.2 If the loops don't yet exist, then make them. If they aren't positioned as described, then make it so.
  CO(RP, SP)=CR.1	The running part crosses over the standing part, and this crossing is named CR.1. If this crossing doesn't yet exist, then make it.

Tips

• Omit detail that doesn't matter. This could mean omitting descriptors or whole stages. Some details don't matter because all legal ways to follow the instructions are acceptable. Some don't matter because you're writing for a particular person (for example, yourself) or persons who can take those details for granted. Some don't matter because your purpose is to record one aspect of the method rather than the whole method.
• Include unnecessary information if it helps. For example, if you've already told us that a loop is in the horizontal plane, and that we are to reeve an end through it from bottom to top, then it's already implicit that the reeving end points up. But if you tell us that it points up in a descriptor, then tyers can verify that they did the right thing.
• The alphabetic symbols are just abbreviations for words and phrases. It may help to use the whole words and phrases, at least until the symbols are well-learned. For example, instead of RV(BT.1, LP1:D-U), you can write Reeve(Bight #1, Loop #1 : Down-Up).
• If you want to name a loop, bight, or other structure created during a tying method, then name it in the same stage, preferably the same sentence, in which it was created.
• Long names can be shortened, which is desirable if they have to be written more than once. For example, E.RP.C.2 unambiguously names the end of the running part of cord #2. But if you'll need to refer to it more than once, consider giving it a shorter name. This instruction, NM(E.RP.C.2=E.2), renames it E.2.
• If you only have to refer to a certain cord structure once, then you don't even have to name it. For example, RV(E.RP, LP.3L:U-D), tells the tyer to reeve the end of the running part through the third loop from the left (and to reeve from up to down). We can save steps if we don't bother to name this particular loop.
• You'll learn the notation better and faster if you practice writing it, not just reading it.

List of special symbols

*   operator introducing new stages
=   operator introducing names
.   operator introducing "which one" modifiers
:   operator introducing "how" modifiers
^   push-pull operator
-   from...to operator
®   until operator
~   negation operator
>   greater than operator
<   less than operator
\   symbol for "S" or right-handed loop
/   symbol for "Z" or left-handed loop
,   delimiter for list items (separating sentences within a stage and parameters within a cluster or sentence)
(...)  markers for beginning and end of parameter lists
[...]  markers for beginning and end of cluster lists

Sample annotated formulas

• In these samples, the notation is in blue and the annotations are in green. I annotate each stage and usually offer some general annotations on each method.
• I will eventually have annotated formulas here illustrating the use of every noun, verb, and descriptor, every syntactic feature, and knotting methods that might be difficult for users new to the notation. But it will take time to get all these written. If there's a knotting method you'd like to see illustrated here, just let me know. When I find time, either I'll write it up —or add it to the list of known inadequacies.

• List of samples
  • Overhand knot (with words)
  • Overhand knot (with abbreviations)
  • Overhand on a bight
  • Zeppelin bend
  • Sheepshank
  • Marlinspike hitch, from below

Overhand knot (with words)
*1 Hold(StandingPart, LeftHand), Hold(RunningPart, RightHand)	Start with the standing part in the left hand and the running part in the right hand.
*2 MakeLoop(RunningPart)=LP.1, CrossOver(RunningPart, StandingPart), Plane(LP.1:HorizontalPlane)	Make a loop in the running part, name it loop #1. The running part crosses over the standing part. Loop #1 lies in the horizontal plane.
*3 Reeve(End.RunningPart, LP.1:Down-Up)	Reeve the end of the running part through loop #1 from down to up.
*4 Move(StandingPart^:Left, RunningPart^:Right)	Pull the standing part to the left and the running part to the right.
Here I've spelled out each noun, verb, and descriptor to show how clear the notation can be. Normally, however, we use abbreviations instead of full words. To see what the same formula looks like with abbreviations, see the next example below. These instructions make a / loop. To make a \ loop instead, change CO(RP, SP) in the second stage to CO(SP, RP). (For a refresher on the difference, see these details.) Clearly the loop doesn't have to lie in the horizontal plane (stage 2). If you instructed the tyer to put it in the vertical plane in stage 2, PN(LP.1:VP), then in stage 3 the end of the running part would have to reeve through it from fore to aft, rather than down to up, RV(E.RP, LP.1:F-A). I've put one stage per line for clarity, but this is not at all required. You could use more lines (one per sentence, not just one per stage), or fewer (the whole formula on one line). This is entirely a matter of style in presenting the formula. I've numbered these stages, but that too is not required.

Overhand knot (with abbreviations)
*1 GP(SP, LH), GP(RP, RH)	Start by gripping the standing part in the left hand and the running part in the right hand.
*2 ML(RP)=LP.1, CO(RP, SP), PN(LP.1:HP)	Make a loop in the running part, name it loop #1. The running part crosses over the standing part. Loop #1 lies in the horizontal plane.
*3 RV(E.RP, LP.1:D-U)	Reeve the end of the running part through loop #1 from down to up.
*4 MV(SP^:L, RP^:R)	Pull the standing part to the left and the running part to the right.
For the same formula with words instead of abbreviations, see the previous example, above. Even this version with abbreviations is longer than necessary, in order to separate the stages. Here's a perfectly valid compression of the same formula: *1 GP(SP, LH), GP(RP, RH), *2 ML(RP)=LP.1, CO(RP, SP), PN(LP.1:HP), *3 RV(E.RP, LP.1.D-U), *4 MV(SP^:L, RP^:R)

Overhand on a bight
* GP(SP, LH), GP(RP, RH)	Start with the standing part in the left hand and the running part in the right hand
* MB(RP)=BT.1	Make a bight in the running part, name it bight #1.
* ML(BT.1)=LP.1, CO(RP.BT.1, SP.BT.1), PN(LP.1:HP)	Make a loop in bight #1, name it loop #1. The running part of bight #1 crosses over its standing part. Loop #1 lies in the horizontal plane.
* RV(BT.1, LP.1:D-U)	Reeve bight #1 through loop #1 from down to up.
* MV(SP.BT.1^:L, E.BT.1^:R)	Pull the standing part of bight #1 to the left, and the end of bight #1 to the right.

Zeppelin bend
* Make a / overhand knot in cord #1 (=LP.1). PN(LP.1:VP), PT(LP.1:U), TT(t)	We can regard the sentence, "Make a / overhand" as a user extension (because I've already provided the code, in the first sample above), or simply as an English sentence allowing me to jump ahead to the parts I'm interested in notating. Call the overhand knot LP.1. Leave it loose. It's in the vertical plane, pointing up.
* PT(LP.1:U-L-A-R), PN(LP.1:VP), NM(LE.D=LE.1)	The loop has been pointing up. Turn it so that it points left, then aft, then right. (Remember that a loop points in the direction of its crossing.) The loop is in the vertical plane. The link eye on the bottom is named LE.1. (Remember that overhand knots have two link eyes; after the first action in this stage, they are located one over the other on the right side of the knot.)
* NM(E.RP.C.2=E.1)	The end of the running part of the second cord will be named E.1.
* RV(E.1, LE.1:A-F)	Reeve end #1 through link eye #1, from aft to fore.
* MB(CS.A(LE.1)=BT.1).C.2	Make a bight in the cord segment aft of link eye #1. Name this bight BT.1. All this is in cord #2.
* OL(BT.1, LP.1)	Make BT.1 overlay LP.1. I'm stating this as if commanded by a verb. But OL is a descriptor. Literally this stage is verbless: Do whatever it takes to arrange things so that BT.1 overlays LP.1.
* PT(E.1:F), PT(E.1:D-A-U-F)	End #1 points fore. Take end #1 and make it point in succession aft, up, then fore. This has the effect of producing a turn of E.1 around the standing part of C.2.
* RV(E.1, [LP.1, BT.1]:F-A)	Reeve end #1 through both LP.1 and BT.1 simultaneously (now superimposed), from fore to aft.
* MV(SP.C.2^:R, SP.C.1^:L), TT(tt)	Pull the standing part of cord #2 to the right and the standing part of cord #1 to the left, until snug.
I've never seen good instructions for this very useful knot. This is my own method. This formula illustrates how the notation handles two cords in one method, the superimposing of a bight on a loop, and reeving through two openings at once.

Sheepshank
*1 GP(SP, [LF.1, LF.2]), GP(RP, [RF.1, RF.2]), BT(CS:20u, LH, RH)	Grip the standing part with the thumb and forefinger of the left hand, and call the gripping site ST.1. At the same time, grip the running part with the thumb and forefinger of the right hand, and call the gripping site ST.2. The cord segment between the left and right hands is about 20 diameters long.
*2 TW(RP:CW:R), MV(RH:L, LH:0), RS(LP), PN(LP:VP), PT(LP:D)	Twist the running part clockwise (as viewed from the right). At the same time, move the right hand to the left and don't move the left hand at all. This results in a loop, which is in the vertical plane and points down.
*3 Do([*1, *2]):3, RS(LP.L=LP.1, LP.2L=LP.2, LP.R=LP.3)	Repeat stages 1 and 2 three times. This results in three loops; the one on the left will be named LP.1, the one second from the left LP.2, and the one on the right LP.3. (Of course, all three loops are in the vertical plane and all three point down.)
* GP([CR.LP.1, CR.LP.2, CR.LP.3], [LF.1, LF.2]), L(LP.1:3u, LP.2), L(LP.2:3u, LP.3)	Grip the three crossings of the three loops with the thumb and forefinger of the left hand. Loop #1 is about three units (cord diameters) to the left of loop #2, which is in turn three units to the left of loop #3.
* RV(^[RF.1, RF.2], LP.3:A-F), GP(SD.R.LP.2, [RF.1, RF.2])	Stick the thumb and forefinger of the right hand through LP.3, from aft to fore. Grip the right side of LP.2 with the right thumb and forefinger.
* RV(^[LF.1, LF.2], LP.1.F-A), GP(SD.L.LP.2, [LF.1, LF.2])	Stick the thumb and forefinger of the left hand through LP.1, from fore to aft. Grip the left side of LP.2 with the left thumb and forefinger
* MV(SD.L.LP.2^:L, SD.R.LP.2^:R), TT(tt)	Pull the left side of LP.2 to the left and the right side of LP.2 to the right. Pull until snug.
* TT(LP.1, tt), TT(LP.3, tt)	Tighten LP.1 and LP.2 until snug.
We start this knot by making three loops. I could have used the ML verb, but I wanted to record instructions for an elegant twist and move method of producing these loops. So I used the TW and MV verbs, instead, followed by the RS descriptor to describe the loop that results. Moreover, instead of using the TW-MV-RS sequence three times, I used it once and then asked the tyer to repeat those stages three times.

Marlinspike hitch, from the bottom
* Let the tyer's marlinspike be Spike.1. NM(E.Spike.1=E.1)	Through a user extension, we name an object not preidefined in the notation. We also name its end.
* Assume the E.SP is secured to an anchor fore of the tyer. GP(RP, LH), MV(RP^:A) TT(t)	Another user extension (or indifferently, departure from the notation) to describe the initial state of the cord. Grip the running part with the left hand, pull aft lightly.
* GP(Spike.1, RH), PT(Spike.1:L), D(Spike.1, C), F(RH, LH)	Grip the spike in the right hand so that its tip points left. The spike is below the cord. The right hand is fore of the left hand.)
* MV(Spike.1:U-A, LH:F), NM(CS.F(Spike.1)=CS.1), CS.A(Spike.1)=CS.2)	Move the spike (and right hand) up and aft, while moving the left hand fore. The cord segment fore of the spike will be named CS.1, and the segment aft of it CS.2.
* F(LH, RH), PT(LF.2:U)	Verbless: now the left hand is fore of the right hand. The left forefinger points up.
* MV(Spike.1:D), L(CS.1, LF.2), RS(/LP=LP.1)	Move the spike down. Now CS.1 is to the left of the left forefinger. This results in a / loop, which we'll name LP.1.
* MV(Spike.1:D-F), PT(LF.2:U-A-D), RS(LP.L(CS.1)=LP.2)	Move the spike down and fore. Rotate the left hand so that the left forefinger points up, then aft, then down. This results in a loop to the left of CS.1, which we'll call LP.2
* PT(Spike.1:L-D-L), RV(^Spike.1, LP.2:U-D), ~RV(LF.2, LP.2:U-D), PT(Spike.1.L)	Turn the spike so that it points left, then down, then left. This reeves the spike through LP.2 from top to bottom. At the same time unreeve (remove) the left forefinger from LP.2, from up to down. The spike points left.
* MV(Spike.1^:A), TT(tt)	Pull the spike aft until line is moderately taut.
This marlinspike hitch is "from the bottom" because the spike starts from under the cord. There's another method in which the spike starts from above. While the method has been chopped into stages, the motion of the toggle is a smooth circle. Viewed from the right, it starts about 3:00, and moves counter-clockwise through 12:00, 9:00, and 6:00. It's finshed when it returns to 3:00. This formula illustrates how to name an object (the spike) not pre-defined in the notation and how to notate actions by toggles or other tools used in the tying method.

This notation was first put online July 26, 2002.

Also see my guide, Knots on the Web.

The right arrow ("until" operator) uses the Symbol Font, which is installed by default on most but not all computers. See Alan Wood's guide to its symbols.