ltntorch 0.1.0

data/lib/ltn/diag.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Mauro Tortonesi.
+# Ported from LTNtorch, copyright 2021-2024 by Tommaso Carraro.
+
+module LTN
+  # Sets diagonal quantification on the given variables: they are no longer
+  # broadcast against each other but paired element-wise, the i-th individual
+  # of each with the i-th of the others. A quantifier over the variables
+  # resets them (see LTN.undiag).
+  #
+  #   forall.call(LTN.diag(x, y), formula) # for all i, formula(x_i, y_i)
+  #
+  # This modifies the variables, replacing their free variables with a shared
+  # `diag_...` label.
+  #
+  # @parameter vars [Array(Variable)] at least two variables with the same number of individuals.
+  # @returns [Array(Variable)] the same variables.
+  # @raises [TypeError] if an argument is not a Variable.
+  # @raises [ArgumentError] if there is only one variable, or their numbers of individuals differ.
+  def self.diag(*vars)
+    unless vars.all?(Variable)
+      raise TypeError, "Expected parameter 'vars' to be Variables, but got #{vars.map(&:class).inspect}"
+    end
+    if vars.size < 2
+      raise ArgumentError, "Expected parameter 'vars' to be more than one Variable, but got just one Variable."
+    end
+    n_individuals = vars.map { |var| var.shape[0] }
+    if n_individuals.uniq.size != 1
+      raise ArgumentError, "Expected the given LTN variables to have the same number of individuals, " \
+        "but got the following numbers of individuals #{n_individuals.inspect}"
+    end
+
+    diag_label = "diag_" + vars.map(&:latent_var).join("_")
+    vars.each { |var| var.free_vars = [diag_label] }
+    vars
+  end
+
+  # Resets the given variables from diagonal quantification (see LTN.diag)
+  # to their own labels.
+  #
+  # @parameter vars [Array(Variable)] the variables.
+  # @returns [Array(Variable)] the same variables.
+  # @raises [TypeError] if an argument is not a Variable.
+  def self.undiag(*vars)
+    unless vars.all?(Variable)
+      raise TypeError, "Expected parameter 'vars' to be Variables, but got #{vars.map(&:class).inspect}"
+    end
+
+    vars.each { |var| var.free_vars = [var.latent_var] }
+    vars
+  end
+end

data/lib/ltn/function.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Mauro Tortonesi.
+# Ported from LTNtorch, copyright 2021-2024 by Tommaso Carraro.
+
+module LTN
+  # An LTN function: maps individuals to individuals (tensors of any shape).
+  class Function < Torch::NN::Module
+    include ModelWrapper
+
+    # Computes the function, after broadcasting the inputs (see
+    # LTN.process_ltn_objects): the result has one leading axis per free
+    # variable of the inputs, followed by the dimensions of each output.
+    #
+    # @parameter inputs [Array(LTNObject)] the arguments.
+    # @parameter kwargs [Hash] passed to the model.
+    # @returns [LTNObject]
+    # @raises [TypeError] if an input is not an LTNObject.
+    def forward(*inputs, **kwargs)
+      check_inputs(inputs)
+      processed, output_vars, output_shape = LTN.process_ltn_objects(inputs)
+      output = model.call(*processed.map(&:value), **kwargs)
+
+      LTNObject.new(output.reshape(output_shape + output.shape.drop(1)).float, output_vars)
+    end
+  end
+end

data/lib/ltn/fuzzy_ops.rb

