From a526cb5b36f91477d8e5bede75df9cd56df2a83d Mon Sep 17 00:00:00 2001 From: Ashley Milsted Date: Fri, 14 Apr 2023 15:57:10 -0700 Subject: [PATCH 1/2] Embedding with lazy semantics Basic version. --- src/operators_lazytensor.jl | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/src/operators_lazytensor.jl b/src/operators_lazytensor.jl index 1e980f9f..06d742cb 100644 --- a/src/operators_lazytensor.jl +++ b/src/operators_lazytensor.jl @@ -202,6 +202,26 @@ end identityoperator(::Type{<:LazyTensor}, ::Type{T}, b1::Basis, b2::Basis) where {T<:Number} = LazyTensor(b1, b2, Int[], Tuple{}(), one(T)) +""" + embed_lazy(b::QOB.Basis, i, op::QOB.AbstractOperator) + +Embed an operator in a larger hilbert space, at site(s) `i` of basis `b`, using a +lazy representation of the tensor product and preserving LazySum. + +This has different meaning to `LazyTensor()` and `embed()`. The former +always constructs a `LazyTensor` operator and the latter will not embed dense +and sparse operators lazily. This function need not return a `LazyTensor` +(it sometimes returns a `LazySum` of `LazyTensor`) and it will always prefer a +lazy representation. +""" +embed_lazy(b::QOB.Basis, i, op::QOB.AbstractOperator) = QOB.LazyTensor(b, i, op) +function embed_lazy(b::QOB.Basis, i, op::QOB.LazySum) + _embed_ops(b, i, ops::Tuple) = ((embed_lazy(b, i, o) for o in ops)...,) + _embed_ops(b, i, ops) = [embed_lazy(b, i, o) for o in ops] + QOB.LazySum(b, b, op.factors, _embed_ops(b, i, op.operators)) +end +embed_lazy(b::QOB.Basis, indices, op::QOB.LazyTensor) = QOB.LazyTensor(b, b, indices, op.operators, op.factor) + ## LazyTensor global cache function lazytensor_default_cache_size() From 10464d155ae2a297d9f059c9169ea1f24a8022a0 Mon Sep 17 00:00:00 2001 From: Ashley Milsted Date: Fri, 14 Apr 2023 16:00:38 -0700 Subject: [PATCH 2/2] Make it not trivially broken --- src/operators_lazytensor.jl | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/operators_lazytensor.jl b/src/operators_lazytensor.jl index 06d742cb..20edd989 100644 --- a/src/operators_lazytensor.jl +++ b/src/operators_lazytensor.jl @@ -203,7 +203,7 @@ end identityoperator(::Type{<:LazyTensor}, ::Type{T}, b1::Basis, b2::Basis) where {T<:Number} = LazyTensor(b1, b2, Int[], Tuple{}(), one(T)) """ - embed_lazy(b::QOB.Basis, i, op::QOB.AbstractOperator) + embed_lazy(b::Basis, i, op::AbstractOperator) Embed an operator in a larger hilbert space, at site(s) `i` of basis `b`, using a lazy representation of the tensor product and preserving LazySum. @@ -214,13 +214,13 @@ and sparse operators lazily. This function need not return a `LazyTensor` (it sometimes returns a `LazySum` of `LazyTensor`) and it will always prefer a lazy representation. """ -embed_lazy(b::QOB.Basis, i, op::QOB.AbstractOperator) = QOB.LazyTensor(b, i, op) -function embed_lazy(b::QOB.Basis, i, op::QOB.LazySum) +embed_lazy(b::Basis, i, op::AbstractOperator) = LazyTensor(b, i, op) +function embed_lazy(b::Basis, i, op::LazySum) _embed_ops(b, i, ops::Tuple) = ((embed_lazy(b, i, o) for o in ops)...,) _embed_ops(b, i, ops) = [embed_lazy(b, i, o) for o in ops] - QOB.LazySum(b, b, op.factors, _embed_ops(b, i, op.operators)) + LazySum(b, b, op.factors, _embed_ops(b, i, op.operators)) end -embed_lazy(b::QOB.Basis, indices, op::QOB.LazyTensor) = QOB.LazyTensor(b, b, indices, op.operators, op.factor) +embed_lazy(b::Basis, indices, op::LazyTensor) = LazyTensor(b, b, indices, op.operators, op.factor) ## LazyTensor global cache