Remove excessive parenthesis in addition and tensor products (#106)

* rm excessive parenthesis in homogeneous ops

* add similar printing methods for inhomogeneous ops

* make slight tweak to SApplyKet printing

Author: apkille

docs/src/introduction.md

@@ -78,7 +78,7 @@ Similar scaling procedures can be performed on bras and operators. Addition betw
 julia> @op A₁; @op A₂;
 
 julia> A₁+A₂
-(A₁+A₂)
+A₁+A₂
 
 julia> @bra b;
 
@@ -120,7 +120,7 @@ julia> 3*A*B*k
 3AB|k⟩
 
 julia> A⊗(k*b + B)
-(A⊗(B+|k⟩⟨b|))
+A⊗(B+|k⟩⟨b|)
 
 julia> A-A
 𝟎
@@ -215,10 +215,10 @@ julia> using Symbolics
 julia> @op A; @ket k;
 
 julia> ex = 2*A + projector(k)
-(2A+𝐏[|k⟩])
+2A+𝐏[|k⟩]
 
 julia> substitute(ex, Dict([A => X, k => X1]))
-(2X+𝐏[|X₁⟩])
+2X+𝐏[|X₁⟩]
 ```
 
 ## Simplifying Expressions
@@ -259,18 +259,18 @@ Symbolic expressions containing quantum objects can be expanded with the [`qexpa
 julia> @op A; @op B; @op C;
 
 julia> qexpand(A⊗(B+C))
-((A⊗B)+(A⊗C))
+(A⊗B)+(A⊗C)
 
 julia> qexpand((B+C)*A)
-(BA+CA)
+BA+CA
 
 julia> @ket k₁; @ket k₂; @ket k₃;
 
 julia> qexpand(k₁⊗(k₂+k₃))
-(|k₁⟩|k₂⟩+|k₁⟩|k₃⟩)
+|k₁⟩|k₂⟩+|k₁⟩|k₃⟩
 
 julia> qexpand((A*B)*(k₁+k₂))
-(AB|k₁⟩+AB|k₂⟩)
+AB|k₁⟩+AB|k₂⟩
 ```
 
 ## Numerical Translation of Symbolic Objects

src/QSymbolicsBase/basic_ops_homogeneous.jl

@@ -76,7 +76,7 @@ end
 julia> @ket k₁; @ket k₂;
 
 julia> k₁ + k₂
-(|k₁⟩+|k₂⟩)
+|k₁⟩+|k₂⟩
 ```
 """
 @withmetadata struct SAdd{T<:QObj} <: Symbolic{T}
@@ -107,17 +107,18 @@ basis(x::SAdd) = basis(first(x.dict).first)
 const SAddBra = SAdd{AbstractBra}
 function Base.show(io::IO, x::SAddBra)
     ordered_terms = sort([repr(i) for i in arguments(x)])
-    print(io, "("*join(ordered_terms,"+")::String*")") # type assert to help inference
+    print(io, join(ordered_terms,"+")::String) # type assert to help inference
 end
 const SAddKet = SAdd{AbstractKet}
 function Base.show(io::IO, x::SAddKet)
     ordered_terms = sort([repr(i) for i in arguments(x)])
-    print(io, "("*join(ordered_terms,"+")::String*")") # type assert to help inference
+    print(io, join(ordered_terms,"+")::String) # type assert to help inference
 end
 const SAddOperator = SAdd{AbstractOperator}
 function Base.show(io::IO, x::SAddOperator)
-    ordered_terms = sort([repr(i) for i in arguments(x)])
-    print(io, "("*join(ordered_terms,"+")::String*")") # type assert to help inference
+    repr_func = x -> x isa STensor ? "("*repr(x)*")" : repr(x)
+    ordered_terms = sort([repr_func(i) for i in arguments(x)])
+    print(io, join(ordered_terms,"+")::String) # type assert to help inference
 end
 
 """Symbolic application of operator on operator.
@@ -153,7 +154,10 @@ function Base.:(*)(x::Symbolic{AbstractOperator}, xs::Vararg{Symbolic{AbstractOp
         SZeroOperator()
     end
 end
-Base.show(io::IO, x::SMulOperator) = print(io, join(map(string, arguments(x)),""))
+function Base.show(io::IO, x::SMulOperator)
+    str_func = x -> x isa SAdd || x isa STensor ? "("*string(x)*")" : string(x)
+    print(io, join(map(str_func, arguments(x)),""))
+end
 basis(x::SMulOperator) = basis(first(x.terms))
 
 """Tensor product of quantum objects (kets, operators, or bras).
@@ -167,7 +171,7 @@ julia> k₁ ⊗ k₂
 julia> @op A; @op B;
 
 julia> A ⊗ B
-(A⊗B)
+A⊗B
 ```
 """
 @withmetadata struct STensor{T<:QObj} <: Symbolic{T}
@@ -196,6 +200,12 @@ Base.show(io::IO, x::STensorBra) = print(io, join(map(string, arguments(x)),""))
 const STensorKet = STensor{AbstractKet}
 Base.show(io::IO, x::STensorKet) = print(io, join(map(string, arguments(x)),""))
 const STensorOperator = STensor{AbstractOperator}
-Base.show(io::IO, x::STensorOperator) = print(io, "("*join(map(string, arguments(x)),"⊗")*")")
+function Base.show(io::IO, x::STensorOperator)
+    str_func = x -> x isa SAdd ? "("*string(x)*")" : string(x)
+    print(io, join(map(str_func, arguments(x)),"⊗"))
+end
 const STensorSuperOperator = STensor{AbstractSuperOperator}
-Base.show(io::IO, x::STensorSuperOperator) = print(io, "("*join(map(string, arguments(x)),"⊗")*")")
+function Base.show(io::IO, x::STensorSuperOperator)
+    str_func = x -> x isa SAdd ? "("*string(x)*")" : string(x)
+    print(io, join(map(str_func, arguments(x)),"⊗"))
+end

src/QSymbolicsBase/basic_ops_inhomogeneous.jl

@@ -32,7 +32,10 @@ end
 Base.:(*)(op::SZeroOperator, k::Symbolic{AbstractKet}) = SZeroKet()
 Base.:(*)(op::Symbolic{AbstractOperator}, k::SZeroKet) = SZeroKet()
 Base.:(*)(op::SZeroOperator, k::SZeroKet) = SZeroKet()
-Base.show(io::IO, x::SApplyKet) = begin print(io, x.op); print(io, x.ket) end
+function Base.show(io::IO, x::SApplyKet) 
+    str_func = x -> x isa SAdd || x isa STensorOperator ? "("*string(x)*")" : string(x)
+    print(io, join(map(str_func, arguments(x)),""))
+end
 basis(x::SApplyKet) = basis(x.ket)
 
 """Symbolic application of an operator on a bra (from the right).
@@ -65,7 +68,10 @@ end
 Base.:(*)(b::SZeroBra, op::Symbolic{AbstractOperator}) = SZeroBra()
 Base.:(*)(b::Symbolic{AbstractBra}, op::SZeroOperator) = SZeroBra()
 Base.:(*)(b::SZeroBra, op::SZeroOperator) = SZeroBra()
-Base.show(io::IO, x::SApplyBra) = begin print(io, x.bra); print(io, x.op) end
+function Base.show(io::IO, x::SApplyBra) 
+    str_func = x -> x isa SAdd || x isa STensor ? "("*string(x)*")" : string(x)
+    print(io, join(map(str_func, arguments(x)),""))
+end
 basis(x::SApplyBra) = basis(x.bra)
 
 """Symbolic inner product of a bra and a ket.

src/QSymbolicsBase/basic_superops.jl

@@ -13,7 +13,7 @@ julia> K = kraus(A₁, A₂, A₃)
 julia> @op ρ;
 
 julia> K*ρ
-(A₁ρA₁†+A₂ρA₂†+A₃ρA₃†)
+A₁ρA₁†+A₂ρA₂†+A₃ρA₃†
 ```
 """
 @withmetadata struct KrausRepr <: Symbolic{AbstractSuperOperator}

src/QSymbolicsBase/linalg.jl

@@ -164,7 +164,7 @@ julia> transpose(A)
 Aᵀ
 
 julia> transpose(A+B)
-(Aᵀ+Bᵀ)
+Aᵀ+Bᵀ
 
 julia> transpose(k)
 |k⟩ᵀ
@@ -331,7 +331,7 @@ julia> ptrace(A⊗B, 1)
 julia> @ket k; @bra b;
 
 julia> factorizable = A ⊗ (k*b)
-(A⊗|k⟩⟨b|)
+A⊗|k⟩⟨b|
 
 julia> ptrace(factorizable, 1)
 (tr(A))|k⟩⟨b|
@@ -340,13 +340,13 @@ julia> ptrace(factorizable, 2)
 (⟨b||k⟩)A
 
 julia> mixed_state = (A⊗(k*b)) + ((k*b)⊗B)
-((A⊗|k⟩⟨b|)+(|k⟩⟨b|⊗B))
+(A⊗|k⟩⟨b|)+(|k⟩⟨b|⊗B)
 
 julia> ptrace(mixed_state, 1)
-((0 + ⟨b||k⟩)B+(tr(A))|k⟩⟨b|)
+(0 + ⟨b||k⟩)B+(tr(A))|k⟩⟨b|
 
 julia> ptrace(mixed_state, 2)
-((0 + ⟨b||k⟩)A+(tr(B))|k⟩⟨b|)
+(0 + ⟨b||k⟩)A+(tr(B))|k⟩⟨b|
 ```
 """
 @withmetadata struct SPartialTrace <: Symbolic{AbstractOperator}
@@ -505,7 +505,7 @@ julia> vec(A)
 |A⟩⟩
 
 julia> vec(A+B)
-(|A⟩⟩+|B⟩⟩)
+|A⟩⟩+|B⟩⟩
 ```
 """
 @withmetadata struct SVec <: Symbolic{AbstractKet}

src/QSymbolicsBase/rules.jl

@@ -183,15 +183,15 @@ Manually expand a symbolic expression of quantum objects.
 julia> @op A; @op B; @op C;
 
 julia> qexpand(commutator(A, B))
-(-1BA+AB)
+-1BA+AB
 
 julia> qexpand(A⊗(B+C))
-((A⊗B)+(A⊗C))
+(A⊗B)+(A⊗C)
 
 julia> @ket k₁; @ket k₂;
 
 julia> qexpand(A*(k₁+k₂))
-(A|k₁⟩+A|k₂⟩)
+A|k₁⟩+A|k₂⟩
 ```
 """
 function qexpand(s)