@@ -0,0 +1,428 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Mauro Tortonesi.
+# Ported from LTNtorch, copyright 2021-2024 by Tommaso Carraro.
+
+module LTN
+  # Fuzzy logic operators and aggregators, the building blocks of
+  # LTN::Connective and LTN::Quantifier. See the appendix of the LTN paper
+  # (https://arxiv.org/abs/2012.13635) for their definitions.
+  #
+  # All operators work on tensors of truth values and support torch's usual
+  # broadcasting. Each one responds to #call, so it can be invoked as
+  # `op.(x, y)`.
+  #
+  # Differences from LTNtorch's `ltn.fuzzy_ops`:
+  # - optional arguments are keywords: `AndProd.new(stable: false)`,
+  #   `op.(x, y, stable: false)`, `agg.(xs, dim: [0], mask: m, p: 3)`;
+  # - Python's ValueError becomes ArgumentError;
+  # - SatAgg reports the shapes of non-scalar formulas instead of raising an
+  #   unrelated error while building that message.
+  #
+  # Arithmetic between floats and tensors is written tensor-first
+  # (`x * c`, `Torch.rsub(x, 1.0)` for `1.0 - x`), and `where` goes through
+  # FuzzyOps.where: in torch.rb 0.27.0, `Float op Tensor` converts the float
+  # to a float32 tensor, and 0-dim tensors that do not require grad can
+  # dispatch to Scalar overloads that return float32 (see TODO_torch-rb.md).
+  # Either way, float64 truth values would lose their dtype or precision.
+  module FuzzyOps
+    # The epsilon of the projections #pi_0 and #pi_1, which keep the stable
+    # operators away from the regions where their gradients vanish or explode.
+    EPS = 1e-4
+
+    module_function
+
+    # Maps truth values from [0, 1] to (0, 1], so that 0 is never an input.
+    #
+    # @parameter x [Torch::Tensor] truth values.
+    # @returns [Torch::Tensor]
+    def pi_0(x)
+      x * (1 - EPS) + EPS
+    end
+
+    # Maps truth values from [0, 1] to [0, 1), so that 1 is never an input.
+    #
+    # @parameter x [Torch::Tensor] truth values.
+    # @returns [Torch::Tensor]
+    def pi_1(x)
+      x * (1 - EPS)
+    end
+
+    # @parameter values [Array(Torch::Tensor)] truth values.
+    # @raises [ArgumentError] if any value is outside [0, 1] (or NaN).
+    def check_values(*values)
+      values.each do |v|
+        next if Torch.all(Torch.logical_and(v.ge(0.0), v.le(1.0))).item
+
+        raise ArgumentError, "Expected inputs of connectives and quantifiers to be tensors of truth values " \
+          "in the range [0., 1.], but got some values outside this range."
+      end
+    end
+
+    # Checks the mask of a guarded quantification.
+    #
+    # @parameter mask [Torch::Tensor] the mask: true includes a value, false excludes it.
+    # @parameter xs [Torch::Tensor] the grounding of the formula being aggregated.
+    # @raises [ArgumentError] if the shapes differ or the mask is not boolean.
+    def check_mask(mask, xs)
+      raise ArgumentError, "'xs' and 'mask' must have the same shape." if mask.shape != xs.shape
+      raise ArgumentError, "'mask' must be a boolean tensor." unless mask.dtype == :bool
+    end
+
+    # Torch.where, safe for 0-dim tensors.
+    #
+    # In torch.rb 0.27.0, a 0-dim tensor that does not require grad also
+    # matches the Scalar parameters of Torch.where's overloads, and the Scalar
+    # overloads win, returning the default dtype (float32) whatever the dtype
+    # of the tensors. Lifting 0-dim tensors to shape [1] for the call avoids
+    # that; the result is the same as PyTorch's.
+    #
+    # @parameter condition [Torch::Tensor] where to take `input`.
+    # @parameter input [Torch::Tensor, Numeric] the values where `condition` holds.
+    # @parameter other [Torch::Tensor, Numeric] the values elsewhere.
+    # @returns [Torch::Tensor]
+    def where(condition, input, other)
+      arguments = [condition, input, other]
+      tensors = arguments.grep(Torch::Tensor)
+      return Torch.where(condition, input, other) unless tensors.any? { |t| t.dim == 0 }
+
+      lifted = arguments.map { |a| (a.is_a?(Torch::Tensor) && a.dim == 0) ? a.reshape([1]) : a }
+      result = Torch.where(*lifted)
+      (tensors.all? { |t| t.dim == 0 }) ? result.reshape([]) : result
+    end
+
+    # @parameter dim [Integer, Array(Integer), nil] the dimension(s) to reduce;
+    #   nil reduces all of them.
+    # @returns [Array(Integer)] the dimensions in the form torch.rb expects,
+    #   where the empty array reduces all of them.
+    def reduction_dims(dim)
+      dim.nil? ? [] : Array(dim)
+    end
+
+    # Shared by the operators with a stable variant: the `stable` flag can be
+    # set in the constructor and overridden on each call.
+    module Stable
+      # @attribute [Boolean] whether to use the stable variant by default.
+      attr_accessor :stable
+
+      # @parameter stable [Boolean] whether to use the stable variant by default.
+      def initialize(stable: true)
+        @stable = stable
+      end
+
+      def inspect
+        "#{self.class.name.split("::").last}(stable: #{stable})"
+      end
+
+      private
+
+      def stable?(override)
+        override.nil? ? stable : override
+      end
+    end
+
+    # Abstract base class of the connective operators.
+    class ConnectiveOperator
+      # @raises [NotImplementedError] always: subclasses implement #call.
+      def call(*args, **kwargs)
+        raise NotImplementedError, "#{self.class} must implement #call"
+      end
+
+      def inspect
+        "#{self.class.name.split("::").last}()"
+      end
+
+      def to_s
+        inspect
+      end
+    end
+
+    # Abstract base class of the unary connective operators.
+    class UnaryConnectiveOperator < ConnectiveOperator
+    end
+
+    # Abstract base class of the binary connective operators.
+    class BinaryConnectiveOperator < ConnectiveOperator
+    end
+
+    # Standard negation: 1 - x.
+    class NotStandard < UnaryConnectiveOperator
+      def call(x)
+        Torch.rsub(x, 1.0)
+      end
+    end
+
+    # Gödel negation: 1 if x == 0, 0 otherwise.
+    class NotGodel < UnaryConnectiveOperator
+      def call(x)
+        Torch.eq(x, 0.0).float
+      end
+    end
+
+    # Gödel conjunction: min(x, y).
+    class AndMin < BinaryConnectiveOperator
+      def call(x, y)
+        Torch.minimum(x, y)
+      end
+    end
+
+    # Goguen (product) conjunction: x * y.
+    class AndProd < BinaryConnectiveOperator
+      include Stable
+
+      def call(x, y, stable: nil)
+        x, y = FuzzyOps.pi_0(x), FuzzyOps.pi_0(y) if stable?(stable)
+        Torch.mul(x, y)
+      end
+    end
+
+    # Łukasiewicz conjunction: max(x + y - 1, 0).
+    class AndLuk < BinaryConnectiveOperator
+      def call(x, y)
+        Torch.maximum(x + y - 1.0, Torch.zeros_like(x))
+      end
+    end
+
+    # Gödel disjunction: max(x, y).
+    class OrMax < BinaryConnectiveOperator
+      def call(x, y)
+        Torch.maximum(x, y)
+      end
+    end
+
+    # Goguen disjunction (probabilistic sum): x + y - x * y.
+    class OrProbSum < BinaryConnectiveOperator
+      include Stable
+
+      def call(x, y, stable: nil)
+        x, y = FuzzyOps.pi_1(x), FuzzyOps.pi_1(y) if stable?(stable)
+        x + y - Torch.mul(x, y)
+      end
+    end
+
+    # Łukasiewicz disjunction: min(x + y, 1).
+    class OrLuk < BinaryConnectiveOperator
+      def call(x, y)
+        Torch.minimum(x + y, Torch.ones_like(x))
+      end
+    end
+
+    # Kleene-Dienes implication: max(1 - x, y).
+    class ImpliesKleeneDienes < BinaryConnectiveOperator
+      def call(x, y)
+        Torch.maximum(Torch.rsub(x, 1.0), y)
+      end
+    end
+
+    # Gödel implication: 1 if x <= y, y otherwise.
+    class ImpliesGodel < BinaryConnectiveOperator
+      def call(x, y)
+        FuzzyOps.where(Torch.le(x, y), Torch.ones_like(x), y)
+      end
+    end
+
+    # Reichenbach implication: 1 - x + x * y.
+    class ImpliesReichenbach < BinaryConnectiveOperator
+      include Stable
+
+      def call(x, y, stable: nil)
+        x, y = FuzzyOps.pi_0(x), FuzzyOps.pi_1(y) if stable?(stable)
+        Torch.rsub(x, 1.0) + Torch.mul(x, y)
+      end
+    end
+
+    # Goguen implication: 1 if x <= y, y / x otherwise.
+    class ImpliesGoguen < BinaryConnectiveOperator
+      include Stable
+
+      def call(x, y, stable: nil)
+        x = FuzzyOps.pi_0(x) if stable?(stable)
+        FuzzyOps.where(Torch.le(x, y), Torch.ones_like(x), Torch.div(y, x))
+      end
+    end
+
+    # Łukasiewicz implication: min(1 - x + y, 1).
+    class ImpliesLuk < BinaryConnectiveOperator
+      def call(x, y)
+        Torch.minimum(Torch.rsub(x, 1.0) + y, Torch.ones_like(x))
+      end
+    end
+
+    # Equivalence, as the conjunction of the implications in both directions.
+    class Equiv < BinaryConnectiveOperator
+      attr_reader :and_op, :implies_op
+
+      # @parameter and_op [BinaryConnectiveOperator] the conjunction.
+      # @parameter implies_op [BinaryConnectiveOperator] the implication.
+      def initialize(and_op, implies_op)
+        @and_op = and_op
+        @implies_op = implies_op
+      end
+
+      def call(x, y)
+        and_op.call(implies_op.call(x, y), implies_op.call(y, x))
+      end
+
+      def inspect
+        "Equiv(and_op: #{and_op.inspect}, implies_op: #{implies_op.inspect})"
+      end
+    end
+
+    # Abstract base class of the aggregation operators.
+    #
+    # Every aggregator responds to `call(xs, dim: nil, keepdim: false, mask: nil)`:
+    # `dim` is the dimension (or dimensions) to aggregate, nil for all of them,
+    # and `mask` is a boolean tensor shaped like `xs` that excludes the values
+    # where it is false (used for guarded quantification).
+    class AggregationOperator
+      # @raises [NotImplementedError] always: subclasses implement #call.
+      def call(*args, **kwargs)
+        raise NotImplementedError, "#{self.class} must implement #call"
+      end
+
+      def inspect
+        "#{self.class.name.split("::").last}()"
+      end
+
+      def to_s
+        inspect
+      end
+
+      private
+
+      # Mean of `xs` over `dims`, counting only the values where `mask` is true.
+      def masked_mean(xs, mask, dims, keepdim)
+        FuzzyOps.check_mask(mask, xs)
+        numerator = Torch.sum(FuzzyOps.where(mask.logical_not, Torch.zeros_like(xs), xs), dim: dims, keepdim: keepdim)
+        denominator = Torch.sum(mask, dim: dims, keepdim: keepdim)
+        Torch.div(numerator, denominator)
+      end
+    end
+
+    # Shared by the pMean aggregators: `p` and `stable` can be set in the
+    # constructor and overridden on each call.
+    module PMeanParameters
+      # @attribute [Numeric] the exponent of the generalized mean.
+      attr_accessor :p
+
+      # @attribute [Boolean] whether to use the stable variant by default.
+      attr_accessor :stable
+
+      # @parameter p [Numeric] the exponent of the generalized mean.
+      # @parameter stable [Boolean] whether to use the stable variant by default.
+      def initialize(p: 2, stable: true)
+        @p = p
+        @stable = stable
+      end
+
+      def inspect
+        "#{self.class.name.split("::").last}(p: #{p}, stable: #{stable})"
+      end
+    end
+
+    # Minimum, an approximation of the universal quantifier.
+    class AggregMin < AggregationOperator
+      def call(xs, dim: nil, keepdim: false, mask: nil)
+        unless mask.nil?
+          FuzzyOps.check_mask(mask, xs)
+          # 1 is the largest truth value, so masked-out values never win the
+          # minimum. As in LTNtorch, this turns the result into float64.
+          xs = FuzzyOps.where(mask.logical_not, 1.0, xs.double)
+        end
+        Torch.amin(xs, dim: FuzzyOps.reduction_dims(dim), keepdim: keepdim)
+      end
+    end
+
+    # Arithmetic mean.
+    class AggregMean < AggregationOperator
+      def call(xs, dim: nil, keepdim: false, mask: nil)
+        dims = FuzzyOps.reduction_dims(dim)
+        return masked_mean(xs, mask, dims, keepdim) unless mask.nil?
+
+        Torch.mean(xs, dim: dims, keepdim: keepdim)
+      end
+    end
+
+    # Generalized mean (pMean), an approximation of the existential quantifier:
+    # (mean(x ** p)) ** (1 / p).
+    class AggregPMean < AggregationOperator
+      include PMeanParameters
+
+      def call(xs, dim: nil, keepdim: false, mask: nil, p: nil, stable: nil)
+        p = self.p if p.nil?
+        stable = self.stable if stable.nil?
+        dims = FuzzyOps.reduction_dims(dim)
+
+        xs = FuzzyOps.pi_0(xs) if stable
+        xs = Torch.pow(xs, p)
+        mean = mask.nil? ? Torch.mean(xs, dim: dims, keepdim: keepdim) : masked_mean(xs, mask, dims, keepdim)
+        Torch.pow(mean, 1.0 / p)
+      end
+    end
+
+    # Generalized mean of the errors (pMeanError), an approximation of the
+    # universal quantifier: 1 - (mean((1 - x) ** p)) ** (1 / p).
+    class AggregPMeanError < AggregationOperator
+      include PMeanParameters
+
+      def call(xs, dim: nil, keepdim: false, mask: nil, p: nil, stable: nil)
+        p = self.p if p.nil?
+        stable = self.stable if stable.nil?
+        dims = FuzzyOps.reduction_dims(dim)
+
+        xs = FuzzyOps.pi_1(xs) if stable
+        xs = Torch.pow(Torch.rsub(xs, 1.0), p)
+        mean = mask.nil? ? Torch.mean(xs, dim: dims, keepdim: keepdim) : masked_mean(xs, mask, dims, keepdim)
+        Torch.rsub(Torch.pow(mean, 1.0 / p), 1.0)
+      end
+    end
+
+    # Aggregates the truth values of the closed formulas of a knowledge base
+    # into its overall satisfaction level, typically to build a loss as
+    # `1 - sat_agg.(...)`.
+    class SatAgg
+      attr_reader :agg_op
+
+      # @parameter agg_op [AggregationOperator] how to aggregate the truth values.
+      # @raises [TypeError] if `agg_op` is not an aggregation operator.
+      def initialize(agg_op = AggregPMeanError.new(p: 2))
+        unless agg_op.is_a?(AggregationOperator)
+          raise TypeError, "SatAgg.new: argument 'agg_op' (position 1) must be an AggregationOperator, not #{agg_op.class}"
+        end
+
+        @agg_op = agg_op
+      end
+
+      # @parameter closed_formulas [Array(LTNObject | Torch::Tensor)] scalar truth values.
+      # @returns [Torch::Tensor] the aggregated (scalar) truth value.
+      # @raises [TypeError] if a formula is neither an LTNObject nor a tensor.
+      # @raises [ArgumentError] if a formula is not closed (its value is not a
+      #   scalar) or not in [0, 1].
+      def call(*closed_formulas)
+        unless closed_formulas.all? { |f| f.is_a?(LTNObject) || f.is_a?(Torch::Tensor) }
+          raise TypeError, "Expected parameter 'closed_formulas' to be LTNObjects and/or tensors, " \
+            "but got #{closed_formulas.map(&:class).inspect}"
+        end
+
+        truth_values = closed_formulas.map { |f| f.is_a?(LTNObject) ? f.value : f }
+        unless truth_values.all? { |v| v.shape == [] }
+          raise ArgumentError, "Expected parameter 'closed_formulas' to be LTNObjects and/or tensors containing " \
+            "scalars, but got the following shapes: #{truth_values.map(&:shape).inspect}"
+        end
+
+        truth_values = Torch.stack(truth_values, dim: 0)
+        FuzzyOps.check_values(truth_values)
+        agg_op.call(truth_values, dim: 0)
+      end
+
+      def inspect
+        "SatAgg(agg_op: #{agg_op.inspect})"
+      end
+
+      def to_s
+        inspect
+      end
+    end
+  end
+end

