quicopt 0.1.0

data/lib/quicopt/model.rb

@@ -0,0 +1,627 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: (c) 2026 Tim Bode, PGI-12, Forschungszentrum Jülich
+# frozen_string_literal: true
+
+# quicopt/model — the native Ruby modelling DSL and the model it builds.
+#
+# A +Model+ owns decision variables, an objective and constraint rows. Arithmetic
+# on variables (+3 * x + 2 * y+) builds an +Expression+, and comparing two
+# expressions (+x + y <= 5+) builds a +Constraint+ — neither evaluates to a number
+# or a boolean.
+#
+# Expressions are normalised as they are built: an +Expression+ is always a
+# constant plus a map of linear terms plus a map of quadratic terms, never an
+# unreduced operator tree. That is what makes the degree check exact — anything
+# that would exceed degree 2 raises at the point of multiplication rather than
+# reaching the service, per the "raise loudly, never approximate" rule the sibling
+# clients follow.
+#
+# Only flat (unindexed) variables exist here. The wire schema also carries index
+# sets, parameter tables and quantified constraints; the Ruby DSL deliberately
+# does not — see the layered front-ends in the other clients for those.
+
+module Quicopt
+  # Base class of every error this gem raises.
+  class Error < StandardError; end
+
+  # An expression outside the linear/quadratic subset the DSL serves — e.g. a
+  # product of three variables, or a division by a variable. Raised at the point
+  # of construction so the offending term is still in the backtrace.
+  class UnsupportedExpression < Error; end
+
+  # Number and term rendering shared by the DSL's +to_s+ methods. Presentation
+  # only — nothing here touches the wire.
+  #
+  # @api private
+  module Format
+    module_function
+
+    # A float without its trailing +.0+ when it is whole.
+    def number(value)
+      return value.to_s unless value.finite?
+
+      value == value.to_i ? value.to_i.to_s : value.to_s
+    end
+
+    # One term, dropping a unit coefficient (+x+, +-x+, +3*x+).
+    def term(coefficient, factors)
+      return factors if coefficient == 1.0
+      return "-#{factors}" if coefficient == -1.0
+
+      "#{number(coefficient)}*#{factors}"
+    end
+  end
+
+  # The operator surface shared by +Variable+ and +Expression+.
+  #
+  # Every operator is written against +to_expr+, so a variable and an expression
+  # behave identically. +coerce+ makes a numeric on the left work too, which is
+  # what lets +3 * x+ parse: Ruby hands the multiplication back to us rather than
+  # failing in +Integer#*+.
+  module Operators
+    # @return [Expression] +self + other+
+    def +(other)
+      to_expr.plus(Expression.cast(other))
+    end
+
+    # @return [Expression] +self - other+
+    def -(other)
+      to_expr.plus(Expression.cast(other).scale(-1.0))
+    end
+
+    # @return [Expression] +self * other+
+    # @raise [UnsupportedExpression] if the product would exceed degree 2
+    def *(other)
+      to_expr.times(Expression.cast(other))
+    end
+
+    # Division by a numeric constant only — dividing by an expression is not a
+    # polynomial and has no wire form.
+    #
+    # @return [Expression] +self / divisor+
+    # @raise [UnsupportedExpression] if +divisor+ is not a nonzero number
+    def /(divisor)
+      unless divisor.is_a?(Numeric)
+        raise UnsupportedExpression,
+              "cannot divide by #{divisor.class}: only division by a numeric constant is supported"
+      end
+      raise ZeroDivisionError, "divided by 0" if divisor.zero?
+
+      to_expr.scale(1.0 / divisor)
+    end
+
+    # Integer powers 0, 1 and 2 only — the degree the subset admits.
+    #
+    # @return [Expression] +self ** exponent+
+    # @raise [UnsupportedExpression] on any other exponent
+    def **(exponent)
+      case exponent
+      when 0 then Expression.new(constant: 1.0)
+      when 1 then to_expr
+      when 2 then to_expr.times(to_expr)
+      else
+        raise UnsupportedExpression,
+              "exponent #{exponent.inspect} is outside the linear/quadratic subset (0, 1 or 2)"
+      end
+    end
+
+    # @return [Expression] the negation of +self+
+    def -@
+      to_expr.scale(-1.0)
+    end
+
+    # @return [Expression] +self+, unchanged
+    def +@
+      to_expr
+    end
+
+    # @return [Constraint] the row +self <= other+
+    def <=(other)
+      Constraint.build(self, other, :le)
+    end
+
+    # @return [Constraint] the row +self >= other+
+    def >=(other)
+      Constraint.build(self, other, :ge)
+    end
+
+    # Builds an *equality row*, not a boolean — +x == 5+ is a constraint.
+    #
+    # A non-numeric, non-expression operand falls back to identity, so an
+    # incidental comparison (+x == nil+, +x == "x"+) still answers +false+ instead
+    # of raising. Hash and Set membership are unaffected either way: they key off
+    # +hash+/+eql?+, which +Variable+ defines separately.
+    #
+    # @return [Constraint, Boolean]
+    def ==(other)
+      return equal?(other) unless Expression.castable?(other)
+
+      Constraint.build(self, other, :eq)
+    end
+
+    # A disequality is not representable on the wire, and Ruby would otherwise
+    # derive it from +==+ and silently answer +false+ for every row.
+    #
+    # @raise [UnsupportedExpression] always, for an expression-like operand
+    def !=(other)
+      return !equal?(other) unless Expression.castable?(other)
+
+      raise UnsupportedExpression,
+            "!= is not a constraint the wire schema can carry; model it with a binary and a big-M row"
+    end
+
+    # Lets Ruby fold a numeric on the left into an expression, so +3 * x+ and
+    # +10 - x+ dispatch here instead of failing inside +Integer+/+Float+.
+    #
+    # @param other [Numeric]
+    # @return [Array(Expression, Expression)]
+    def coerce(other)
+      [Expression.cast(other), to_expr]
+    end
+  end
+
+  # A decision variable, owned by the +Model+ that created it.
+  #
+  # +index+ is the variable's position in its model; it also fixes the canonical
+  # order of a quadratic term's two factors, so +x * y+ and +y * x+ land on the
+  # same coefficient.
+  class Variable
+    include Operators
+
+    # @return [Model] the model that declared this variable
+    attr_reader :model
+    # @return [String] the wire name; solutions come back keyed by it
+    attr_reader :name
+    # @return [Symbol] +:CONTINUOUS+, +:INTEGER+ or +:BINARY+
+    attr_reader :domain
+    # @return [Float] the lower bound (may be +-Float::INFINITY+)
+    attr_reader :lower
+    # @return [Float] the upper bound (may be +Float::INFINITY+)
+    attr_reader :upper
+    # @return [Float] the starting point handed to the solver
+    attr_reader :start
+    # @return [Integer] the variable's position in its model
+    attr_reader :index
+
+    def initialize(model, name, domain, lower, upper, start, index)
+      @model = model
+      @name = name
+      @domain = domain
+      @lower = lower
+      @upper = upper
+      @start = start
+      @index = index
+      freeze
+    end
+
+    # @return [Expression] this variable as a degree-1 expression
+    def to_expr
+      Expression.new(linear: { self => 1.0 })
+    end
+
+    # Identity equality, kept separate from +==+ (which builds a constraint) so
+    # variables stay usable as Hash and Set keys.
+    def eql?(other)
+      equal?(other)
+    end
+
+    # Hashes by identity, to match +eql?+.
+    def hash
+      object_id.hash
+    end
+
+    # @return [String] the variable's wire name
+    def to_s
+      @name
+    end
+
+    # @return [String] name, domain and bounds
+    def inspect
+      "#<Quicopt::Variable #{@name} #{@domain} [#{@lower}, #{@upper}]>"
+    end
+  end
+
+  # A normalised polynomial of degree ≤ 2 over a model's variables:
+  # +constant + Σ cᵢ·xᵢ + Σ qᵢⱼ·xᵢxⱼ+.
+  #
+  # Instances are immutable — every operator returns a new expression — so an
+  # expression can be shared, reused and stored without aliasing surprises.
+  class Expression
+    include Operators
+
+    # @return [Float] the constant term
+    attr_reader :constant
+    # @return [Hash{Variable=>Float}] linear coefficients, in insertion order
+    attr_reader :linear
+    # @return [Hash{Array(Variable,Variable)=>Float}] quadratic coefficients,
+    #   keyed by the factor pair in model order, in insertion order
+    attr_reader :quadratic
+
+    def initialize(constant: 0.0, linear: {}, quadratic: {})
+      @constant = constant.to_f
+      @linear = linear.freeze
+      @quadratic = quadratic.freeze
+      freeze
+    end
+
+    # @return [Boolean] whether +value+ can become an expression
+    def self.castable?(value)
+      value.is_a?(Expression) || value.is_a?(Variable) || value.is_a?(Numeric)
+    end
+
+    # Coerce a number, variable or expression into an +Expression+.
+    #
+    # @raise [TypeError] for anything else
+    def self.cast(value)
+      case value
+      when Expression then value
+      when Variable then value.to_expr
+      when Numeric then new(constant: value)
+      else
+        raise TypeError, "cannot use #{value.class} in a Quicopt expression"
+      end
+    end
+
+    # @return [Expression] self
+    def to_expr
+      self
+    end
+
+    # @return [Integer] 0, 1 or 2 — the highest degree present
+    def degree
+      return 2 unless @quadratic.empty?
+      return 1 unless @linear.empty?
+
+      0
+    end
+
+    # @return [Boolean] whether this is a bare constant
+    def constant?
+      degree.zero?
+    end
+
+    # @return [Expression] +self + other+
+    def plus(other)
+      Expression.new(constant: @constant + other.constant,
+                     linear: Expression.merge(@linear, other.linear),
+                     quadratic: Expression.merge(@quadratic, other.quadratic))
+    end
+
+    # @return [Expression] +self+ scaled by the numeric +factor+
+    def scale(factor)
+      f = factor.to_f
+      return Expression.new if f.zero?
+
+      Expression.new(constant: @constant * f,
+                     linear: @linear.transform_values { |c| c * f },
+                     quadratic: @quadratic.transform_values { |c| c * f })
+    end
+
+    # Multiply two expressions, staying inside the degree-2 subset.
+    #
+    # A constant factor just scales; two linear factors expand into quadratic
+    # terms. Anything else would exceed degree 2 and raises instead.
+    #
+    # @return [Expression]
+    # @raise [UnsupportedExpression] if the product would exceed degree 2
+    def times(other)
+      return scale(other.constant) if other.constant?
+      return other.scale(@constant) if constant?
+
+      if degree > 1 || other.degree > 1
+        raise UnsupportedExpression,
+              "product of degree #{degree} and degree #{other.degree} exceeds the quadratic subset"
+      end
+
+      quadratic = {}
+      @linear.each do |va, ca|
+        other.linear.each do |vb, cb|
+          key = Expression.pair(va, vb)
+          quadratic[key] = (quadratic[key] || 0.0) + (ca * cb)
+        end
+      end
+      Expression.new(constant: @constant * other.constant,
+                     linear: Expression.merge(@linear.transform_values { |c| c * other.constant },
+                                              other.linear.transform_values { |c| c * @constant }),
+                     quadratic: Expression.prune(quadratic))
+    end
+
+    # Every variable this expression mentions, in first-use order.
+    #
+    # @return [Array<Variable>]
+    def variables
+      seen = @linear.keys
+      @quadratic.each_key { |a, b| seen |= [a, b] }
+      seen
+    end
+
+    # Renders the polynomial, e.g. +3*x + 2*y - 4+.
+    def to_s
+      terms = []
+      terms << Format.number(@constant) unless @constant.zero?
+      @linear.each { |v, c| terms << Format.term(c, v.name) }
+      @quadratic.each { |(a, b), c| terms << Format.term(c, "#{a.name}*#{b.name}") }
+      return "0" if terms.empty?
+
+      terms.join(" + ").gsub(" + -", " - ")
+    end
+
+    # @return [String] the polynomial, tagged with the class
+    def inspect
+      "#<Quicopt::Expression #{self}>"
+    end
+
+    # @return [Boolean] value equality — the same constant and the same
+    #   coefficient maps. Named +eq?+ because +==+ builds a constraint row.
+    def eq?(other)
+      other.is_a?(Expression) && @constant == other.constant &&
+        @linear == other.linear && @quadratic == other.quadratic
+    end
+
+    # Sum two coefficient maps, dropping terms that cancel exactly.
+    #
+    # @api private
+    def self.merge(left, right)
+      return left.dup if right.empty?
+      return right.dup if left.empty?
+
+      out = left.dup
+      right.each { |k, c| out[k] = (out[k] || 0.0) + c }
+      prune(out)
+    end
+
+    # Drop exactly-zero coefficients, so a cancelled term leaves no trace on the
+    # wire.
+    #
+    # @api private
+    def self.prune(terms)
+      terms.reject { |_, c| c.zero? }
+    end
+
+    # The canonical key for a quadratic term: the two factors in model order, so
+    # +x*y+ and +y*x+ accumulate on one coefficient.
+    #
+    # @api private
+    def self.pair(left, right)
+      (left.index <= right.index ? [left, right] : [right, left]).freeze
+    end
+  end
+
+  # One constraint row: a residual expression compared against zero.
+  #
+  # +expr+ is +lhs - rhs+, so the row is +expr <= 0+, +expr >= 0+ or +expr == 0+.
+  # The lowering in +Quicopt::Wire+ splits that into the body +f+ (the variable
+  # terms) and the numeric +bound+ (the constant, moved to the other side), which
+  # is the shape the wire's function-in-set rows take.
+  class Constraint
+    # The comparison operator each sense renders as.
+    SENSES = { le: "<=", ge: ">=", eq: "==" }.freeze
+
+    # @return [Expression] the residual +lhs - rhs+
+    attr_reader :expr
+    # @return [Symbol] +:le+, +:ge+ or +:eq+
+    attr_reader :sense
+
+    # Build a row from the two sides of a comparison.
+    def self.build(lhs, rhs, sense)
+      new(Expression.cast(lhs).plus(Expression.cast(rhs).scale(-1.0)), sense)
+    end
+
+    def initialize(expr, sense)
+      raise ArgumentError, "unknown constraint sense #{sense.inspect}" unless SENSES.key?(sense)
+
+      @expr = expr
+      @sense = sense
+      freeze
+    end
+
+    # The row body: the variable terms alone, with the constant moved to +bound+.
+    #
+    # @return [Expression]
+    def body
+      Expression.new(linear: @expr.linear, quadratic: @expr.quadratic)
+    end
+
+    # The right-hand side after moving the constant across.
+    #
+    # @return [Float]
+    def bound
+      -@expr.constant
+    end
+
+    # Renders the row as +body <op> bound+.
+    def to_s
+      "#{body} #{SENSES[@sense]} #{Format.number(bound)}"
+    end
+
+    # @return [String] the row, tagged with the class
+    def inspect
+      "#<Quicopt::Constraint #{self}>"
+    end
+  end
+
+  # An optimization model: variables, one objective, and constraint rows.
+  #
+  #   m = Quicopt::Model.new
+  #   x = m.int_var(0, 4, "x")
+  #   y = m.bin_var("y")
+  #   m.maximize(3 * x + 2 * y)
+  #   m.add(x + y <= 5)
+  #
+  # The model is the authoring surface; +to_program+ / +encode+ lower it to the
+  # wire IR, and +Quicopt::Client#solve+ ships it.
+  class Model
+    # @return [Array<Variable>] the declared variables, in declaration order
+    attr_reader :variables
+    # @return [Array<Constraint>] the constraint rows, in insertion order
+    attr_reader :constraints
+    # @return [Expression] the objective (the zero expression until set)
+    attr_reader :objective
+    # @return [String] +"min"+ or +"max"+
+    attr_reader :sense
+
+    def initialize
+      @variables = []
+      @by_name = {}
+      @constraints = []
+      @objective = Expression.new
+      @sense = "min"
+    end
+
+    # Declare a continuous variable.
+    #
+    # @param lower [Numeric, nil] the lower bound; +nil+ means unbounded below
+    # @param upper [Numeric, nil] the upper bound; +nil+ means unbounded above
+    # @param name [String, nil] the wire name; auto-generated when omitted
+    # @param start [Numeric, nil] the starting point; defaults to 0 clamped into
+    #   the bounds, matching the other clients' front-ends
+    # @return [Variable]
+    def num_var(lower = nil, upper = nil, name = nil, start: nil)
+      declare(:CONTINUOUS, lower, upper, name, start)
+    end
+
+    # Declare an integer variable.
+    #
+    # Bounds of exactly +[0, 1]+ declare a +:BINARY+ variable rather than an
+    # integer one — the same normalisation the other front-ends apply, so the
+    # same model reaches the service as the same IR whichever client authored it.
+    #
+    # @return [Variable]
+    def int_var(lower = nil, upper = nil, name = nil, start: nil)
+      lo = coerce_bound(lower, -Float::INFINITY)
+      hi = coerce_bound(upper, Float::INFINITY)
+      domain = lo.zero? && hi == 1.0 ? :BINARY : :INTEGER
+      declare(domain, lo, hi, name, start)
+    end
+
+    # Declare a binary variable.
+    #
+    # @return [Variable]
+    def bin_var(name = nil, start: nil)
+      declare(:BINARY, 0.0, 1.0, name, start)
+    end
+
+    # Look a variable up by its wire name.
+    #
+    # @return [Variable, nil]
+    def variable(name)
+      @by_name[name.to_s]
+    end
+
+    # Minimize +expr+.
+    #
+    # @return [Expression] the objective now set
+    def minimize(expr)
+      set_objective(expr, "min")
+    end
+
+    # Maximize +expr+.
+    #
+    # @return [Expression] the objective now set
+    def maximize(expr)
+      set_objective(expr, "max")
+    end
+
+    # Add a constraint row built by +<=+, +>=+ or +==+.
+    #
+    # @param constraint [Constraint]
+    # @return [Constraint] the row just added
+    # @raise [TypeError] if handed something that is not a constraint — most
+    #   often a bare expression, or a comparison Ruby already reduced to a boolean
+    def add(constraint)
+      unless constraint.is_a?(Constraint)
+        raise TypeError,
+              "add expects a constraint such as `x + y <= 5`, got #{constraint.class}"
+      end
+      check_ownership(constraint.expr)
+      @constraints << constraint
+      constraint
+    end
+
+    # Lower this model to the wire IR.
+    #
+    # @return [Quicopt::Modeler::V1::Program]
+    def to_program
+      Wire.program(self)
+    end
+
+    # Lower this model and serialize it to wire bytes.
+    #
+    # @return [String] binary protobuf bytes
+    def encode
+      Wire.encode(self)
+    end
+
+    # Renders the whole model: objective, rows, then declarations.
+    def to_s
+      lines = ["#{@sense} #{@objective}"]
+      lines << "subject to" unless @constraints.empty?
+      @constraints.each { |c| lines << "  #{c}" }
+      @variables.each do |v|
+        lines << "  #{v.name} in #{v.domain} [#{Format.number(v.lower)}, #{Format.number(v.upper)}]"
+      end
+      lines.join("\n")
+    end
+
+    # @return [String] a one-line summary: variable and row counts
+    def inspect
+      "#<Quicopt::Model #{@variables.size} vars, #{@constraints.size} constraints>"
+    end
+
+    private
+
+    def declare(domain, lower, upper, name, start)
+      lo = coerce_bound(lower, -Float::INFINITY)
+      hi = coerce_bound(upper, Float::INFINITY)
+      raise ArgumentError, "lower bound #{lo} exceeds upper bound #{hi}" if lo > hi
+
+      nm = name.nil? ? auto_name : name.to_s
+      raise ArgumentError, "duplicate variable name #{nm.inspect}" if @by_name.key?(nm)
+
+      variable = Variable.new(self, nm, domain, lo, hi, coerce_start(start, lo, hi), @variables.size)
+      @variables << variable
+      @by_name[nm] = variable
+      variable
+    end
+
+    def coerce_bound(value, default)
+      return default if value.nil?
+      raise ArgumentError, "bound must be a number, got #{value.class}" unless value.is_a?(Numeric)
+
+      value.to_f
+    end
+
+    # 0 clamped into the bounds — finite for any bounds, matching the sibling
+    # front-ends so an unset start lowers identically across clients.
+    def coerce_start(start, lower, upper)
+      return [[0.0, lower].max, upper].min if start.nil?
+      raise ArgumentError, "start must be a number, got #{start.class}" unless start.is_a?(Numeric)
+
+      start.to_f
+    end
+
+    def auto_name
+      n = @variables.size + 1
+      n += 1 while @by_name.key?("x#{n}")
+      "x#{n}"
+    end
+
+    def set_objective(expr, sense)
+      objective = Expression.cast(expr)
+      check_ownership(objective)
+      @objective = objective
+      @sense = sense
+      objective
+    end
+
+    # Reject variables belonging to another model: their names would collide
+    # arbitrarily and their coefficients would silently merge on the wire.
+    def check_ownership(expr)
+      expr.variables.each do |v|
+        next if v.model.equal?(self)
+
+        raise ArgumentError, "variable #{v.name.inspect} belongs to a different Quicopt::Model"
+      end
+    end
+  end
+end

