Magnitude conjecture

MagnitudeConjecture.Algebra.StringWord

Words for string algebras #

A string word is a path in the symmetrified displayed quiver. Reduction is expressed by excluding a contiguous arrow--inverse pair. The monomial relations are excluded in both orientations: every contiguous positive path in the word and in its reverse must survive the quotient.

This is the word convention used by Butler--Ringel, phrased without choosing sign functions at the vertices. The sign functions are useful for ordering strings, but are not part of the underlying string or its module.

@[reducible, inline]
abbrev MagnitudeConjecture.BoundQuiver.StringWord.SignedPath {Q : Type u} [Quiver Q] (x y : Q) :

A path in the quiver obtained by adjoining a formal inverse to every displayed arrow.

Instances For
    @[reducible, inline]

    One arrow in the symmetrified displayed quiver.

    Instances For
      theorem MagnitudeConjecture.BoundQuiver.StringWord.path_comp_decomposition_unique {V : Type u_1} [Quiver V] {a b c d : V} {p₁ : Quiver.Path a b} {q₁ : Quiver.Path b d} {p₂ : Quiver.Path a c} {q₂ : Quiver.Path c d} (hcomp : p₁.comp q₁ = p₂.comp q₂) (hlength : p₁.length = p₂.length) :
      ∃ (_ : b = c), p₁ ≍ p₂ ∧ q₁ ≍ q₂

      Two decompositions of a quiver path at the same length have the same intermediate vertex, prefix, and suffix.

      theorem MagnitudeConjecture.BoundQuiver.StringWord.path_exists_comp_of_comp_eq_comp_of_length_le {V : Type u_1} [Quiver V] {a b c d : V} {p₁ : Quiver.Path a b} {q₁ : Quiver.Path b d} {p₂ : Quiver.Path a c} {q₂ : Quiver.Path c d} (hcomp : p₁.comp q₁ = p₂.comp q₂) (hlength : p₁.length ≤ p₂.length) :
      ∃ (t : Quiver.Path b c), p₂ = p₁.comp t

      If two paths are prefixes of the same path, the shorter one is a prefix of the longer one.

      def MagnitudeConjecture.BoundQuiver.StringWord.IsContiguousSubpath {V : Type u_1} [Quiver V] {x y a b : V} (p : Quiver.Path x y) (w : Quiver.Path a b) :

      A path occurs contiguously inside another path when the latter factors as a prefix, followed by that path, followed by a suffix.

      Instances For
        theorem MagnitudeConjecture.BoundQuiver.StringWord.isContiguousSubpath_refl {V : Type u_1} [Quiver V] {x y : V} (p : Quiver.Path x y) :

        Every path is a contiguous subpath of itself.

        theorem MagnitudeConjecture.BoundQuiver.StringWord.IsContiguousSubpath.trans {V : Type u_1} [Quiver V] {x y a b c d : V} {p : Quiver.Path x y} {q : Quiver.Path a b} {w : Quiver.Path c d} (hpq : IsContiguousSubpath p q) (hqw : IsContiguousSubpath q w) :

        Contiguous-subpath containment is transitive.

        theorem MagnitudeConjecture.BoundQuiver.StringWord.IsContiguousSubpath.length_le {V : Type u_1} [Quiver V] {x y a b : V} {p : Quiver.Path x y} {w : Quiver.Path a b} (h : IsContiguousSubpath p w) :
        p.length ≤ w.length

        A contiguous subpath cannot be longer than the ambient path.

        theorem MagnitudeConjecture.BoundQuiver.StringWord.isContiguousSubpath_comp_toPath_comp_of_not_boundary {Q : Type u} [Quiver Q] {a b c d x y : Q} {p : SignedPath x y} (left : SignedPath a b) (e : SignedArrow b c) (right : SignedPath c d) (hsub : IsContiguousSubpath p (Quiver.Path.comp left ((Quiver.Hom.toPath e).comp right))) (hboundary : ¬IsContiguousSubpath (Quiver.Hom.toPath e) p) :

        If a contiguous subpath of left ++ e ++ right does not contain the distinguished boundary arrow e, then it lies wholly on one side of that boundary.

        theorem MagnitudeConjecture.BoundQuiver.StringWord.isContiguousSubpath_comp_overlap {Q : Type u} [Quiver Q] {a b c d x y : Q} {p : SignedPath x y} (left : SignedPath a b) (middle : SignedPath b c) (right : SignedPath c d) (hsub : IsContiguousSubpath p (Quiver.Path.comp left (Quiver.Path.comp middle right))) (hlength : Quiver.Path.length p ≤ Quiver.Path.length middle + 1) :
        IsContiguousSubpath p (Quiver.Path.comp left middle) ∨ IsContiguousSubpath p (Quiver.Path.comp middle right)

        A contiguous subpath short enough not to span a nonempty overlap lies in one of the two overlapping paths.

        theorem MagnitudeConjecture.BoundQuiver.StringWord.isContiguousSubpath_reverse_iff {V : Type u_1} [Quiver V] [Quiver.HasInvolutiveReverse V] {x y a b : V} (p : Quiver.Path x y) (w : Quiver.Path a b) :
        IsContiguousSubpath p.reverse w.reverse ↔ IsContiguousSubpath p w

        Reversal carries a contiguous subpath to the reversed contiguous subpath, and conversely.

        theorem MagnitudeConjecture.BoundQuiver.StringWord.length_reverse {V : Type u_1} [Quiver V] [Quiver.HasReverse V] {x y : V} (p : Quiver.Path x y) :
        p.reverse.length = p.length

        Reversing a path preserves its length.

        def MagnitudeConjecture.BoundQuiver.StringWord.positiveArrow {Q : Type u} [Quiver Q] {x y : Q} (a : x ⟶ y) :

        The positive signed copy of a displayed arrow, with the symmetrified quiver instance pinned explicitly.

        Instances For
          def MagnitudeConjecture.BoundQuiver.StringWord.negativeArrow {Q : Type u} [Quiver Q] {x y : Q} (a : x ⟶ y) :

          The negative signed copy of a displayed arrow, traversed backwards.

          Instances For
            @[simp]
            theorem MagnitudeConjecture.BoundQuiver.StringWord.reverse_positiveArrow {Q : Type u} [Quiver Q] {x y : Q} (a : x ⟶ y) :
            Quiver.reverse (positiveArrow a) = negativeArrow a
            @[simp]
            theorem MagnitudeConjecture.BoundQuiver.StringWord.reverse_negativeArrow {Q : Type u} [Quiver Q] {x y : Q} (a : x ⟶ y) :
            Quiver.reverse (negativeArrow a) = positiveArrow a
            def MagnitudeConjecture.BoundQuiver.StringWord.positivePath {Q : Type u} [Quiver Q] {x y : Q} (p : Quiver.Path x y) :

            The positive copy of an ordinary displayed-quiver path in the symmetrified quiver.

            Instances For
              @[simp]
              theorem MagnitudeConjecture.BoundQuiver.StringWord.positivePath_nil {Q : Type u} [Quiver Q] (x : Q) :
              positivePath Quiver.Path.nil = Quiver.Path.nil
              @[simp]
              theorem MagnitudeConjecture.BoundQuiver.StringWord.positivePath_comp {Q : Type u} [Quiver Q] {x y z : Q} (p : Quiver.Path x y) (q : Quiver.Path y z) :
              positivePath (p.comp q) = Quiver.Path.comp (positivePath p) (positivePath q)
              @[simp]
              theorem MagnitudeConjecture.BoundQuiver.StringWord.positivePath_cons {Q : Type u} [Quiver Q] {x y z : Q} (p : Quiver.Path x y) (a : y ⟶ z) :
              positivePath (p.cons a) = Quiver.Path.comp (positivePath p) (positivePath a.toPath)
              @[simp]
              theorem MagnitudeConjecture.BoundQuiver.StringWord.positivePath_length {Q : Type u} [Quiver Q] {x y : Q} (p : Quiver.Path x y) :
              Quiver.Path.length (positivePath p) = p.length
              @[simp]
              theorem MagnitudeConjecture.BoundQuiver.StringWord.positivePath_toPath {Q : Type u} [Quiver Q] {x y : Q} (a : x ⟶ y) :
              positivePath a.toPath = Quiver.Hom.toPath (positiveArrow a)
              def MagnitudeConjecture.BoundQuiver.StringWord.signedPathSigns {Q : Type u} [Quiver Q] {x y : Quiver.Symmetrify Q} :
              Quiver.Path x y → List Bool

              The signs of a signed path, listed from its final letter backwards.

              Instances For
                @[simp]
                theorem MagnitudeConjecture.BoundQuiver.StringWord.signedPathSigns_comp {Q : Type u} [Quiver Q] {x y z : Quiver.Symmetrify Q} (p : Quiver.Path x y) (q : Quiver.Path y z) :
                @[simp]
                theorem MagnitudeConjecture.BoundQuiver.StringWord.signedPathSigns_positivePath {Q : Type u} [Quiver Q] {x y : Q} (p : Quiver.Path x y) :
                signedPathSigns (positivePath p) = List.replicate p.length false
                @[simp]
                theorem MagnitudeConjecture.BoundQuiver.StringWord.signedPathSigns_negativeArrow {Q : Type u} [Quiver Q] {x y : Q} (a : x ⟶ y) :
                signedPathSigns (Quiver.Hom.toPath (negativeArrow a)) = [true]
                theorem MagnitudeConjecture.BoundQuiver.StringWord.not_negativeArrow_contiguousSubpath_positivePath {Q : Type u} [Quiver Q] {x y a b : Q} (e : x ⟶ y) (p : Quiver.Path a b) :
                ¬IsContiguousSubpath (Quiver.Hom.toPath (negativeArrow e)) (positivePath p)

                A negative signed arrow cannot occur inside a positive ordinary path.

                def MagnitudeConjecture.BoundQuiver.StringWord.IsReduced {Q : Type u} [Quiver Q] {x y : Q} (w : SignedPath x y) :

                A signed path is reduced when it contains no adjacent formal inverse pair.

                Instances For
                  theorem MagnitudeConjecture.BoundQuiver.StringWord.isReduced_reverse_iff {Q : Type u} [Quiver Q] {x y : Q} (w : SignedPath x y) :
                  IsReduced (Quiver.Path.reverse w) ↔ IsReduced w

                  Reduction is invariant under reversing a signed path.

                  theorem MagnitudeConjecture.BoundQuiver.StringWord.isReduced_of_length_lt_two {Q : Type u} [Quiver Q] {x y : Q} (w : SignedPath x y) (hw : Quiver.Path.length w < 2) :

                  Every signed path of length at most one is reduced.

                  theorem MagnitudeConjecture.BoundQuiver.StringWord.isReduced_toPath_comp_toPath_of_not_heq_reverse {Q : Type u} [Quiver Q] {a b c : Q} (e : SignedArrow a b) (f : SignedArrow b c) (hnot : ¬f ≍ Quiver.reverse e) :
                  IsReduced ((Quiver.Hom.toPath e).comp (Quiver.Hom.toPath f))

                  A two-letter signed path is reduced when its second letter is not the formal inverse of its first, allowing the endpoints to be dependent.

                  theorem MagnitudeConjecture.BoundQuiver.StringWord.isReduced_toPath_comp_zero_comp_toPath_of_not_heq_reverse {Q : Type u} [Quiver Q] {a b c d : Q} (e : SignedArrow a b) (middle : SignedPath b c) (f : SignedArrow c d) (hmiddle : Quiver.Path.length middle = 0) (hnot : ¬f ≍ Quiver.reverse e) :
                  IsReduced ((Quiver.Hom.toPath e).comp (Quiver.Path.comp middle (Quiver.Hom.toPath f)))

                  A zero-length path between two noncancelling signed letters does not affect reducedness.

                  theorem MagnitudeConjecture.BoundQuiver.StringWord.IsReduced.of_contiguousSubpath {Q : Type u} [Quiver Q] {x y a b : Q} {p : SignedPath x y} {w : SignedPath a b} (hw : IsReduced w) (hpw : IsContiguousSubpath p w) :

                  Every contiguous subpath of a reduced signed path is reduced.

                  theorem MagnitudeConjecture.BoundQuiver.StringWord.isReduced_comp_of_overlap {Q : Type u} [Quiver Q] {a b c d : Q} (left : SignedPath a b) (middle : SignedPath b c) (right : SignedPath c d) (hmiddle : 0 < Quiver.Path.length middle) (hleft : IsReduced (Quiver.Path.comp left middle)) (hright : IsReduced (Quiver.Path.comp middle right)) :
                  IsReduced (Quiver.Path.comp left (Quiver.Path.comp middle right))

                  Reducedness glues across a nonempty overlap: an inverse pair is too short to span both ends of that overlap.

                  def MagnitudeConjecture.BoundQuiver.StringWord.AvoidsRelations {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) {x y : Q} (w : SignedPath x y) :

                  Every positive ordinary-quiver path occurring in the signed word survives the relation quotient.

                  Instances For
                    theorem MagnitudeConjecture.BoundQuiver.StringWord.avoidsRelations_of_length_lt_two {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (hR : IsAdmissible R) {x y : Q} (w : SignedPath x y) (hw : Quiver.Path.length w < 2) :

                    In an admissible quotient, every signed word of length at most one avoids relations: all of its positive subpaths have length below two.

                    theorem MagnitudeConjecture.BoundQuiver.StringWord.AvoidsRelations.of_contiguousSubpath {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) {x y a b : Q} {p : SignedPath x y} {w : SignedPath a b} (hw : AvoidsRelations R w) (hpw : IsContiguousSubpath p w) :

                    Avoiding the monomial relations is inherited by contiguous subpaths.

                    theorem MagnitudeConjecture.BoundQuiver.StringWord.avoidsRelations_comp_negativeArrow_comp {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) {a b d : Q} (left : SignedPath a b) {x : Q} (e : x ⟶ b) (right : SignedPath x d) (hleft : AvoidsRelations R left) (hright : AvoidsRelations R right) :
                    AvoidsRelations R (Quiver.Path.comp left ((Quiver.Hom.toPath (negativeArrow e)).comp right))

                    A negative signed boundary blocks every positive ordinary subpath, so avoidance of relations glues across it.

                    def MagnitudeConjecture.BoundQuiver.StringWord.IsString {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) {x y : Q} (w : SignedPath x y) :

                    The Butler--Ringel string condition: the signed path is reduced and no positive subpath of it or of its inverse belongs to the monomial relation ideal.

                    Instances For
                      theorem MagnitudeConjecture.BoundQuiver.StringWord.isString_cast {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) {a b a' b' : Quiver.Symmetrify Q} (ha : a = a') (hb : b = b') (p : Quiver.Path a b) :
                      IsString R (Quiver.Path.cast ha hb p) ↔ IsString R p

                      Casting the displayed endpoints of a signed path does not change whether it is a string.

                      theorem MagnitudeConjecture.BoundQuiver.StringWord.path_cast_comp_cast_toPath {Q : Type u} [Quiver Q] {a b a' b' c : Quiver.Symmetrify Q} (p : Quiver.Path a b) (e : b' ⟶ c) (ha : a = a') (hb : b = b') :
                      Quiver.Path.cast ha ⋯ (p.comp (Quiver.Hom.cast ⋯ ⋯ e).toPath) = (Quiver.Path.cast ha hb p).comp e.toPath

                      Casting the endpoint of a prefix and casting the source of the appended arrow cancel when the two pieces are composed.

                      theorem MagnitudeConjecture.BoundQuiver.StringWord.path_cast_target_injective {V : Type u_1} [Quiver V] {a b b' : V} (h : b = b') :
                      Function.Injective fun (p : Quiver.Path a b) => Quiver.Path.cast ⋯ h p

                      Casting only the target of a quiver path is injective.

                      @[simp]
                      theorem MagnitudeConjecture.BoundQuiver.StringWord.path_cast_length {V : Type u_1} [Quiver V] {a b a' b' : V} (ha : a = a') (hb : b = b') (p : Quiver.Path a b) :
                      (Quiver.Path.cast ha hb p).length = p.length

                      Endpoint casts preserve path length.

                      theorem MagnitudeConjecture.BoundQuiver.StringWord.path_cast_comp_target {V : Type u_1} [Quiver V] {a b c c' : V} (p : Quiver.Path a b) (q : Quiver.Path b c) (h : c = c') :
                      Quiver.Path.cast ⋯ h (p.comp q) = p.comp (Quiver.Path.cast ⋯ h q)

                      Casting the target of a composite is the same as casting the target of its second factor.

                      theorem MagnitudeConjecture.BoundQuiver.StringWord.path_reverse_cast {Q : Type u} [Quiver Q] {a b a' b' : Quiver.Symmetrify Q} (ha : a = a') (hb : b = b') (p : Quiver.Path a b) :
                      (Quiver.Path.cast ha hb p).reverse = Quiver.Path.cast hb ha p.reverse

                      Reversing an endpoint-cast path casts the reversed path at the swapped endpoints.

                      theorem MagnitudeConjecture.BoundQuiver.StringWord.isString_comp_cast_toPath {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) {a b a' b' c : Quiver.Symmetrify Q} (p : Quiver.Path a b) (e : b' ⟶ c) (ha : a = a') (hb : b = b') (h : IsString R ((Quiver.Path.cast ha hb p).comp e.toPath)) :
                      IsString R (p.comp (Quiver.Hom.cast ⋯ ⋯ e).toPath)

                      A string extension may be transported across endpoint equalities by casting the old path and the new arrow in opposite directions.

                      theorem MagnitudeConjecture.BoundQuiver.StringWord.isString_comp_of_negative_positive_boundaries_of_reduced {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) {a b c d e f : Q} (leftTail : SignedPath a b) (leftArrow : c ⟶ b) (middle : SignedPath c d) (rightArrow : d ⟶ e) (rightTail : SignedPath e f) (hreduced : IsReduced (Quiver.Path.comp leftTail ((Quiver.Hom.toPath (negativeArrow leftArrow)).comp (Quiver.Path.comp middle ((Quiver.Hom.toPath (positiveArrow rightArrow)).comp rightTail))))) (hleft : IsString R (Quiver.Path.comp leftTail ((Quiver.Hom.toPath (negativeArrow leftArrow)).comp middle))) (hright : IsString R (Quiver.Path.comp middle ((Quiver.Hom.toPath (positiveArrow rightArrow)).comp rightTail))) :
                      IsString R (Quiver.Path.comp leftTail ((Quiver.Hom.toPath (negativeArrow leftArrow)).comp (Quiver.Path.comp middle ((Quiver.Hom.toPath (positiveArrow rightArrow)).comp rightTail))))

                      Once reducedness is known, two one-ended strings glue across a negative left boundary and a positive right boundary. The signs prevent relations from crossing either seam.

                      theorem MagnitudeConjecture.BoundQuiver.StringWord.isString_comp_of_negative_positive_boundaries {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) {a b c d e f : Q} (leftTail : SignedPath a b) (leftArrow : c ⟶ b) (middle : SignedPath c d) (rightArrow : d ⟶ e) (rightTail : SignedPath e f) (hmiddle : 0 < Quiver.Path.length middle) (hleft : IsString R (Quiver.Path.comp leftTail ((Quiver.Hom.toPath (negativeArrow leftArrow)).comp middle))) (hright : IsString R (Quiver.Path.comp middle ((Quiver.Hom.toPath (positiveArrow rightArrow)).comp rightTail))) :
                      IsString R (Quiver.Path.comp leftTail ((Quiver.Hom.toPath (negativeArrow leftArrow)).comp (Quiver.Path.comp middle ((Quiver.Hom.toPath (positiveArrow rightArrow)).comp rightTail))))

                      Two strings with a nonempty common middle glue when the new outer boundaries have the hook signs: negative on the left and positive on the right.

                      theorem MagnitudeConjecture.BoundQuiver.StringWord.isString_of_length_lt_two {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (hR : IsAdmissible R) {x y : Q} (w : SignedPath x y) (hw : Quiver.Path.length w < 2) :

                      Every signed path of length at most one is a string for an admissible bound-quiver presentation.

                      theorem MagnitudeConjecture.BoundQuiver.StringWord.isString_reverse_iff {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) {x y : Q} (w : SignedPath x y) :
                      IsString R (Quiver.Path.reverse w) ↔ IsString R w

                      A string remains a string after reversing every letter and the order of the word.

                      theorem MagnitudeConjecture.BoundQuiver.StringWord.IsString.of_contiguousSubpath {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) {x y a b : Q} {p : SignedPath x y} {w : SignedPath a b} (hw : IsString R w) (hpw : IsContiguousSubpath p w) :

                      Every contiguous subpath of a string is a string.

                      structure MagnitudeConjecture.BoundQuiver.StringWord.Word {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) :

                      A bundled string word, including its displayed endpoints.

                      Instances For
                        theorem MagnitudeConjecture.BoundQuiver.StringWord.Word.isReduced_positiveArrow_comp_positiveArrow {Q : Type u} [Quiver Q] {x y z : Q} (a : x ⟶ y) (b : y ⟶ z) :
                        IsReduced ((Quiver.Hom.toPath (positiveArrow a)).comp (Quiver.Hom.toPath (positiveArrow b)))

                        Two consecutive positive letters cannot cancel.

                        theorem MagnitudeConjecture.BoundQuiver.StringWord.Word.isReduced_negativeArrow_comp_negativeArrow {Q : Type u} [Quiver Q] {x y z : Q} (a : y ⟶ x) (b : z ⟶ y) :
                        IsReduced ((Quiver.Hom.toPath (negativeArrow a)).comp (Quiver.Hom.toPath (negativeArrow b)))

                        Two consecutive negative letters cannot cancel.

                        theorem MagnitudeConjecture.BoundQuiver.StringWord.Word.isReduced_negativeArrow_comp_positiveArrow_of_star_ne {Q : Type u} [Quiver Q] {x y z : Q} (b : x ⟶ y) (a : x ⟶ z) (hba : ⟨y, b⟩ ≠ ⟨z, a⟩) :
                        IsReduced ((Quiver.Hom.toPath (negativeArrow b)).comp (Quiver.Hom.toPath (positiveArrow a)))

                        A negative letter followed by a positive letter is reduced when their underlying arrows are distinct in the common-source star.

                        theorem MagnitudeConjecture.BoundQuiver.StringWord.Word.isReduced_positiveArrow_comp_negativeArrow_of_costar_ne {Q : Type u} [Quiver Q] {x y z : Q} (a : x ⟶ y) (b : z ⟶ y) (hab : ⟨x, a⟩ ≠ ⟨z, b⟩) :
                        IsReduced ((Quiver.Hom.toPath (positiveArrow a)).comp (Quiver.Hom.toPath (negativeArrow b)))

                        A positive letter followed by a negative letter is reduced when their underlying arrows are distinct in the common-target costar.

                        theorem MagnitudeConjecture.BoundQuiver.StringWord.Word.ext {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) {C D : Word R} (hsource : C.source = D.source) (htarget : C.target = D.target) (hpath : C.path ≍ D.path) :
                        C = D

                        Bundled words are equal when their endpoints and dependent paths are equal; the string proof is proposition-valued.

                        theorem MagnitudeConjecture.BoundQuiver.StringWord.Word.ext_iff {k Q : Type u} [Field k] [Quiver Q] {R : RelationFamily k Q} {C D : Word R} :
                        C = D ↔ C.source = D.source ∧ C.target = D.target ∧ C.path ≍ D.path
                        def MagnitudeConjecture.BoundQuiver.StringWord.Word.vertex {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (hR : IsAdmissible R) (x : Q) :

                        The length-zero string at a displayed vertex.

                        Instances For
                          def MagnitudeConjecture.BoundQuiver.StringWord.Word.arrow {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (hR : IsAdmissible R) {x y : Q} (a : x ⟶ y) :

                          A displayed arrow as a positive string of length one.

                          Instances For
                            def MagnitudeConjecture.BoundQuiver.StringWord.Word.reverse {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (C : Word R) :

                            Reverse a bundled string word.

                            Instances For
                              def MagnitudeConjecture.BoundQuiver.StringWord.Word.inverseArrow {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (hR : IsAdmissible R) {x y : Q} (a : x ⟶ y) :

                              A displayed arrow traversed in the inverse direction.

                              Instances For
                                @[simp]
                                theorem MagnitudeConjecture.BoundQuiver.StringWord.Word.reverse_source {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (C : Word R) :
                                @[simp]
                                theorem MagnitudeConjecture.BoundQuiver.StringWord.Word.reverse_target {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (C : Word R) :
                                @[simp]
                                theorem MagnitudeConjecture.BoundQuiver.StringWord.Word.reverse_path {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (C : Word R) :
                                (reverse R C).path = Quiver.Path.reverse C.path
                                @[simp]
                                theorem MagnitudeConjecture.BoundQuiver.StringWord.Word.reverse_reverse {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (C : Word R) :
                                reverse R (reverse R C) = C
                                def MagnitudeConjecture.BoundQuiver.StringWord.Word.length {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (C : Word R) :
                                ℕ

                                Length of a string word.

                                Instances For
                                  @[simp]
                                  theorem MagnitudeConjecture.BoundQuiver.StringWord.Word.reverse_length {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (C : Word R) :
                                  length R (reverse R C) = length R C
                                  @[simp]
                                  theorem MagnitudeConjecture.BoundQuiver.StringWord.Word.vertex_length {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (hR : IsAdmissible R) (x : Q) :
                                  length R (vertex R hR x) = 0
                                  @[simp]
                                  theorem MagnitudeConjecture.BoundQuiver.StringWord.Word.arrow_length {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (hR : IsAdmissible R) {x y : Q} (a : x ⟶ y) :
                                  length R (arrow R hR a) = 1
                                  @[simp]
                                  theorem MagnitudeConjecture.BoundQuiver.StringWord.Word.inverseArrow_length {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (hR : IsAdmissible R) {x y : Q} (a : x ⟶ y) :
                                  length R (inverseArrow R hR a) = 1
                                  def MagnitudeConjecture.BoundQuiver.StringWord.Word.append {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (C : Word R) {z : Q} (e : SignedArrow C.target z) (h : IsString R (Quiver.Path.comp C.path (Quiver.Hom.toPath e))) :

                                  Append one signed arrow to a string word, provided the extended path is again a string.

                                  Instances For
                                    @[simp]
                                    theorem MagnitudeConjecture.BoundQuiver.StringWord.Word.append_source {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (C : Word R) {z : Q} (e : SignedArrow C.target z) (h : IsString R (Quiver.Path.comp C.path (Quiver.Hom.toPath e))) :
                                    (append R C e h).source = C.source
                                    @[simp]
                                    theorem MagnitudeConjecture.BoundQuiver.StringWord.Word.append_target {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (C : Word R) {z : Q} (e : SignedArrow C.target z) (h : IsString R (Quiver.Path.comp C.path (Quiver.Hom.toPath e))) :
                                    (append R C e h).target = z
                                    @[simp]
                                    theorem MagnitudeConjecture.BoundQuiver.StringWord.Word.append_path {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (C : Word R) {z : Q} (e : SignedArrow C.target z) (h : IsString R (Quiver.Path.comp C.path (Quiver.Hom.toPath e))) :
                                    (append R C e h).path = Quiver.Path.comp C.path (Quiver.Hom.toPath e)
                                    @[simp]
                                    theorem MagnitudeConjecture.BoundQuiver.StringWord.Word.append_length {k Q : Type u} [Field k] [Quiver Q] (R : RelationFamily k Q) (C : Word R) {z : Q} (e : SignedArrow C.target z) (h : IsString R (Quiver.Path.comp C.path (Quiver.Hom.toPath e))) :
                                    length R (append R C e h) = length R C + 1