data/lib/ltn/lambda_model.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Mauro Tortonesi.
+# Ported from LTNtorch, copyright 2021-2024 by Tommaso Carraro.
+
+module LTN
+  # Wraps a function (a lambda, proc, method or block) in a Torch::NN::Module,
+  # to ground a non-trainable predicate or function.
+  class LambdaModel < Torch::NN::Module
+    # @attribute [#call] the wrapped function.
+    attr_reader :func
+
+    # @parameter func [#call] the function to wrap.
+    def initialize(func)
+      super()
+      @func = func
+    end
+
+    def forward(*inputs, **kwargs)
+      func.call(*inputs, **kwargs)
+    end
+  end
+end

data/lib/ltn/ltn_object.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Mauro Tortonesi.
+# Ported from LTNtorch, copyright 2021-2024 by Tommaso Carraro.
+
+module LTN
+  # The output of every LTN operation: a grounding (a tensor) together with
+  # the labels of the free variables appearing in it, one per leading axis of
+  # the tensor, in order.
+  #
+  # Named `LTNObject`, as in LTNtorch, rather than `LTN::Object`, which would
+  # shadow Ruby's `Object` for every unqualified reference inside `LTN`.
+  class LTNObject
+    # @attribute [Torch::Tensor] the grounding.
+    attr_accessor :value
+
+    # @attribute [Array(String)] labels of the free variables, one per leading axis of #value.
+    attr_accessor :free_vars
+
+    # @parameter value [Torch::Tensor] the grounding.
+    # @parameter var_labels [Array(String)] labels of the free variables in `value`.
+    # @raises [TypeError] if `value` is not a tensor or `var_labels` is not an array of strings.
+    def initialize(value, var_labels)
+      unless value.is_a?(Torch::Tensor)
+        raise TypeError, "LTNObject.new: argument 'value' (position 1) must be a Torch::Tensor, not #{value.class}"
+      end
+      unless var_labels.is_a?(Array) && var_labels.all?(String)
+        raise TypeError,
+          "LTNObject.new: argument 'var_labels' (position 2) must be an Array of String, not #{var_labels.class}"
+      end
+
+      @value = value
+      @free_vars = var_labels
+    end
+
+    # @returns [Array(Integer)] the shape of the grounding.
+    def shape
+      value.shape
+    end
+
+    def inspect
+      "LTNObject(value=#{value.inspect}, free_vars=#{free_vars.inspect})"
+    end
+    alias_method :to_s, :inspect
+  end
+end

