| 
  • If you are citizen of an European Union member nation, you may not use this service unless you are at least 16 years old.

  • Stop wasting time looking for files and revisions. Connect your Gmail, DriveDropbox, and Slack accounts and in less than 2 minutes, Dokkio will automatically organize all your file attachments. Learn more and claim your free account.

View
 

Knots Terms

Page history last edited by dave@layhands.com 10 years, 5 months ago

Guiding Principles:

 

  1. The intent of these definitions is to create a clean and sensible and unambiguous language which is not bound or influenced by traditional terminology, except where the traditional terminology is sensible and useful.

 

  1. These definitions are intended to deal with the general case.  It is recognized that there might be exceptions to any rule or definition.

 

  1. It is understood that adjustments will need to be made along the way.

 

  1. Nodeology terms can be written in the following ways (using "Tail_End" as an example):

     

N.Tail_End -- This is pronounced as "n dot tail end" and it specifies that "Tail_End" is a Nodeology term.

 

N.B.K.Tail_End -- This is pronounced as "n dot b dot k dot tail end" and it specifies the exact path where "Tail_End" resides.  In this case, "Tail_End" resides in the Nodeology/Bindings/Knots path.

 

.Tail_End -- This is pronounced as "tail end" and it provides a less cumbersome way of specifying that "Tail_End" is a Nodeology term.

 

  1. There are no blank spaces in Nodeology terms because blank spaces are treated as special characters in certain areas of computing.  This is done for future growth in case the new terms are someday used in computing (e.g. XML).

 

  1. Directions are given from the perspective of the viewer, such as up, down, left, right, front (the side of the .Knot closest to the viewer), and behind (the back side of the .Knot which the viewer can't see). 

 

 

 

Definition of a .Knot:

 

  • N.Knot -- A .Knot is a gripping formation created by manipulating one or more .Cords, using only the outer surface of the .Cord(s).  The degree of gripping is not relevant, meaning that if the .Cord formation is CAPABLE of gripping under a .Load then it is a .Knot.  Some .Knots such as Bowlines allow for a .Ring to be created.  In this case, the .Knot is the part which grips the .Cord, and the .Ring is an artifact or by-product of the .Knot.  The .Ring is part of the .Knot_Structure, but it is not part of the .Knot itself.  Other .Knots such as Clove Hitches ONLY provide a gripping force when tied around an external object.  In this case, the external object is part of the .Knot_Structure but it is not part of the .Knot itself, and when the external object is removed then the .Cord formation is no longer a .Knot (instead, it's a "potential" .Knot).  If the external object is manipulated into a formation which assists the .Knot's gripping action, then the external object is a .Cord and is considered to be part of the .Knot. [discussion: 0 comments]

 

  • N.Knot_Structure -- A .Knot_Structure includes the .Knot (the part which has a gripping function) plus any by-products such as the .Tail_End and .Rings and so on.  It also includes any external objects which are required for the .Knot's gripping force (as in the case of a Clove Hitch, for example).  ".Knot_Structure" is often shortened to ".Knot" for simplicity (e.g. when we say that a Bowline and a Sheet Bend are two different .Knots, but we really mean that they are two different .Knot_Structures). [discussion: 0 comments]

 

 

 

Definitions of the parts of .Knots and actions relating to .Knots:

 

  • N.Tail_End -- The .Tail_End of a .Cord is the end section which is manipulated the most while tying a .Knot.  Traditionally referred to as the Working End, Running End, or Bitter End.  After a .Knot is tied, the .Tail_End is part of the .Knot_Structure, but it is not part of the .Knot itself because it does not contribute to the gripping action.  If two or more ends of .Cord are tied together then each end is a .Tail_End. [discussion: 0 comments]

 

  • N.Body -- From the perspective of an individual .Knot, the .Body of a .Cord is the section of .Cord which is outside of the .Knot and which enters into the .Knot and which is not the .Tail_End.  In other words, a .Knot generally sits between the .Tail_End and the .Body of the .Cord (as you trace out the path of the .Cord).  Traditionally referred to as the Standing Part.  If both ends of a .Cord are tied together then there are two .Tail_Ends and two .Cord .Bodies exactly as if two separate .Cords are tied together at the ends. [discussion: 0 comments]

 

  • N.Load -- When a force is holding or pulling on a section of .Cord (e.g. the .Body or the .Tail_End), then that section of .Cord is said to be .Loaded or under a .Load.  Traditionally referred to as Loaded or Tensioned. [discussion: 0 comments]

 

  • N.Ring -- A .Ring is the elliptical section of .Cord which is created when certain .Knots are tied (e.g. Bowlines).  .Rings are useful for throwing over a post, or for clipping onto with a carabiner, and so on.  Traditionally referred to as a Loop. [discussion: 1 or more comments]

 

  • N.Ring_Loading -- When two sections of a .Cord exit a .Knot together (such as two sides of a .Ring), and both sections are .Loaded in opposite directions perpendicular to their direction of travel out of the .Knot, then .Ring_Loading has taken place.  This can deform certain .Knots, and is therefore potentially dangerous.  Traditionally referred to as Ring Loading or Wrong Loading or Side Loading. [discussion: 0 comments]

 

  • N.Eye -- An .Eye is a permanent .Ring at the end of a .Cord which is usually made by .Splicing the end of the .Cord back to the .Cord itself.  Similar to an eye bolt. [discussion: 0 comments]

 

  • N.Collar(around .Body, leg1 behind, curve down) -- A .Collar is formed by taking a .Cord halfway around an object so that the .Cord continues in a direction OPPOSITE to its original direction of travel.  The "collared" object is completely surrounded on three sides (e.g. the behind, left, and front sides).

 

        A .Collar consists of the following parts:

       

          .Collar_Leg1 -- The "leg" of the .Collar BEFORE the .Cord curves around the object.  This is the first "leg" you would reach by tracing the .Cord from .Body to .Tail_End.

          .Collar_Curve -- The part of the .Collar which curves around the object and which is BETWEEN the two "legs."

          .Collar_Leg2 -- The "leg" of the .Collar AFTER the .Cord curves around the object.

   

      .Collar can be used with the following two-word parameters (in any order):  The "around" parameter specifies the object to be "collared," such as "around .Body" or "around tree."  The "leg1" parameter indicates whether .Collar_Leg1 crosses the object in front or behind or right or left or above or below.  The "curve" parameter indicates the initial direction in which the .Cord travels when it starts curving around the object. [discussion: 0 comments]

 

  • N.Wrap(around nothing, curve right, finish front, 1.5 times, two-finger size) -- A .Wrap is formed by taking a .Cord in a complete revolution around an object (or simply around the air) so that the .Cord continues in its ORIGINAL direction of travel.  Traditionally referred to as a Loop.

 

        A .Wrap consists of the following parts:

       

          .Wrap_Leg1 -- The "leg" of the .Wrap BEFORE the .Cord curves around the object.  This is the first "leg" you would reach by tracing the .Cord from .Body to .Tail_End.

          .Wrap_Curve -- The part of the .Wrap which curves around the object and which is BETWEEN the two "legs."

          .Wrap_Leg2 -- The "leg" of the .Wrap AFTER the .Cord curves around the object.

   

      .Wrap can be used with the following two-word parameters (in any order):  The "around" parameter specifies the object around which the .Cord is wrapped, such as "around tree" or "around nothing."  The "curve" parameter indicates the initial direction in which the .Cord travels when it starts curving around the object (or around the air).  The "finish" parameter indicates whether .Wrap_Leg2 crosses .Wrap_Leg1 in front or behind or right or left or above or below.  The "times" parameter is optional, and it indicates how many times the .Cord goes around the object ("1 time" is the default value).  "1.5 times" around an object is traditionally referred to as a Round Turn.  "0.5 times" or "1/2 times" around an object is the same as a .Collar.  The "size" parameter is optional, and it indicates the approximate size of the .Wrap, usually when the .Wrap is made in the air.  Some examples for the size parameter might be "two-finger size" (the size when wrapped around two fingers) or "hand size," etc. [discussion: 1 or more comments]

 

  • N.Grip_Wrap(around .Body, curve right, finish front) -- A .Grip_Wrap is a type of .Wrap which is intended to create a gripping action rather than a separation when both sides of the .Wrap are .Loaded in a direction perpendicular to the .Wrap.  Traditionally referred to as a Half Hitch.

 

        A .Grip_Wrap consists of the following parts:

       

          .Grip_Wrap_Leg1 -- The "leg" of the .Grip_Wrap BEFORE the .Cord curves around the object.  This is the first "leg" you would reach by tracing the .Cord from .Body to .Tail_End.

          .Grip_Wrap_Curve -- The part of the .Grip_Wrap which curves around the object and which is BETWEEN the two "legs."

          .Grip_Wrap_Leg2 -- The "leg" of the .Grip_Wrap AFTER the .Cord curves around the object.

   

      .Grip_Wrap can be used with the following two-word parameters (in any order):  The "around" parameter specifies the object around which the .Cord is wrapped, such as "around tree" or "around .Body."  The "curve" parameter indicates the initial direction in which the .Cord travels when it starts curving around the object.  The "finish" parameter indicates whether .Grip_Wrap_Leg2 crosses .Grip_Wrap_Leg1 in front or behind or right or left or above or below. [discussion: 0 comments]

 

  • N.Doubled_Cord -- A .Doubled_Cord is a length of .Cord which has been folded over ("doubled") to be used as if it's a single length of .Cord.

 

        A .Doubled_Cord consists of the following parts:

 

          .Doubled_Cord_Leg(left side) -- A .Doubled_Cord has two "legs," each of which can be specified by using the "side" parameter (e.g. "left side" or "front side" or "up side," etc.).

          .Doubled_End -- The .Tail_End of a .Doubled_Cord.  Traditionally referred to as a Bight.

          .Doubled_Cord_Curve -- When the "legs" of a .Doubled_End are separated to create a gap of any size, then the .Doubled_End is probably not being used as a .Tail_End at that point.  In this case (for consistency with other terms), the .Doubled_Cord_Curve is the part of the .Doubled_Cord which curves around BETWEEN the two "legs."  Traditionally referred to as a Bight. [discussion: 0 comments]

 

  • N.Easy_Release -- If a .Doubled_End is made in the .Tail_End of a .Cord, and the .Knot being tied is finished off by pushing the .Doubled_End through the .Knot instead of pushing the entire .Tail_End through, then the .Knot is usually easy to untie by pulling on the .Tail_End.  Such a .Knot is an .Easy_Release .Knot.  Traditionally referred to as a Slipped Knot. [discussion: 0 comments]

 

  • N.Push(thru .Wrap, from behind) -- .Push means that an object (e.g. the .Tail_End or a .Doubled_End) is pushed through an opening in another object (e.g. through a .Wrap).  .Push can be used with the following two-word parameters (in any order):  The "thru" parameter specifies the object which has the opening, such as "thru .Wrap."  The "from" parameter indicates the direction from which the .Cord goes through the opening, such as "from behind" or "from left."  Traditionally referred to as Reeving. [discussion: 0 comments]

     
  • N.Pull(thru .Wrap, from behind) -- .Pull is identical to .Push, but with a pulling motion. [discussion: 0 comments]

     
  • N.Cross(over .Body, from front) -- .Cross means that an object (e.g. the .Tail_End) is made to cross over another object.  .Cross can be used with the following two-word parameters (in any order):  The "over" parameter specifies the object which is being crossed over, such as "over .Body" or "over .Wrap" or "over tree."  The "from" parameter indicates whether the crossing is done in front or behind or right or left or above or below. [discussion: 0 comments]

 

  • N.Becomes -- While tying a .Knot, the completion of one action sometimes leaves the .Cord in a position such that another action is partially completed.  For example, when a .Wrap is completed then the .Tail_End might be in such a position that the first part of a .Collar has been performed.  If a .Collar is the next step in the tying sequence after the .Wrap, then these steps can be written in the form of ".Wrap .Becomes .Collar." [discussion: 0 comments]

 

  • N.FlipSides(left becomes right, behind becomes front) -- .FlipSides means that a .Knot or other object should be flipped.  The two parameters specify the sides which need to be flipped (e.g. "front becomes behind, up becomes down"), but only one parameter is needed for specifying a rotation (e.g. "down becomes right"). [discussion: 0 comments]

  

  • N.Set -- A .Knot is .Set when all sections of .Cord which are involved in gripping are snug and tight against each other.  This means that the looseness within the .Knot has been removed, but it does not necessarily mean that the .Knot has been pulled as tight as possible. [discussion: 0 comments]

 

  • N.Dressed -- The knot-tyer should ensure that all sections of .Cord are in their desired positions while a .Knot is being .Set.  This is referred to as .Dressing a .Knot.  If a .Knot is .Dressed improperly then some sections of .Cord might be subjected to unnecessary stresses which can weaken the .Cord.  A .Knot can be .Dressed in a wide variety of ways (of which only one or two might be considered "proper"), and it's possible that some of these .Dressings will result in different .Knots.  See "Differentiating between .Knots" below. [discussion: 0 comments] 

 

 

 

Definitions of the types of .Knots:

 

  • N.Ring_Type -- A type of .Knot which creates a .Ring (e.g. an Alpine Butterfly).  Traditionally referred to as a Single Loop Knot.

 

  • N.Two_Ring_Type -- A type of .Knot which creates two .Rings (e.g. a Double Alpine Butterfly).  Traditionally referred to as a Double Loop Knot.

 

  • N.Three_Ring_Type -- A type of .Knot which creates three .Rings (e.g. a Triple Alpine Butterfly).  Traditionally referred to as a Triple Loop Knot.

 

  • N.Union_Type -- A type of .Knot which is used for tying two or more .Tail_Ends together (whether from the same .Cord or from different .Cords).  Traditionally referred to as a Bend.

 

  • N.Tether_Type -- A type of .Knot which is used for tying a .Cord around an object and which relies on conforming to the shape of the object for its gripping/holding force.  Traditionally referred to as a Hitch.  If an animal is tethered to a post using a Bowline, for example, then the Bowline would be referred to as a .Ring_Type because it doesn't rely on conforming to the shape of the object for its gripping/holding force.

 

  • N.Endless_Ring -- Formed by tying a .Union_Type .Knot using both ends of a single .Cord.  Traditionally referred to as a Sling.

 [discussion: 1 or more comments]

 

 

Differentiating between .Knots:

 

The following guidelines can help determine whether two .Knots are the same as each other or different from each other:

 

  • If two .Knots have a different geometry/structure then they are different .Knots.  For example, the Overhand Knot and the Figure-Eight Knot have a different geometry/structure, so they are different .Knots.

 

  • If two .Knots have the same essential geometry/structure, but they are .Dressed differently, then they are the same .Knot.  For example, the Alpine Butterfly can be .Dressed so that both ends of .Cord leave the .Knot in opposite directions to each other (perpendicular to the .Knot_Structure), or it can be .Dressed so that both ends leave the .Knot parallel to each other.  These two .Dressings result in the same .Knot.  However, if two .Knots have the same essential geometry/structure while being tied, but they are .Dressed differently such that their gripping characteristics are not the same, then they are different .Knots.

 

  • If two .Knots have the same geometry/structure but their "types" are different, then they are different .Knots.  For example, the Sheet Bend and the Bowline have the same geometry/structure in their .Knots, but the Sheet Bend is a .Union_Type and the Bowline is a .Ring_Type.  Since they are different types of .Knots, they are therefore considered to be different .Knots.

 

  • Different tying methods result in the same .Knot unless there is a difference in the .Knots as described above.

 

 

There will be situations which are not easily resolved using the above guidelines.  For example, if two .Knots have the same essential geometry/structure, but they have different "handedness" (e.g. if one .Knot is tied using a .Wrap(from FRONT) and the other .Knot is tied using a .Wrap(from BEHIND)), then are they different .Knots?  If the .Tail_End of one Bowline is tied so that it enhances the overall gripping ability compared to the .Tail_End of a second Bowline, then should they be considered as different .Knots or should they be considered as "variants" of the same .Knot?  If a .Knot is tied by combining two or more different .Knots, then should it be considered as a .Knot in its own right?  If two .Knots are the same in all respects based on the above guidelines, but they are .Loaded differently, then should they be considered as different .Knots?

 

At the present time there is no objective method which handles all of the possible scenarios for differentiating between .Knots, and no objective method is on the horizon.  Therefore, in practice it's the general consensus which determines if .Knots are "new" or "different" or "variants."

[discussion: 0 comments]

 

Comments (9)

dave@layhands.com said

at 8:38 pm on Feb 14, 2010

Added ".Knot_Structure." Added ".Eye." Added a section called "Differentiating between .Knots."

DerekSmith said

at 7:38 pm on Feb 18, 2010

Dave, might need to review the 'Differentiation' section above to be able to handle the fact that a .knot can be dressed to an extreme variation ie the Reef or the bowline can both be capsized (just a form of dressing), yet they are just dressing differences.

I believe that we will have to accept that a .knot is 'different' if the forces in use take differing paths - this effectively means that one structure might be capable of generating an almost continuous spectrum of 'different' .knots.

Of note, even incorporating twist into a cord being formed into a .knot changes the functional properties of that .knot -- so it is a different .knot ??

dave@layhands.com said

at 10:17 pm on Feb 18, 2010

The second bullet item says, "...However, if two .Knots have the same essential geometry/structure while being tied, but they are dressed differently such that their gripping characteristics are not the same, then they are different .Knots."

Maybe that should be changed to: "...However, if two .Knots have the same essential geometry/structure while being tied, but they are dressed differently such that the forces in use take differing paths, then they are different .Knots." How does that sound?

If there's a twist in the .Cord, then in the general case would that be a dressing issue which shouldn't be considered as a different .Knot?

dave@layhands.com said

at 1:40 pm on Feb 19, 2010

Since one structure might be capable of generating an almost continuous spectrum of 'different' .Knots, as you pointed out, then it's not likely that we'll be able to define a strict rule for when a dressing has resulted in a different .Knot.

Therefore, maybe the second bullet item should be changed to: "...However, if two .Knots have the same essential geometry/structure while being tied, but they are dressed differently such that the forces in use take differing paths, then they might be considered as different .Knots according to the general consensus."

How does that sound?

dave@layhands.com said

at 2:20 pm on Feb 19, 2010

Added ".Dressed." Added ".Set."

DerekSmith said

at 12:23 am on Feb 20, 2010

@ Dave - differentiation between .knots.

I think the point is that in the IGKT sense, 'knot' has a meaning in that it vaguely describes a binding of recognisable construction, and largely ignores the finessing of detailed dressing and the extreme finessing of dressing out twist. Furthermore, it fundamentally rules out the impact of forces on the 'primary' (i.e. dressed) structure, the movement through an almost infinite spectrum of other forms (some of which are relatively stable) into numerous capsized versions.

The .Knot we are defining must somehow be able to encompass every single aspect and form that it is possible for this tied form, dressed, set, under load and during deformation. Somehow .knot has to define and encompass this whole matrix of forms. A .knot is not a single entity, it is a set, a continuum a whole piece of the surface of the 2D matrix I touched on in the forum.

The big problem is that the .knot 'space' is analogue in nature - it is the integral between set limits.

I am rambling - so need to give this more time to gel

dave@layhands.com said

at 12:15 pm on Feb 22, 2010

Perhaps we need to define a set of .Knot properties or characteristics as subheadings under .Knot, such as a "Name" or "Primary Name" (e.g. "Bowline"), and an "ABOK#," and a list of "Traditional Names," and properties which encompass every aspect and form that is possible for this tied form, dressed, set, under load and during deformation, etc.

dave@layhands.com said

at 7:19 pm on Feb 23, 2010

Added item #6 under Guiding Principles. Modified N.Wrap and N.Grip_Wrap. Added N.Collar, N.Quarter_Wrap, N.PushThru, N.PullThru, and N.CrossOver. These additions and modifications were driven by the knot-tying notation which is under development.

dave@layhands.com said

at 7:28 pm on Mar 1, 2010

Added more parameters to .Collar, .Wrap, .Grip_Wrap, .Push, .Pull, and .Cross. Added .Doubled_Cord, .Becomes, and .FlipSides. Removed .Quarter_Wrap. Renamed .PushThru to .Push, and .PullThru to .Pull, and .CrossOver to .Cross, and .Ring_Knot to .Ring_Type, etc., and .Union_Knot to .Union_Type, and .Tether_Knot to .Tether_Type.

You don't have permission to comment on this page.