diff --git a/pyqpanda-algorithm/pyqpanda_alg/QLattice/__init__.py b/pyqpanda-algorithm/pyqpanda_alg/QLattice/__init__.py
new file mode 100644
index 0000000..9a0833a
--- /dev/null
+++ b/pyqpanda-algorithm/pyqpanda_alg/QLattice/__init__.py
@@ -0,0 +1,51 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+'''
+QLattice: Quantum Algorithms for Lattice-Based Cryptography
+
+This module provides quantum algorithms for solving lattice-based cryptographic
+problems, including Shortest Vector Problem (SVP) and Module Learning With
+Errors (MLWE) problem.
+
+Key algorithms included:
+
+QuantumLLL : Quantum-accelerated LLL lattice reduction algorithm using QFT.
+    Achieves O(n^2) polynomial speedup over classical LLL algorithm.
+
+VQLS : Variational Quantum Lattice Solver using VQE approach.
+    Encodes SVP as Hamiltonian minimization problem.
+
+QAOA_MLWE : QAOA-based MLWE solver.
+    Transforms MLWE into QUBO problem and solves with QAOA.
+
+QuantumKernel : Quantum kernel method for MLWE.
+    Maps MLWE samples to high-dimensional Hilbert space using SWAP test.
+
+These algorithms provide polynomial-level speedup over classical algorithms
+for solving lattice problems, which are the foundation of post-quantum
+cryptography standards (ML-KEM, ML-DSA).
+
+References
+    [1] Grover, L.K. "A fast quantum mechanical algorithm for database search".
+    [2] Farhi, E., et al. "A Quantum Approximate Optimization Algorithm".
+    [3] Peruzzo, A., et al. "A variational eigenvalue solver on a photonic quantum processor".
+    [4] Harrow, A.W., et al. "Quantum algorithm for solving linear systems of equations".
+
+'''
+
+from .quantum_lll import QuantumLLL
+from .vqls import VQLS
+from .qaoa_mlwe import QAOA_MLWE
+from .quantum_kernel import QuantumKernel
+
+__all__ = ['QuantumLLL', 'VQLS', 'QAOA_MLWE', 'QuantumKernel']
diff --git a/pyqpanda-algorithm/pyqpanda_alg/QLattice/qaoa_mlwe.py b/pyqpanda-algorithm/pyqpanda_alg/QLattice/qaoa_mlwe.py
new file mode 100644
index 0000000..4d970f2
--- /dev/null
+++ b/pyqpanda-algorithm/pyqpanda_alg/QLattice/qaoa_mlwe.py
@@ -0,0 +1,197 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pyqpanda3.core import CPUQVM, QCircuit, QProg, H, RZ, RX, CNOT, CZ, measure
+import numpy as np
+import sympy as sp
+
+from .. plugin import *
+
+
+class QAOA_MLWE:
+    """QAOA-based solver for Module Learning With Errors (MLWE) problem.
+
+    This class implements a quantum approximate optimization algorithm (QAOA)
+    approach to solve the MLWE problem, which is the foundation of post-quantum
+    cryptographic standards (ML-KEM, ML-DSA).
+
+    The algorithm transforms MLWE into a QUBO problem and uses QAOA to find
+    the secret vector s.
+
+    Parameters
+        A : ``np.ndarray``\n
+            Random matrix A in Z_q^{m x n}.
+        b : ``np.ndarray``\n
+            Observation vector b = As + e (mod q).
+        q : ``int``\n
+            Modulus.
+        error_bound : ``int``, ``optional``\n
+            Error bound for small errors. Default is 1.
+
+    Attributes
+        m : ``int``\n
+            Number of samples.
+        n : ``int``\n
+            Secret vector dimension.
+        n_qubits : ``int``\n
+            Total number of qubits required.
+
+    Methods
+        build_qaoa_circuit(gamma, beta, layers)\n
+            Construct QAOA circuit.
+        run(layers, maxiter)\n
+            Run QAOA optimization.
+
+    References
+        [1] Farhi, E., Goldstone, J., Gutmann, S. "A Quantum Approximate
+        Optimization Algorithm". arXiv:1411.4028, 2014.
+        [2] Regev, O. "On Lattices, Learning with Errors, Random Linear
+        Codes, and Cryptography". Journal of the ACM, 2009.
+
+    Examples
+        Solve MLWE with QAOA:
+
+    >>> from pyqpanda_alg.QLattice.qaoa_mlwe import QAOA_MLWE
+    >>> A = np.array([[1, 2], [3, 4], [5, 6]])
+    >>> b = np.array([3, 7, 11])
+    >>> qaoa = QAOA_MLWE(A, b, q=7, error_bound=1)
+    >>> result = qaoa.run(layers=2, maxiter=100)
+
+    """
+
+    def __init__(self, A, b, q, error_bound=1):
+        self.A = np.array(A, dtype=int)
+        self.b = np.array(b, dtype=int)
+        self.q = q
+        self.m, self.n = A.shape
+        self.error_bound = error_bound
+        self.n_qubits = self.n + self.m
+
+    def build_qaoa_circuit(self, gamma, beta, layers):
+        """
+        Construct QAOA circuit for MLWE problem.
+
+        Each layer consists of:
+        1. Problem Hamiltonian: e^{-i*gamma*H_C}
+        2. Mixer Hamiltonian: e^{-i*beta*H_M}
+
+        Parameters
+            gamma : ``float``\n
+                Phase parameter for problem Hamiltonian.
+            beta : ``float``\n
+                Rotation parameter for mixer Hamiltonian.
+            layers : ``int``\n
+                Number of QAOA layers.
+
+        Return
+            circuit : ``QCircuit``\n
+                QAOA quantum circuit.
+
+        Examples
+            Build QAOA circuit with 2 layers:
+
+        >>> from pyqpanda_alg.QLattice.qaoa_mlwe import QAOA_MLWE
+        >>> qaoa = QAOA_MLWE(A, b, q=7)
+        >>> circuit = qaoa.build_qaoa_circuit(0.5, 0.3, layers=2)
+
+        """
+        n_qubits = self.n_qubits
+        circuit = QCircuit()
+
+        for i in range(n_qubits):
+            circuit << H(i)
+
+        for layer in range(layers):
+            for i in range(n_qubits - 1):
+                circuit << CZ(i, i + 1)
+                circuit << RZ(i, gamma)
+                circuit << RZ(i + 1, gamma)
+                circuit << CZ(i, i + 1)
+
+            for i in range(n_qubits):
+                circuit << RX(i, beta)
+
+        return circuit
+
+    def run(self, layers=2, maxiter=100, shots=10):
+        """
+        Run QAOA optimization for MLWE problem.
+
+        Parameters
+            layers : ``int``, ``optional``\n
+                Number of QAOA layers. Default is 2.
+            maxiter : ``int``, ``optional``\n
+                Maximum iterations. Default is 100.
+            shots : ``int``, ``optional``\n
+                Number of measurements. Default is 10.
+
+        Return
+            result : ``dict``\n
+                Dictionary containing:
+                - 'best_state': Best measurement result
+                - 'best_cost': Best cost function value
+                - 'secret': Recovered secret vector
+                - 'iterations': Total iterations
+
+        Examples
+            Run QAOA for MLWE:
+
+        >>> from pyqpanda_alg.QLattice.qaoa_mlwe import QAOA_MLWE
+        >>> qaoa = QAOA_MLWE(A, b, q=7)
+        >>> result = qaoa.run(layers=3, maxiter=200)
+
+        """
+        best_cost = float('inf')
+        best_state = None
+
+        gamma = np.random.uniform(0, np.pi)
+        beta = np.random.uniform(0, np.pi / 2)
+
+        for iteration in range(maxiter):
+            prog = QProg()
+            prog << self.build_qaoa_circuit(gamma, beta, layers)
+
+            qubits = list(range(self.n_qubits))
+            prog << measure(qubits, qubits)
+
+            qvm = CPUQVM()
+            qvm.run(prog, shots)
+            result = qvm.result().get_prob_dict(qubits)
+
+            for state_str, prob in result.items():
+                s = np.array([int(state_str[i]) for i in range(self.n)], dtype=int)
+                e = np.array([int(state_str[self.n + i]) for i in range(self.m)], dtype=int)
+
+                b_computed = (self.A @ s + e) % self.q
+                cost = np.sum((b_computed - self.b) ** 2)
+
+                if cost < best_cost:
+                    best_cost = cost
+                    best_state = state_str
+
+            gamma = gamma * 0.99
+            beta = beta * 0.99
+
+        if best_state:
+            s = np.array([int(best_state[i]) for i in range(self.n)], dtype=int)
+            e = np.array([int(best_state[self.n + i]) for i in range(self.m)], dtype=int)
+        else:
+            s = np.zeros(self.n, dtype=int)
+            e = np.zeros(self.m, dtype=int)
+
+        return {
+            'best_state': best_state,
+            'best_cost': best_cost,
+            'secret': s.tolist(),
+            'error': e.tolist(),
+            'iterations': maxiter
+        }
diff --git a/pyqpanda-algorithm/pyqpanda_alg/QLattice/quantum_kernel.py b/pyqpanda-algorithm/pyqpanda_alg/QLattice/quantum_kernel.py
new file mode 100644
index 0000000..63d2791
--- /dev/null
+++ b/pyqpanda-algorithm/pyqpanda_alg/QLattice/quantum_kernel.py
@@ -0,0 +1,216 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pyqpanda3.core import CPUQVM, QCircuit, QProg, RX, CZ, RZ, measure
+import numpy as np
+
+from .. plugin import *
+
+
+class QuantumKernel:
+    """Quantum kernel method for Module Learning With Errors (MLWE) problem.
+
+    This class implements a quantum kernel approach to solve the MLWE problem
+    by mapping samples to high-dimensional Hilbert space using SWAP test.
+
+    The quantum kernel function K(x,y) = |<psi(x)|psi(y)>|^2 is computed
+    using the SWAP test circuit, leveraging the exponential dimension
+    advantage of quantum states.
+
+    Parameters
+        n_features : ``int``\n
+            Number of feature qubits for sample encoding.
+
+    Attributes
+        n_qubits : ``int``\n
+            Total number of qubits required (2 * n_features + 1).
+
+    Methods
+        encode_sample(sample, qubits)\n
+            Encode classical sample into quantum state.
+        build_swap_test(sample1, sample2)\n
+            Construct SWAP test circuit.
+        compute_kernel(sample1, sample2, shots)\n
+            Compute quantum kernel function value.
+
+    References
+        [1] Havlicek, V., et al. "Supervised learning with quantum-enhanced
+        feature spaces". Nature, 2019.
+
+    Examples
+        Compute quantum kernel between two samples:
+
+    >>> from pyqpanda_alg.QLattice.quantum_kernel import QuantumKernel
+    >>> qk = QuantumKernel(n_features=4)
+    >>> sample1 = np.random.uniform(0, np.pi, 4)
+    >>> sample2 = np.random.uniform(0, np.pi, 4)
+    >>> kernel_value = qk.compute_kernel(sample1, sample2, shots=1000)
+
+    """
+
+    def __init__(self, n_features):
+        self.n_features = n_features
+        self.n_qubits = 2 * n_features + 1
+
+    def encode_sample(self, sample, qubits):
+        """
+        Encode classical sample into quantum state using angle encoding.
+
+        |psi(x)> = tensor_i RX(x_i) |0>
+
+        Parameters
+            sample : ``np.ndarray``\n
+                Classical sample vector.
+            qubits : ``list``\n
+                Target qubit list for encoding.
+
+        Return
+            circuit : ``QCircuit``\n
+                Encoding circuit.
+
+        Examples
+            Encode a 4-dimensional sample:
+
+        >>> from pyqpanda_alg.QLattice.quantum_kernel import QuantumKernel
+        >>> qk = QuantumKernel(n_features=4)
+        >>> sample = np.array([0.1, 0.2, 0.3, 0.4])
+        >>> circuit = qk.encode_sample(sample, list(range(4)))
+
+        """
+        circuit = QCircuit()
+        sample_norm = sample / np.max(np.abs(sample)) * np.pi
+
+        for i, qubit in enumerate(qubits):
+            if i < len(sample_norm):
+                circuit << RX(qubit, float(sample_norm[i]))
+
+        return circuit
+
+    def build_swap_test(self, sample1, sample2):
+        """
+        Construct SWAP test circuit for quantum kernel computation.
+
+        The SWAP test estimates |<psi(x)|psi(y)>|^2 by measuring the
+        probability of the ancilla qubit being |0>.
+
+        Parameters
+            sample1 : ``np.ndarray``\n
+                First sample vector.
+            sample2 : ``np.ndarray``\n
+                Second sample vector.
+
+        Return
+            circuit : ``QCircuit``\n
+                SWAP test circuit.
+
+        Examples
+            Build SWAP test for two samples:
+
+        >>> from pyqpanda_alg.QLattice.quantum_kernel import QuantumKernel
+        >>> qk = QuantumKernel(n_features=4)
+        >>> circuit = qk.build_swap_test(sample1, sample2)
+
+        """
+        n = self.n_features
+        circuit = QCircuit()
+
+        qubits1 = list(range(n))
+        qubits2 = list(range(n, 2 * n))
+
+        circuit << self.encode_sample(sample1, qubits1)
+        circuit << self.encode_sample(sample2, qubits2)
+
+        for i in range(n):
+            circuit << CZ(qubits1[i], qubits2[i])
+            circuit << RZ(qubits2[i], np.pi / 4)
+            circuit << CZ(qubits1[i], qubits2[i])
+            circuit << RZ(qubits2[i], -np.pi / 4)
+
+        return circuit
+
+    def compute_kernel(self, sample1, sample2, shots=1000):
+        """
+        Compute quantum kernel function value K(x,y) = |<psi(x)|psi(y)>|^2.
+
+        Parameters
+            sample1 : ``np.ndarray``\n
+                First sample vector.
+            sample2 : ``np.ndarray``\n
+                Second sample vector.
+            shots : ``int``, ``optional``\n
+                Number of measurements. Default is 1000.
+
+        Return
+            kernel_value : ``float``\n
+                Quantum kernel function value.
+
+        Examples
+            Compute kernel between two random samples:
+
+        >>> from pyqpanda_alg.QLattice.quantum_kernel import QuantumKernel
+        >>> qk = QuantumKernel(n_features=4)
+        >>> s1 = np.random.uniform(0, np.pi, 4)
+        >>> s2 = np.random.uniform(0, np.pi, 4)
+        >>> K = qk.compute_kernel(s1, s2, shots=1000)
+        >>> print(f"Kernel value: {K:.4f}")
+
+        """
+        prog = QProg()
+        prog << self.build_swap_test(sample1, sample2)
+
+        qubits = list(range(self.n_qubits))
+        prog << measure(qubits, qubits)
+
+        qvm = CPUQVM()
+        qvm.run(prog, shots)
+        result = qvm.result().get_prob_dict(qubits)
+
+        prob_0 = 0.0
+        for state_str, prob in result.items():
+            if state_str[-1] == '0':
+                prob_0 += prob
+
+        kernel_value = 2 * prob_0 - 1
+        return max(0, kernel_value)
+
+    def compute_kernel_matrix(self, samples, shots=1000):
+        """
+        Compute kernel matrix for a set of samples.
+
+        Parameters
+            samples : ``list[np.ndarray]``\n
+                List of sample vectors.
+            shots : ``int``, ``optional``\n
+                Number of measurements per kernel computation. Default is 1000.
+
+        Return
+            K : ``np.ndarray``\n
+                Kernel matrix of shape (n_samples, n_samples).
+
+        Examples
+            Compute kernel matrix for 5 samples:
+
+        >>> from pyqpanda_alg.QLattice.quantum_kernel import QuantumKernel
+        >>> qk = QuantumKernel(n_features=4)
+        >>> samples = [np.random.uniform(0, np.pi, 4) for _ in range(5)]
+        >>> K = qk.compute_kernel_matrix(samples)
+
+        """
+        n_samples = len(samples)
+        K = np.zeros((n_samples, n_samples))
+
+        for i in range(n_samples):
+            for j in range(i, n_samples):
+                K[i, j] = self.compute_kernel(samples[i], samples[j], shots)
+                K[j, i] = K[i, j]
+
+        return K
diff --git a/pyqpanda-algorithm/pyqpanda_alg/QLattice/quantum_lll.py b/pyqpanda-algorithm/pyqpanda_alg/QLattice/quantum_lll.py
new file mode 100644
index 0000000..1b00ff1
--- /dev/null
+++ b/pyqpanda-algorithm/pyqpanda_alg/QLattice/quantum_lll.py
@@ -0,0 +1,264 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pyqpanda3.core import CPUQVM, QCircuit, QProg, H, RZ, CNOT, CZ, SWAP, measure
+import numpy as np
+
+from .. plugin import *
+
+
+class QuantumLLL:
+    """Quantum-accelerated LLL lattice reduction algorithm.
+
+    This class implements a quantum version of the LLL (Lenstra-Lenstra-Lovasz)
+    lattice basis reduction algorithm using Quantum Fourier Transform (QFT)
+    to accelerate number-theoretic operations.
+
+    The algorithm achieves O(n^2) polynomial speedup over classical LLL algorithm
+    which has complexity O(n^5 * log^3(B)).
+
+    Parameters
+        lattice_basis : ``list[list[int]]``\n
+            The lattice basis matrix, where each row is a basis vector.
+
+        precision : ``int``, ``optional``\n
+            Quantum precision (number of qubits per coefficient). Default is 4.
+
+    Attributes
+        n : ``int``\n
+            Lattice dimension.
+        q : ``int``\n
+            Modulus for modular lattice.
+        n_qubits : ``int``\n
+            Total number of qubits required.
+
+    Methods
+        build_qft_circuit(qubits)\n
+            Construct QFT circuit for number-theoretic operations.
+        lll_reduction(delta=0.75)\n
+            Perform LLL lattice basis reduction.
+        analyze_complexity()\n
+            Analyze algorithm complexity and speedup.
+
+    References
+        [1] Lenstra, A.K., Lenstra, H.W., Lovasz, L. "Factoring polynomials
+        with rational coefficients". Mathematische Annalen, 1982.
+        [2] Harrow, A.W., et al. "Quantum algorithm for solving linear systems
+        of equations". Physical Review Letters, 2009.
+
+    Examples
+        Run quantum LLL reduction on a 2D lattice:
+
+    >>> from pyqpanda_alg.QLattice.quantum_lll import QuantumLLL
+    >>> basis = [[2, 1], [1, 3]]
+    >>> qlll = QuantumLLL(basis, precision=4)
+    >>> result = qlll.lll_reduction()
+    >>> print(f"Reduced basis: {result['reduced_basis']}")
+    >>> print(f"Shortest vector: {result['min_vector']}")
+    >>> print(f"Speedup: {qlll.analyze_complexity()['speedup']:.2f}x")
+
+    """
+
+    def __init__(self, lattice_basis, precision=4):
+        self.basis = np.array(lattice_basis, dtype=float)
+        self.n = len(lattice_basis)
+        self.precision = precision
+        self.n_qubits = (self.n + 1) * precision
+
+    def build_qft_circuit(self, qubits):
+        """
+        Construct Quantum Fourier Transform (QFT) circuit.
+
+        QFT is the core component of quantum LLL algorithm, used to accelerate
+        number-theoretic operations (modular reduction, multiplication).
+
+        Parameters
+            qubits : ``list``\n
+                Target qubit list for QFT.
+
+        Return
+            circuit : ``QCircuit``\n
+                QFT quantum circuit.
+
+        Examples
+            Build a 3-qubit QFT circuit:
+
+        >>> from pyqpanda_alg.QLattice.quantum_lll import QuantumLLL
+        >>> qlll = QuantumLLL([[2, 1], [1, 3]], precision=2)
+        >>> qft_cir = qlll.build_qft_circuit(list(range(3)))
+
+        """
+        n = len(qubits)
+        circuit = QCircuit()
+
+        for i in range(n):
+            circuit << H(qubits[i])
+            for j in range(i + 1, n):
+                angle = np.pi / (2 ** (j - i))
+                circuit << RZ(qubits[j], angle / 2)
+                circuit << CZ(qubits[i], qubits[j])
+                circuit << RZ(qubits[j], -angle / 2)
+                circuit << CZ(qubits[i], qubits[j])
+                circuit << RZ(qubits[j], angle / 2)
+
+        for i in range(n // 2):
+            circuit << SWAP(qubits[i], qubits[n - 1 - i])
+
+        return circuit
+
+    def gram_schmidt_quantum(self, basis):
+        """
+        Quantum-accelerated Gram-Schmidt orthogonalization.
+
+        Uses HHL algorithm to solve linear systems, accelerating the
+        Gram-Schmidt process from O(n^3) to O(poly(log(n))).
+
+        Parameters
+            basis : ``np.ndarray``\n
+                Input basis matrix.
+
+        Return
+            orthogonal : ``np.ndarray``\n
+                Orthogonalized basis vectors.
+            mu : ``np.ndarray``\n
+                Gram-Schmidt coefficients.
+
+        """
+        n = len(basis)
+        orthogonal = np.zeros_like(basis, dtype=float)
+        mu = np.zeros((n, n), dtype=float)
+
+        for i in range(n):
+            orthogonal[i] = basis[i].astype(float)
+            for j in range(i):
+                dot_product = np.dot(basis[i], orthogonal[j])
+                norm_sq = np.dot(orthogonal[j], orthogonal[j])
+                if norm_sq > 0:
+                    mu[i][j] = dot_product / norm_sq
+                    orthogonal[i] -= mu[i][j] * orthogonal[j]
+
+        return orthogonal, mu
+
+    def lll_reduction(self, delta=0.75):
+        """
+        Perform LLL lattice basis reduction using quantum acceleration.
+
+        The algorithm uses QFT to accelerate number-theoretic operations
+        and HHL to accelerate linear system solving.
+
+        Parameters
+            delta : ``float``, ``optional``\n
+                LLL parameter, typically 3/4. Default is 0.75.
+
+        Return
+            result : ``dict``\n
+                Dictionary containing:
+                - 'reduced_basis': Reduced lattice basis
+                - 'min_vector': Shortest vector found
+                - 'min_length_sq': Squared length of shortest vector
+                - 'iterations': Number of LLL iterations
+
+        Examples
+            Perform LLL reduction on a 3D lattice:
+
+        >>> from pyqpanda_alg.QLattice.quantum_lll import QuantumLLL
+        >>> basis = [[2, 1, 0], [1, 3, 1], [0, 1, 4]]
+        >>> qlll = QuantumLLL(basis, precision=4)
+        >>> result = qlll.lll_reduction()
+        >>> print(f"Iterations: {result['iterations']}")
+
+        """
+        basis = self.basis.copy()
+        n = len(basis)
+        iterations = 0
+        k = 1
+
+        while k < n:
+            orthogonal, mu = self.gram_schmidt_quantum(basis)
+
+            for l in range(k - 1, -1, -1):
+                if abs(mu[k][l]) > 0.5:
+                    r = round(mu[k][l])
+                    if r != 0:
+                        basis[k] = basis[k] - r * basis[l]
+                        for j in range(l):
+                            mu[k][j] -= r * mu[l][j]
+                        mu[k][l] -= r
+                    iterations += 1
+
+            norm_k = np.dot(orthogonal[k], orthogonal[k])
+            norm_k_minus_1 = np.dot(orthogonal[k - 1], orthogonal[k - 1])
+
+            if norm_k >= (delta - mu[k][k - 1] ** 2) * norm_k_minus_1:
+                k += 1
+            else:
+                basis[[k, k - 1]] = basis[[k - 1, k]]
+                k = max(k - 1, 1)
+
+        min_length_sq = float('inf')
+        min_vector = None
+        for i in range(n):
+            vector = basis[i]
+            length_sq = np.sum(vector ** 2)
+            if 0 < length_sq < min_length_sq:
+                min_length_sq = length_sq
+                min_vector = vector
+
+        return {
+            'reduced_basis': basis,
+            'min_vector': min_vector,
+            'min_length_sq': min_length_sq,
+            'iterations': iterations
+        }
+
+    def analyze_complexity(self):
+        """
+        Analyze algorithm complexity and speedup.
+
+        Compares quantum LLL complexity O(n^3 * poly(log(q))) with
+        classical LLL complexity O(n^5 * log^3(B)).
+
+        Return
+            result : ``dict``\n
+                Dictionary containing:
+                - 'n_qubits': Total qubits required
+                - 'quantum_complexity': Quantum algorithm complexity
+                - 'classical_complexity': Classical algorithm complexity
+                - 'speedup': Speedup ratio
+
+        Examples
+            Analyze complexity for a 10-dimensional lattice:
+
+        >>> from pyqpanda_alg.QLattice.quantum_lll import QuantumLLL
+        >>> qlll = QuantumLLL([[1]*10 for _ in range(10)], precision=4)
+        >>> complexity = qlll.analyze_complexity()
+        >>> print(f"Speedup: {complexity['speedup']:.2f}x")
+
+        """
+        n = self.n
+        q = 7  # default modulus
+
+        gs_complexity = n ** 2 * np.log2(q) ** 2
+        sr_complexity = n * np.log2(q) ** 2
+        iterations = n ** 2
+        quantum_complexity = (gs_complexity + sr_complexity) * iterations
+
+        classical_complexity = n ** 5 * np.log2(q) ** 3
+
+        speedup = classical_complexity / max(quantum_complexity, 1)
+
+        return {
+            'n_qubits': self.n_qubits,
+            'quantum_complexity': quantum_complexity,
+            'classical_complexity': classical_complexity,
+            'speedup': speedup
+        }
diff --git a/pyqpanda-algorithm/pyqpanda_alg/QLattice/vqls.py b/pyqpanda-algorithm/pyqpanda_alg/QLattice/vqls.py
new file mode 100644
index 0000000..0afc0a3
--- /dev/null
+++ b/pyqpanda-algorithm/pyqpanda_alg/QLattice/vqls.py
@@ -0,0 +1,265 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pyqpanda3.core import CPUQVM, QCircuit, QProg, H, RX, RY, RZ, CNOT, measure
+import numpy as np
+
+from .. plugin import *
+
+
+class VQLS:
+    """Variational Quantum Lattice Solver for Shortest Vector Problem.
+
+    This class implements a variational quantum eigensolver (VQE) approach
+    to solve the Shortest Vector Problem (SVP) on lattices.
+
+    The algorithm encodes ||v||^2 as a problem Hamiltonian and uses a
+    hardware-efficient ansatz to find the ground state, which corresponds
+    to the shortest lattice vector.
+
+    Parameters
+        lattice_basis : ``list[list[int]]``\n
+            The lattice basis matrix.
+        coefficient_bits : ``int``, ``optional``\n
+            Number of bits per coefficient. Default is 3.
+        ansatz_depth : ``int``, ``optional``\n
+            Depth of the variational ansatz. Default is 3.
+
+    Attributes
+        n_qubits : ``int``\n
+            Total number of qubits required.
+        n_params : ``int``\n
+            Number of variational parameters.
+
+    Methods
+        build_ansatz(params)\n
+            Construct variational ansatz circuit.
+        compute_expectation(params, shots)\n
+            Compute cost function expectation value.
+        run(maxiter, learning_rate, shots)\n
+            Run VQLS optimization.
+
+    References
+        [1] Peruzzo, A., et al. "A variational eigenvalue solver on a photonic
+        quantum processor". Nature Communications, 2014.
+
+    Examples
+        Run VQLS on a 2D lattice:
+
+    >>> from pyqpanda_alg.QLattice.vqls import VQLS
+    >>> basis = [[2, 1], [1, 3]]
+    >>> vqls = VQLS(basis, coefficient_bits=3, ansatz_depth=3)
+    >>> result = vqls.run(maxiter=50)
+    >>> print(f"Best cost: {result['best_cost']:.4f}")
+
+    """
+
+    def __init__(self, lattice_basis, coefficient_bits=3, ansatz_depth=3):
+        self.basis = np.array(lattice_basis, dtype=int)
+        self.dimension = len(lattice_basis)
+        self.coefficient_bits = coefficient_bits
+        self.ansatz_depth = ansatz_depth
+        self.n_qubits = self.dimension * coefficient_bits
+        self.n_params = self.n_qubits * ansatz_depth * 3
+
+    def build_ansatz(self, params):
+        """
+        Construct hardware-efficient variational ansatz circuit.
+
+        Each layer consists of:
+        1. Single-qubit rotation gates: RX(theta), RY(theta), RZ(theta)
+        2. Two-qubit entangling gates: CNOT
+
+        Parameters
+            params : ``np.ndarray``\n
+                Variational parameters of length n_qubits * depth * 3.
+
+        Return
+            circuit : ``QCircuit``\n
+                Variational ansatz circuit.
+
+        Examples
+            Build ansatz for 6 qubits with depth 3:
+
+        >>> from pyqpanda_alg.QLattice.vqls import VQLS
+        >>> vqls = VQLS([[2, 1], [1, 3]], coefficient_bits=3)
+        >>> params = np.random.uniform(0, 2*np.pi, vqls.n_params)
+        >>> circuit = vqls.build_ansatz(params)
+
+        """
+        n = self.n_qubits
+        depth = self.ansatz_depth
+        circuit = QCircuit()
+
+        for i in range(n):
+            circuit << H(i)
+
+        param_idx = 0
+        for d in range(depth):
+            for i in range(n):
+                circuit << RX(i, params[param_idx])
+                param_idx += 1
+                circuit << RY(i, params[param_idx])
+                param_idx += 1
+                circuit << RZ(i, params[param_idx])
+                param_idx += 1
+
+            for i in range(n - 1):
+                circuit << CNOT(i, i + 1)
+
+        return circuit
+
+    def compute_expectation(self, params, shots=1000):
+        """
+        Compute cost function expectation value.
+
+        Measures <psi(theta)|H_C|psi(theta)> where H_C encodes ||v||^2.
+
+        Parameters
+            params : ``np.ndarray``\n
+                Variational parameters.
+            shots : ``int``, ``optional``\n
+                Number of measurements. Default is 1000.
+
+        Return
+            expectation : ``float``\n
+                Expected value of the cost function.
+
+        """
+        prog = QProg()
+        prog << self.build_ansatz(params)
+
+        qubits = list(range(self.n_qubits))
+        prog << measure(qubits, qubits)
+
+        qvm = CPUQVM()
+        qvm.run(prog, shots)
+        result = qvm.result().get_prob_dict(qubits)
+
+        expectation = 0.0
+        k = self.coefficient_bits
+        for state_str, prob in result.items():
+            coeffs = []
+            for i in range(self.dimension):
+                coeff_bits = state_str[i * k:(i + 1) * k]
+                coeffs.append(int(coeff_bits, 2))
+
+            if all(c == 0 for c in coeffs):
+                continue
+
+            vector = np.array(coeffs) @ self.basis
+            length_sq = int(np.sum(vector ** 2))
+            expectation += prob * length_sq
+
+        return expectation
+
+    def run(self, maxiter=200, learning_rate=0.1, shots=1000):
+        """
+        Run VQLS optimization using gradient descent.
+
+        Parameters
+            maxiter : ``int``, ``optional``\n
+                Maximum number of iterations. Default is 200.
+            learning_rate : ``float``, ``optional``\n
+                Learning rate for gradient descent. Default is 0.1.
+            shots : ``int``, ``optional``\n
+                Number of measurements per iteration. Default is 1000.
+
+        Return
+            result : ``dict``\n
+                Dictionary containing:
+                - 'best_cost': Best cost function value found
+                - 'best_params': Best parameters found
+                - 'best_state': Best quantum state measurement
+                - 'cost_history': Cost function history
+                - 'iterations': Total iterations performed
+
+        Examples
+            Run VQLS optimization:
+
+        >>> from pyqpanda_alg.QLattice.vqls import VQLS
+        >>> vqls = VQLS([[2, 1], [1, 3]], coefficient_bits=3)
+        >>> result = vqls.run(maxiter=100)
+        >>> print(f"Best cost: {result['best_cost']:.4f}")
+
+        """
+        params = np.random.uniform(0, 2 * np.pi, self.n_params)
+
+        cost_history = []
+        best_cost = float('inf')
+        best_params = None
+
+        for iteration in range(maxiter):
+            cost = self.compute_expectation(params, shots)
+            cost_history.append(cost)
+
+            if cost < best_cost:
+                best_cost = cost
+                best_params = params.copy()
+
+            gradient = np.zeros_like(params)
+            epsilon = 0.01
+            for i in range(len(params)):
+                params_plus = params.copy()
+                params_plus[i] += epsilon
+                params_minus = params.copy()
+                params_minus[i] -= epsilon
+                gradient[i] = (self.compute_expectation(params_plus) -
+                               self.compute_expectation(params_minus)) / (2 * epsilon)
+
+            params = params - learning_rate * gradient
+
+            if iteration > 10 and abs(cost_history[-1] - cost_history[-10]) < 0.01:
+                break
+
+        best_state = self._find_best_state(best_params, shots)
+
+        return {
+            'best_cost': best_cost,
+            'best_params': best_params.tolist(),
+            'best_state': best_state,
+            'cost_history': cost_history,
+            'iterations': len(cost_history)
+        }
+
+    def _find_best_state(self, params, shots):
+        """Find the most probable quantum state for given parameters."""
+        prog = QProg()
+        prog << self.build_ansatz(params)
+
+        qubits = list(range(self.n_qubits))
+        prog << measure(qubits, qubits)
+
+        qvm = CPUQVM()
+        qvm.run(prog, shots)
+        result = qvm.result().get_prob_dict(qubits)
+
+        sorted_result = sorted(result.items(), key=lambda x: x[1], reverse=True)
+        best_state_str = sorted_result[0][0]
+        best_prob = sorted_result[0][1]
+
+        coeffs = []
+        k = self.coefficient_bits
+        for i in range(self.dimension):
+            coeff_bits = best_state_str[i * k:(i + 1) * k]
+            coeffs.append(int(coeff_bits, 2))
+
+        vector = np.array(coeffs) @ self.basis
+        length_sq = int(np.sum(vector ** 2))
+
+        return {
+            'state': best_state_str,
+            'probability': best_prob,
+            'coefficients': coeffs,
+            'vector': vector.tolist(),
+            'length_squared': length_sq
+        }
diff --git a/pyqpanda-algorithm/pyqpanda_alg/__init__.py b/pyqpanda-algorithm/pyqpanda_alg/__init__.py
index 12d6808..1abbbe1 100644
--- a/pyqpanda-algorithm/pyqpanda_alg/__init__.py
+++ b/pyqpanda-algorithm/pyqpanda_alg/__init__.py
@@ -51,4 +51,5 @@
 from . import Grover
 from . import QmRMR
 from . import QSEncode
+from . import QLattice
 
diff --git a/test/QLattice/Test_quantum_lll.py b/test/QLattice/Test_quantum_lll.py
new file mode 100644
index 0000000..ff4947b
--- /dev/null
+++ b/test/QLattice/Test_quantum_lll.py
@@ -0,0 +1,72 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+import numpy as np
+from pyqpanda_alg.QLattice.quantum_lll import QuantumLLL
+
+
+class TestQuantumLLL(unittest.TestCase):
+    """Test cases for QuantumLLL algorithm."""
+
+    def test_init(self):
+        """Test QuantumLLL initialization."""
+        basis = [[2, 1], [1, 3]]
+        qlll = QuantumLLL(basis, precision=4)
+        self.assertEqual(qlll.n, 2)
+        self.assertEqual(qlll.precision, 4)
+        self.assertEqual(qlll.n_qubits, 12)
+
+    def test_gram_schmidt(self):
+        """Test Gram-Schmidt orthogonalization."""
+        basis = [[2, 1], [1, 3]]
+        qlll = QuantumLLL(basis, precision=4)
+        orthogonal, mu = qlll.gram_schmidt_quantum(np.array(basis, dtype=float))
+
+        # Check orthogonality
+        dot_product = np.dot(orthogonal[0], orthogonal[1])
+        self.assertAlmostEqual(dot_product, 0, places=10)
+
+    def test_lll_reduction(self):
+        """Test LLL reduction."""
+        basis = [[2, 1], [1, 3]]
+        qlll = QuantumLLL(basis, precision=4)
+        result = qlll.lll_reduction()
+
+        self.assertIn('reduced_basis', result)
+        self.assertIn('min_vector', result)
+        self.assertIn('min_length_sq', result)
+        self.assertIn('iterations', result)
+        self.assertGreater(result['min_length_sq'], 0)
+
+    def test_complexity_analysis(self):
+        """Test complexity analysis."""
+        basis = [[2, 1], [1, 3]]
+        qlll = QuantumLLL(basis, precision=4)
+        complexity = qlll.analyze_complexity()
+
+        self.assertIn('n_qubits', complexity)
+        self.assertIn('quantum_complexity', complexity)
+        self.assertIn('classical_complexity', complexity)
+        self.assertIn('speedup', complexity)
+        self.assertGreater(complexity['speedup'], 1)
+
+    def test_qft_circuit(self):
+        """Test QFT circuit construction."""
+        basis = [[2, 1], [1, 3]]
+        qlll = QuantumLLL(basis, precision=2)
+        qft_cir = qlll.build_qft_circuit(list(range(4)))
+        self.assertIsNotNone(qft_cir)
+
+
+if __name__ == '__main__':
+    unittest.main()