data/lib/quicopt/modeler/v1/program_pb.rb

@@ -0,0 +1,48 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: (c) 2026 Tim Bode, PGI-12, Forschungszentrum Jülich
+
+# frozen_string_literal: true
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: quicopt/modeler/v1/program.proto
+
+require 'google/protobuf'
+
+
+descriptor_data = "\n quicopt/modeler/v1/program.proto\x12\x12quicopt.modeler.v1\"2\n\tIndexElem\x12\r\n\x03int\x18\x01 \x01(\x03H\x00\x12\x0e\n\x04name\x18\x02 \x01(\tH\x00\x42\x06\n\x04kind\"5\n\x05Index\x12,\n\x05\x65lems\x18\x01 \x03(\x0b\x32\x1d.quicopt.modeler.v1.IndexElem\"\xdc\x01\n\nExpression\x12\x12\n\x08\x63onstant\x18\x01 \x01(\x01H\x00\x12-\n\x05param\x18\x02 \x01(\x0b\x32\x1c.quicopt.modeler.v1.ParamRefH\x00\x12)\n\x03var\x18\x03 \x01(\x0b\x32\x1a.quicopt.modeler.v1.VarRefH\x00\x12*\n\x05\x61pply\x18\x04 \x01(\x0b\x32\x19.quicopt.modeler.v1.ApplyH\x00\x12,\n\x06reduce\x18\x05 \x01(\x0b\x32\x1a.quicopt.modeler.v1.ReduceH\x00\x42\x06\n\x04node\"B\n\x08ParamRef\x12\x0c\n\x04name\x18\x01 \x01(\t\x12(\n\x05index\x18\x02 \x01(\x0b\x32\x19.quicopt.modeler.v1.Index\"@\n\x06VarRef\x12\x0c\n\x04name\x18\x01 \x01(\t\x12(\n\x05index\x18\x02 \x01(\x0b\x32\x19.quicopt.modeler.v1.Index\"A\n\x05\x41pply\x12\n\n\x02op\x18\x01 \x01(\t\x12,\n\x04\x61rgs\x18\x02 \x03(\x0b\x32\x1e.quicopt.modeler.v1.Expression\"?\n\x06SetRef\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\'\n\x04\x61rgs\x18\x02 \x01(\x0b\x32\x19.quicopt.modeler.v1.Index\"\xa7\x01\n\x06Reduce\x12\n\n\x02op\x18\x01 \x01(\t\x12\x0b\n\x03idx\x18\x02 \x01(\t\x12(\n\x04over\x18\x03 \x01(\x0b\x32\x1a.quicopt.modeler.v1.SetRef\x12,\n\x04\x62ody\x18\x04 \x01(\x0b\x32\x1e.quicopt.modeler.v1.Expression\x12,\n\x04\x63ond\x18\x05 \x01(\x0b\x32\x1e.quicopt.modeler.v1.Expression\"\x06\n\x04Zero\"\x08\n\x06Nonneg\"_\n\tIndicator\x12\'\n\x03\x62in\x18\x01 \x01(\x0b\x32\x1a.quicopt.modeler.v1.VarRef\x12)\n\x05inner\x18\x02 \x01(\x0b\x32\x1a.quicopt.modeler.v1.ConSet\"\x9c\x01\n\x06\x43onSet\x12(\n\x04zero\x18\x01 \x01(\x0b\x32\x18.quicopt.modeler.v1.ZeroH\x00\x12,\n\x06nonneg\x18\x02 \x01(\x0b\x32\x1a.quicopt.modeler.v1.NonnegH\x00\x12\x32\n\tindicator\x18\x03 \x01(\x0b\x32\x1d.quicopt.modeler.v1.IndicatorH\x00\x42\x06\n\x04kind\"D\n\x0cQuantBinding\x12\x0b\n\x03idx\x18\x01 \x01(\t\x12\'\n\x03set\x18\x02 \x01(\x0b\x32\x1a.quicopt.modeler.v1.SetRef\"\x90\x01\n\nConstraint\x12)\n\x01\x66\x18\x01 \x01(\x0b\x32\x1e.quicopt.modeler.v1.Expression\x12\'\n\x03set\x18\x02 \x01(\x0b\x32\x1a.quicopt.modeler.v1.ConSet\x12.\n\x04over\x18\x03 \x03(\x0b\x32 .quicopt.modeler.v1.QuantBinding\"2\n\x05\x42ound\x12\x10\n\x06scalar\x18\x01 \x01(\x01H\x00\x12\x0f\n\x05param\x18\x02 \x01(\tH\x00\x42\x06\n\x04kind\"\xb4\x01\n\x07VarDecl\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x0c\n\x04\x61xes\x18\x02 \x03(\t\x12*\n\x06\x64omain\x18\x03 \x01(\x0e\x32\x1a.quicopt.modeler.v1.Domain\x12(\n\x05lower\x18\x04 \x01(\x0b\x32\x19.quicopt.modeler.v1.Bound\x12(\n\x05upper\x18\x05 \x01(\x0b\x32\x19.quicopt.modeler.v1.Bound\x12\r\n\x05start\x18\x06 \x01(\x01\"I\n\x08IndexSet\x12\x0c\n\x04name\x18\x01 \x01(\t\x12/\n\x08\x65lements\x18\x02 \x03(\x0b\x32\x1d.quicopt.modeler.v1.IndexElem\"g\n\x0fIndexedSetFibre\x12&\n\x03key\x18\x01 \x01(\x0b\x32\x19.quicopt.modeler.v1.Index\x12,\n\x05value\x18\x02 \x03(\x0b\x32\x1d.quicopt.modeler.v1.IndexElem\"O\n\nIndexedSet\x12\x0c\n\x04name\x18\x01 \x01(\t\x12\x33\n\x06\x66ibres\x18\x02 \x03(\x0b\x32#.quicopt.modeler.v1.IndexedSetFibre\"C\n\nParamEntry\x12&\n\x03key\x18\x01 \x01(\x0b\x32\x19.quicopt.modeler.v1.Index\x12\r\n\x05value\x18\x02 \x01(\x01\"K\n\nParamTable\x12\x0c\n\x04name\x18\x01 \x01(\t\x12/\n\x07\x65ntries\x18\x02 \x03(\x0b\x32\x1e.quicopt.modeler.v1.ParamEntry\"P\n\x08\x46ixEntry\x12\x0b\n\x03var\x18\x01 \x01(\t\x12(\n\x05index\x18\x02 \x01(\x0b\x32\x19.quicopt.modeler.v1.Index\x12\r\n\x05value\x18\x03 \x01(\x01\"\xe8\x02\n\x07Program\x12*\n\x04sets\x18\x01 \x03(\x0b\x32\x1c.quicopt.modeler.v1.IndexSet\x12\x34\n\x0cindexed_sets\x18\x02 \x03(\x0b\x32\x1e.quicopt.modeler.v1.IndexedSet\x12.\n\x06params\x18\x03 \x03(\x0b\x32\x1e.quicopt.modeler.v1.ParamTable\x12)\n\x04vars\x18\x04 \x03(\x0b\x32\x1b.quicopt.modeler.v1.VarDecl\x12\x31\n\tobjective\x18\x05 \x01(\x0b\x32\x1e.quicopt.modeler.v1.Expression\x12\r\n\x05sense\x18\x06 \x01(\t\x12\x33\n\x0b\x63onstraints\x18\x07 \x03(\x0b\x32\x1e.quicopt.modeler.v1.Constraint\x12)\n\x03\x66ix\x18\x08 \x03(\x0b\x32\x1c.quicopt.modeler.v1.FixEntry\";\n\tParamData\x12.\n\x06params\x18\x01 \x03(\x0b\x32\x1e.quicopt.modeler.v1.ParamTable\"0\n\x05OpDef\x12\n\n\x02op\x18\x01 \x01(\t\x12\r\n\x05\x61rity\x18\x02 \x01(\x05\x12\x0c\n\x04tags\x18\x03 \x03(\t\"B\n\x07\x43\x61talog\x12\x0f\n\x07version\x18\x01 \x01(\r\x12&\n\x03ops\x18\x02 \x03(\x0b\x32\x19.quicopt.modeler.v1.OpDef*I\n\x06\x44omain\x12\x16\n\x12\x44OMAIN_UNSPECIFIED\x10\x00\x12\x0e\n\nCONTINUOUS\x10\x01\x12\x0b\n\x07INTEGER\x10\x02\x12\n\n\x06\x42INARY\x10\x03\x62\x06proto3"
+
+pool = ::Google::Protobuf::DescriptorPool.generated_pool
+pool.add_serialized_file(descriptor_data)
+
+module Quicopt
+  module Modeler
+    module V1
+      IndexElem = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.IndexElem").msgclass
+      Index = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.Index").msgclass
+      Expression = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.Expression").msgclass
+      ParamRef = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.ParamRef").msgclass
+      VarRef = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.VarRef").msgclass
+      Apply = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.Apply").msgclass
+      SetRef = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.SetRef").msgclass
+      Reduce = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.Reduce").msgclass
+      Zero = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.Zero").msgclass
+      Nonneg = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.Nonneg").msgclass
+      Indicator = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.Indicator").msgclass
+      ConSet = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.ConSet").msgclass
+      QuantBinding = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.QuantBinding").msgclass
+      Constraint = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.Constraint").msgclass
+      Bound = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.Bound").msgclass
+      VarDecl = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.VarDecl").msgclass
+      IndexSet = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.IndexSet").msgclass
+      IndexedSetFibre = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.IndexedSetFibre").msgclass
+      IndexedSet = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.IndexedSet").msgclass
+      ParamEntry = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.ParamEntry").msgclass
+      ParamTable = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.ParamTable").msgclass
+      FixEntry = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.FixEntry").msgclass
+      Program = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.Program").msgclass
+      ParamData = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.ParamData").msgclass
+      OpDef = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.OpDef").msgclass
+      Catalog = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.Catalog").msgclass
+      Domain = ::Google::Protobuf::DescriptorPool.generated_pool.lookup("quicopt.modeler.v1.Domain").enummodule
+    end
+  end
+end

data/lib/quicopt/version.rb

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: (c) 2026 Tim Bode, PGI-12, Forschungszentrum Jülich
+# frozen_string_literal: true
+
+module Quicopt
+  # The gem version, tracking the client — not the wire schema, which is
+  # versioned separately by its protobuf package (`quicopt.modeler.v1`).
+  VERSION = "0.1.0"
+end