data/lib/ltn/model_wrapper.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Mauro Tortonesi.
+# Ported from LTNtorch, copyright 2021-2024 by Tommaso Carraro.
+
+module LTN
+  # The construction shared by Predicate and Function: they are grounded
+  # either by a Torch::NN::Module (trainable) or by a function (not trainable).
+  module ModelWrapper
+    # @attribute [Torch::NN::Module] the grounding; a LambdaModel for a function.
+    attr_reader :model
+
+    # Ground the symbol with either `model` or a function, given as `func:`
+    # or as a block:
+    #
+    #   LTN::Predicate.new(model)
+    #   LTN::Predicate.new(func: ->(x) { Torch.sigmoid(x.sum(1)) })
+    #   LTN::Predicate.new { |x| Torch.sigmoid(x.sum(1)) }
+    #
+    # @parameter model [Torch::NN::Module, nil] a model taking one tensor per argument.
+    # @parameter func [#call, nil] a function taking one tensor per argument.
+    # @raises [ArgumentError] unless exactly one of model, func and block is given.
+    # @raises [TypeError] if `model` is not a Torch::NN::Module or `func` is not callable.
+    def initialize(model = nil, func: nil, &block)
+      super()
+      groundings = [model, func, block].compact
+      if groundings.size > 1
+        raise ArgumentError, "More than one of model, func and block have been specified. " \
+          "Expected only one of them to be specified."
+      end
+      if groundings.empty?
+        raise ArgumentError, "None of model, func and block have been specified. " \
+          "Expected one of them to be specified."
+      end
+
+      @model = if model
+        unless model.is_a?(Torch::NN::Module)
+          raise TypeError, "#{symbol_name}.new: argument 'model' (position 1) must be a Torch::NN::Module, " \
+            "not #{model.class}"
+        end
+        model
+      else
+        func ||= block
+        if !func.respond_to?(:call) || func.is_a?(Torch::NN::Module)
+          raise TypeError, "#{symbol_name}.new: argument 'func' must be a function, not #{func.class}"
+        end
+        LambdaModel.new(func)
+      end
+    end
+
+    def inspect
+      "#{symbol_name}(model=#{model.inspect})"
+    end
+
+    def to_s
+      inspect
+    end
+
+    private
+
+    def symbol_name
+      self.class.name.split("::").last
+    end
+
+    def check_inputs(inputs)
+      return if inputs.all?(LTNObject)
+
+      raise TypeError, "Expected parameter 'inputs' to be LTNObjects, but got #{inputs.map(&:class).inspect}"
+    end
+  end
+end

data/lib/ltn/predicate.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Mauro Tortonesi.
+# Ported from LTNtorch, copyright 2021-2024 by Tommaso Carraro.
+
+module LTN
+  # An LTN predicate: maps individuals to truth values in [0, 1].
+  #
+  #   is_positive = LTN::Predicate.new { |x| Torch.sigmoid(x.sum(1)) }
+  #   x = LTN::Variable.new("x", Torch.randn(4, 3))
+  #   is_positive.call(x) # => an LTNObject with 4 truth values and free_vars ["x"]
+  class Predicate < Torch::NN::Module
+    include ModelWrapper
+
+    # Computes the truth values of the predicate, after broadcasting the
+    # inputs (see LTN.process_ltn_objects): the result has one axis per free
+    # variable of the inputs.
+    #
+    # @parameter inputs [Array(LTNObject)] the arguments.
+    # @parameter kwargs [Hash] passed to the model.
+    # @returns [LTNObject]
+    # @raises [TypeError] if an input is not an LTNObject.
+    # @raises [ArgumentError] if the model returns values outside [0, 1].
+    def forward(*inputs, **kwargs)
+      check_inputs(inputs)
+      processed, output_vars, output_shape = LTN.process_ltn_objects(inputs)
+      output = model.call(*processed.map(&:value), **kwargs)
+
+      unless Torch.all(Torch.logical_and(output.ge(0.0), output.le(1.0))).item
+        raise ArgumentError, "Expected the output of a predicate to be in the range [0., 1.], but got some " \
+          "values outside of this range. Check your predicate implementation!"
+      end
+
+      LTNObject.new(output.reshape(output_shape).float, output_vars)
+    end
+  end
+end