quicopt 0.1.0 → 0.3.0

data/lib/quicopt/wire.rb

@@ -5,15 +5,15 @@
 require "google/protobuf"
 require_relative "modeler/v1/program_pb"
 
-# quicopt/wire — a +Model+ → the wire IR +Program+ → protobuf bytes.
+# quicopt/wire — a +Model+ → the +Program+ message → protobuf bytes.
 #
-# The generated codec (+lib/quicopt/modeler/+, regenerated by +gen/gen.sh+ from
-# the vendored +program.proto+) does the serialization; this file supplies the
-# node constructors on top of it and the lowering from the DSL's normalised
-# polynomials into the IR's expression trees.
+# The generated protobuf classes (+lib/quicopt/modeler/+, regenerated by
+# +gen/gen.sh+ from the vendored +program.proto+) do the encoding; this file
+# supplies the node constructors on top of them and the translation from the DSL's
+# collected polynomials into the message's expression trees.
 #
-# The canonical forms below are shared with the other clients, so the same model
-# authored in Ruby, Python or Julia reaches the service as the same IR:
+# The forms below are shared with the Python and Julia clients, so the same model
+# written in any of the three arrives as the same message:
 #
 #   f = c   ⇒  f − c = 0   (Zero)
 #   f ≥ l   ⇒  f − l ≥ 0   (Nonneg)
@@ -22,33 +22,52 @@ require_relative "modeler/v1/program_pb"
 # A unit coefficient is dropped rather than emitted as +1 * e+, an additive zero
 # constant is dropped from a sum, and a sum of one term is that term.
 #
-# Note on byte-level comparison: proto3 omits zero-valued scalars (+start: 0.0+)
-# and does not canonicalize field order, so these bytes are *decode-equivalent*
-# to the service's reference codec, not byte-identical — the same position the
-# Julia client is in. Compare decoded +Program+ values in tests, never hex.
+# Permutations, partitions and lookup tables count from 0 in the DSL and from 1
+# on the wire, and this file is the one place that shifts between the two:
+#
+#   route.item_at(k)  ⇒  item_at(k + 1, route) − 1
+#   teams.part_of(i)  ⇒  part_of(i + 1, teams) − 1
+#   teams.size_of(b)  ⇒  size_of(b + 1, teams)      (a count: not shifted)
+#   dist[i, j]        ⇒  dist[i + 1, j + 1]
+#
+# A read used as a table position meets both shifts, and they cancel:
+# +dist[route.item_at(0), …]+ goes out as +dist[item_at(1, route), …]+.
+#
+# The terms that switch (+quicopt/indicators+) go out as the catalog's
+# +indicator+, +step+, +min+ and +max+; a +min+ or +max+ of more than two
+# arguments as nested binary ones, folded from the left.
+#
+# Note on byte-level comparison: protobuf omits fields that hold their default
+# value (+start: 0.0+) and does not fix the order of map entries, so two encodings
+# of one model can differ byte for byte while meaning exactly the same thing — the
+# same position the Julia client is in. Compare decoded +Program+ values in tests,
+# never hex.
 module Quicopt
-  # Node constructors over the generated codec, and the lowering from the DSL's
-  # normalised polynomials into the IR's expression trees.
+  # Node constructors over the generated protobuf classes, and the translation
+  # from the DSL's collected polynomials into the message's expression trees.
   module Wire
-    # The generated wire schema — +Program+, +Expression+, +Constraint+, … — as
-    # the client's IR. Aliased for brevity throughout the codec.
+    # The generated protobuf classes — +Program+, +Expression+, +Constraint+, …
+    # Aliased for brevity throughout this file.
     PB = Quicopt::Modeler::V1
 
     class << self
-      # Lower +model+ to the wire IR.
+      # Turn +model+ into the +Program+ message the service reads.
       #
       # @param model [Quicopt::Model]
       # @return [PB::Program]
       def program(model)
         PB::Program.new(
+          params: model.tables.sort_by(&:name).map { |t| param_table(t) },
           vars: model.variables.map { |v| var_decl(v) },
           objective: expression(model.objective),
           sense: model.sense,
-          constraints: model.constraints.map { |c| constraint(c) }
+          constraints: model.constraints.map { |c| constraint(c) },
+          structures: (model.permutations + model.partitions).sort_by(&:name).map { |p| structure_decl(p) },
+          blocks: model.blocks.sort_by(&:name).map { |b| block_decl(b) }
         )
       end
 
-      # Serialize a model (or an already-lowered +Program+) to wire bytes.
+      # Encode a model (or an already-built +Program+) to bytes.
       #
       # @param model [Quicopt::Model, PB::Program]
       # @return [String] binary protobuf bytes
@@ -56,8 +75,8 @@ module Quicopt
         PB::Program.encode(model.is_a?(PB::Program) ? model : program(model))
       end
 
-      # Parse wire bytes back into a +Program+ — the inverse of +encode+, and the
-      # only sound way to compare two encodings.
+      # Parse bytes back into a +Program+ — the inverse of +encode+, and the only
+      # sound way to compare two encodings.
       #
       # @param bytes [String]
       # @return [PB::Program]
@@ -67,26 +86,26 @@ module Quicopt
 
       # ── node constructors ──────────────────────────────────────────────────
 
-      # A constant expression node. Always a set +oneof+ case, so +Const(0.0)+
-      # survives the round-trip rather than vanishing as a proto3 default.
+      # A constant expression node. The +oneof+ case is always set, so a constant
+      # +0.0+ survives the round-trip rather than vanishing as a protobuf default.
       def const(value)
         PB::Expression.new(constant: number(value))
       end
 
-      # Normalise negative zero on its way to the wire.
+      # Flatten negative zero before encoding.
       #
       # IEEE keeps +-0.0+ distinct from +0.0+ — a distinct bit pattern, and a
       # distinct protobuf value — and moving a bound across an inequality
       # (+f ≤ 0+ ⇒ +0 − f ≥ 0+) produces one whenever that bound is zero. The
-      # sibling clients emit +0.0+ there, so collapse the sign here rather than
-      # shipping bytes that differ from theirs by a sign bit.
+      # Python and Julia clients send +0.0+ there, so collapse the sign here
+      # rather than sending bytes that differ from theirs by a sign bit.
       def number(value)
         float = value.to_f
         float.zero? ? 0.0 : float
       end
 
-      # A reference to a flat (unindexed) variable. The +Index+ message is emitted
-      # present-but-empty, matching the reference codec.
+      # A reference to a flat (unindexed) variable. The +Index+ message is sent
+      # present-but-empty, which is what the service expects.
       def var(name)
         PB::Expression.new(var: PB::VarRef.new(name: name, index: PB::Index.new))
       end
@@ -96,6 +115,17 @@ module Quicopt
         PB::Expression.new(apply: PB::Apply.new(op: op, args: args))
       end
 
+      # A reference to a declared permutation, by name.
+      def structure(name)
+        PB::Expression.new(structure: PB::StructRef.new(name: name))
+      end
+
+      # A read of the parameter table +param+ at the given positions (counted
+      # from 1, as on the wire).
+      def table(param, index)
+        PB::Expression.new(table: PB::TableRef.new(param: param, index: index))
+      end
+
       # +coef · expr+, dropping a unit coefficient.
       def scaled(coef, expr)
         coef == 1.0 ? expr : apply("*", [const(coef), expr])
@@ -113,21 +143,124 @@ module Quicopt
 
       # ── lowering ───────────────────────────────────────────────────────────
 
-      # A normalised DSL expression → an IR expression tree: the constant (when
-      # nonzero), then the linear terms, then the quadratic ones — the term order
-      # the sibling front-ends emit.
+      # A collected DSL expression → the message's expression tree: the constant
+      # (when nonzero), then the linear terms, then the quadratic ones — the term
+      # order the Python and Julia clients use.
       #
       # @param expr [Quicopt::Expression]
       # @return [PB::Expression]
       def expression(expr)
         terms = []
         terms << const(expr.constant) unless expr.constant.zero?
-        expr.linear.each { |v, c| terms << scaled(c, var(v.name)) }
-        expr.quadratic.each { |(a, b), c| terms << scaled(c, apply("*", [var(a.name), var(b.name)])) }
+        expr.linear.each { |v, c| terms << scaled(c, factor(v)) }
+        expr.quadratic.each { |(a, b), c| terms << scaled(c, apply("*", [factor(a), factor(b)])) }
         sum(terms)
       end
 
-      # One DSL constraint row → an IR function-in-set row.
+      # One factor of a term: a variable, a read of a permutation, partition or
+      # lookup table (each standing for its value counted from 0), or a term
+      # that switches.
+      #
+      # @param factor [Quicopt::Variable, Quicopt::Placement, Quicopt::PartRead,
+      #   Quicopt::TableEntry, Quicopt::Condition, Quicopt::Extremum]
+      # @return [PB::Expression]
+      def factor(factor)
+        case factor
+        when Variable then var(factor.name)
+        when Placement
+          apply("-", [apply(factor.op.to_s, [const(factor.position + 1), structure(factor.permutation.name)]),
+                      const(1.0)])
+        when PartRead then part_read(factor)
+        when TableEntry then table(factor.table.name, factor.index.map { |e| one_based(e) })
+        when Condition then condition(factor)
+        when Extremum
+          factor.args.map { |a| expression(a) }.reduce { |acc, e| apply(factor.op.to_s, [acc, e]) }
+        else raise Error, "unknown factor #{factor.inspect}"
+        end
+      end
+
+      # A read of a partition: the part, shifted to count from 0; the size, a
+      # count, as it is.
+      #
+      # @param read [Quicopt::PartRead]
+      # @return [PB::Expression]
+      def part_read(read)
+        node = apply(read.op.to_s, [const(read.position + 1), structure(read.partition.name)])
+        read.op == :part_of ? apply("-", [node, const(1.0)]) : node
+      end
+
+      # A 0/1 term: +indicator(e)+, +step(e)+, or +step(tol − abs(e))+ for a
+      # comparison with a tolerance.
+      #
+      # @param cond [Quicopt::Condition]
+      # @return [PB::Expression]
+      def condition(cond)
+        arg = expression(cond.argument)
+        case cond.op
+        when :indicator then apply("indicator", [arg])
+        when :step then apply("step", [arg])
+        when :near then apply("step", [apply("-", [const(cond.tol), apply("abs", [arg])])])
+        else raise Error, "unknown condition #{cond.op.inspect}"
+        end
+      end
+
+      # A table position, counted from 0 in the DSL, as the wire's position
+      # counted from 1: a whole number moves up by one, a read of a permutation
+      # loses the − 1 its own shift added, and anything else gains + 1.
+      #
+      # @param position [Quicopt::Expression]
+      # @return [PB::Expression]
+      def one_based(position)
+        return const(position.constant + 1) if position.constant?
+
+        e = expression(position)
+        down = e.node == :apply && e.apply.op == "-" && e.apply.args.size == 2 &&
+               e.apply.args[1].node == :constant && e.apply.args[1].constant == 1.0
+        down ? e.apply.args[0] : apply("+", [e, const(1.0)])
+      end
+
+      # A lookup table → +ParamTable+: one entry per cell, keyed by its positions
+      # counted from 1, in row-major order.
+      #
+      # @param table [Quicopt::LookupTable]
+      # @return [PB::ParamTable]
+      def param_table(table)
+        cells = table.shape.map { |extent| (0...extent).to_a }
+        keys = cells.first.product(*cells.drop(1))
+        PB::ParamTable.new(name: table.name, entries: keys.map do |key|
+          PB::ParamEntry.new(key: PB::Index.new(elems: key.map { |k| PB::IndexElem.new(int: k + 1) }),
+                             value: number(key.reduce(table.values) { |row, k| row[k] }))
+        end)
+      end
+
+      # A permutation or a partition → +StructureDecl+, its start (and a
+      # permutation's precedences) counted from 1.
+      #
+      # @param structure [Quicopt::Permutation, Quicopt::Partition]
+      # @return [PB::StructureDecl]
+      def structure_decl(structure)
+        start = (structure.start || []).map { |k| k + 1 }
+        if structure.is_a?(Partition)
+          return PB::StructureDecl.new(name: structure.name, kind: "partition", size: structure.size,
+                                       start: start, fixed: false, parts: structure.parts)
+        end
+
+        PB::StructureDecl.new(
+          name: structure.name, kind: "permutation", size: structure.size, start: start, fixed: false,
+          precede: structure.precedences.map { |a, b| PB::Precedence.new(before: a + 1, after: b + 1) }
+        )
+      end
+
+      # A block → +BlockDecl+: its name and its variables, in the order given.
+      #
+      # @param block [Quicopt::Block]
+      # @return [PB::BlockDecl]
+      def block_decl(block)
+        PB::BlockDecl.new(name: block.name,
+                          members: block.variables.map { |v| PB::VarRef.new(name: v.name, index: PB::Index.new) })
+      end
+
+      # One DSL constraint row → one constraint in the message.
       #
       # @param con [Quicopt::Constraint]
       # @return [PB::Constraint]
@@ -142,9 +275,11 @@ module Quicopt
         end
       end
 
-      # A variable declaration → +VarDecl+. Bounds are scalars (a Param-table
-      # bound needs indexed variables, which the DSL does not have); ±Inf passes
-      # straight through as a free direction.
+      # A variable declaration → +VarDecl+. Bounds are plain numbers (the message
+      # can also take a bound from a parameter table, but that needs indexed
+      # variables, which this DSL does not have); ±Inf passes straight through and
+      # means "unbounded in that direction". A variable that may also be 0 goes
+      # out with its domain, +SEMICONTINUOUS+ or +SEMIINTEGER+.
       #
       # @param variable [Quicopt::Variable]
       # @return [PB::VarDecl]

data/lib/quicopt.rb

@@ -4,13 +4,14 @@
 
 require_relative "quicopt/version"
 require_relative "quicopt/model"
+require_relative "quicopt/structured"
+require_relative "quicopt/indicators"
 require_relative "quicopt/wire"
 require_relative "quicopt/client"
 
 # Quicopt — a Ruby client for the Quicopt optimization service.
 #
-# Author a model in the native DSL, encode it to the versioned wire IR, and let
-# the service solve it:
+# Write a model in the native DSL, encode it, and let the service solve it:
 #
 #   require "quicopt"
 #
@@ -26,12 +27,12 @@ require_relative "quicopt/client"
 #
 # Three pieces, nothing more: +Model+ authors, +Wire+ encodes, +Client+ ships.
 module Quicopt
-  # The wire IR container, re-exported so callers can inspect or route the bytes
-  # themselves rather than going through +Client+.
+  # The structured message a model becomes, re-exported so callers can inspect
+  # the bytes or route them themselves rather than going through +Client+.
   Program = Wire::PB::Program
 
   class << self
-    # Lower a model to wire bytes.
+    # Encode a model to bytes.
     #
     # @param model [Model, Program]
     # @return [String] binary protobuf bytes
@@ -39,7 +40,7 @@ module Quicopt
       Wire.encode(model)
     end
 
-    # Parse wire bytes back into a +Program+.
+    # Parse bytes back into a +Program+.
     #
     # @param bytes [String]
     # @return [Program]

data/proto/quicopt/modeler/v1/program.proto

@@ -54,15 +54,52 @@ message Index {
 
 message Expression {
   oneof node {
-    double   constant = 1;  // Const(value) — always emitted (a set oneof case),
-                            //                so Const(0.0) survives the round-trip
-    ParamRef param    = 2;  // Param(name, index)
-    VarRef   var      = 3;  // Var(name, index)
-    Apply    apply    = 4;  // Apply(op, args)
-    Reduce   reduce   = 5;  // Reduce(op, idx, over, body, cond)
+    double    constant  = 1;  // Const(value) — always emitted (a set oneof case),
+                              //                so Const(0.0) survives the round-trip
+    ParamRef  param     = 2;  // Param(name, index)
+    VarRef    var       = 3;  // Var(name, index)
+    Apply     apply     = 4;  // Apply(op, args)
+    Reduce    reduce    = 5;  // Reduce(op, idx, over, body, cond)
+    SourceRef source    = 6;  // SourceRef(name) — a stochastic source, by name
+    StructRef structure = 7;  // StructRef(name) — a declared structure, by name
+    TableRef  table     = 8;  // TableRef(param, index) — a data table read at
+                              //   positions given by expressions
   }
 }
 
+// A reference to a declared stochastic source (Program.sources). Identity lives
+// in the NAME: every SourceRef("w") denotes the same random variable, however
+// often the subtree containing it is copied — so tree encodings and rewrites
+// preserve the model's correlation structure with no encoder discipline
+// required. Independent sources are separate declarations. A server that
+// predates this field rejects any Expression carrying it (an empty oneof), so
+// a stochastic model can never be silently mis-solved as deterministic.
+message SourceRef {
+  string name = 1;
+}
+
+// A reference to a declared structure (Program.structures), by name, exactly
+// as SourceRef names a source. It is legal only as the second argument of a
+// part operator (catalog tag struct_part): `item_at(3, tour)` is
+// Apply("item_at", [constant 3, StructRef "tour"]). A server that predates this
+// field rejects any Expression carrying it (an empty oneof).
+message StructRef {
+  string name = 1;
+}
+
+// A declared Param table read at positions given by expressions: one index for
+// a vector table, two for a matrix. Unlike ParamRef, whose index is a fixed
+// coordinate or a bound loop index, the index expressions here may involve
+// decisions, structure parts or random terms, so the entry is read when the
+// model is solved. The table must be dense on the integer keys 1..a (one
+// index) or 1..a by 1..b (two). An index value that is not an integer in range
+// is rounded to the nearest integer and clamped into range, and a NaN index
+// reads position 1.
+message TableRef {
+  string              param = 1;
+  repeated Expression index = 2;  // one or two
+}
+
 message ParamRef {
   string name  = 1;
   Index  index = 2;
@@ -142,6 +179,11 @@ enum Domain {
   CONTINUOUS         = 1;
   INTEGER            = 2;
   BINARY             = 3;
+  // The two domains with a hole: the value is 0 or lies in [lower, upper],
+  // never in between. Both bounds must be finite; when 0 lies inside them the
+  // hole is empty and the variable is an ordinary CONTINUOUS or INTEGER one.
+  SEMICONTINUOUS     = 4;  // 0, or any value in [lower, upper]
+  SEMIINTEGER        = 5;  // 0, or a whole number in [lower, upper]
 }
 
 // A per-variable bound: a scalar, or the name of a per-index Param table to look
@@ -196,6 +238,97 @@ message FixEntry {
   double value = 3;
 }
 
+// ---------------------------------------------------------------------------
+// Stochastic sources — named declarations, referenced by SourceRef
+//
+// The stochastic layer rides the SAME expression language: distribution heads
+// and scenario aggregators (smean, scvar, sfreq_*) are catalog operators, so
+// the distribution vocabulary can grow without changing this schema. What the
+// schema adds is declarations: a source is declared once under a name and
+// referenced by SourceRef leaves. The scenario count and seed are model data —
+// they pin the sampled instance, so two solves of the same bytes see the same
+// draws.
+// ---------------------------------------------------------------------------
+
+// A parametric source: a distribution head from the catalog (tag stoch_source)
+// with deterministic parameter expressions, e.g. normal(mu, sigma) where mu
+// may be a Param lookup. Parameters must not contain SourceRef or stochastic
+// heads.
+message Parametric {
+  string              head   = 1;
+  repeated Expression params = 2;
+}
+
+// An empirical source: a fixed scenario column of exactly Program.scenarios
+// values. Joint distributions are several columns drawn jointly client-side —
+// the scenario index is shared across all sources, so alignment preserves
+// correlation.
+message Empirical {
+  repeated double data = 1;  // packed; length == Program.scenarios
+}
+
+// One named source declaration.
+message SourceDecl {
+  string name = 1;
+  oneof kind {
+    Parametric parametric = 2;
+    Empirical  empirical  = 3;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Structured decision variables — named declarations, referenced by StructRef
+//
+// A structure is a decision variable with a shape every candidate solution
+// keeps. It is declared once under a name, like a source, and its parts are
+// read in expressions through catalog operators tagged struct_part applied to
+// a StructRef. Two kinds:
+//   permutation  n items over n slots: `item_at(slot, P)` is the item in a
+//                slot and `slot_of(item, P)` the slot of an item, both
+//                decision-valued integers in 1..n;
+//   partition    n items in k parts: `part_of(item, P)` is the part of an item
+//                (in 1..k) and `size_of(part, P)` the number of items in a
+//                part (in 0..n); a part may stay empty.
+// The kind is a catalog key (tag structure). Kinds that do not use a field
+// leave it empty; a field set on a kind that does not use it is refused.
+// ---------------------------------------------------------------------------
+
+// One precedence of a permutation: item `before` sits in an earlier slot than
+// item `after` in every arrangement considered.
+message Precedence {
+  uint64 before = 1;  // items, 1-based
+  uint64 after  = 2;
+}
+
+// One named structure declaration.
+message StructureDecl {
+  string            name    = 1;  // "tour"
+  string            kind    = 2;  // "permutation" | "partition"
+  uint64            size    = 3;  // n: items 1..n (a permutation: n >= 2,
+                                  // slots 1..n; a partition: n >= 1)
+  repeated int64    start   = 4;  // empty, or start[i] = where item i starts:
+                                  // its slot (a permutation of 1..n) or its
+                                  // part (in 1..k)
+  bool              fixed   = 5;  // pinned at `start`, which must then be full:
+                                  // how a solution is re-evaluated
+  repeated Precedence precede = 6;  // permutation only
+  uint64            parts   = 7;  // partition only: k >= 2, parts 1..k
+}
+
+// ---------------------------------------------------------------------------
+// Blocks — named groups of variables, one subproblem of the model each
+//
+// A block lists the variables of one subproblem (one customer's supply, one
+// project's staffing). It changes nothing about what the model means: the
+// same points are feasible and the objective is the same. A variable is in at
+// most one block, and a member needs finite bounds.
+// ---------------------------------------------------------------------------
+
+message BlockDecl {
+  string          name    = 1;
+  repeated VarRef members = 2;  // each a declared variable at a concrete index
+}
+
 // ---------------------------------------------------------------------------
 // Program — the structured authoring container (what crosses the wire)
 // ---------------------------------------------------------------------------
@@ -209,6 +342,27 @@ message Program {
   string              sense        = 6;  // "min" | "max"
   repeated Constraint constraints  = 7;
   repeated FixEntry   fix          = 8;
+
+  // Stochastic layer (absent ⇒ deterministic; a deterministic Program encodes
+  // identically with or without this schema). For the two scalars, proto3
+  // conflates 0 with absent, so 0 is not a legal value on the wire: both mean
+  // "server default" (scenarios 1, seed 1). A model whose MEANING depends on
+  // these fields necessarily contains a SourceRef or a stochastic operator, so
+  // an old server rejects it cleanly rather than mis-solving it; `scenarios`
+  // without stochastic terms is semantically inert and safe to skip.
+  uint64              scenarios     = 9;   // number of scenarios in the sampled instance
+  uint64              scenario_seed = 10;  // base-draw seed
+  repeated SourceDecl sources       = 11;  // canonical order: sorted by name
+
+  // Structured variables (absent ⇒ none; a Program without them encodes
+  // identically with or without this field). Canonical order: sorted by name.
+  // A model that uses one carries a StructRef, which an old server rejects, so
+  // it is never mis-solved as a plain model.
+  repeated StructureDecl structures = 12;
+
+  // Blocks (absent ⇒ none; a Program without them encodes identically with or
+  // without this field). Canonical order: sorted by name.
+  repeated BlockDecl  blocks        = 13;
 }
 
 // ---------------------------------------------------------------------------

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quicopt
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Tim Bode
@@ -23,8 +23,10 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
-description: Author an optimization model in a small native Ruby DSL, encode it to
-  the versioned Quicopt wire IR, and solve it on the Quicopt service.
+description: 'Describe an optimization problem in a small native Ruby DSL — the variables
+  you choose, the constraints that must hold, and the quantity to minimize or maximize
+  — and solve it on the Quicopt service. There is no local solver: the service does
+  the solving.'
 email:
 - 9047234+timbode@users.noreply.github.com
 executables: []
@@ -36,8 +38,10 @@ files:
 - README.md
 - lib/quicopt.rb
 - lib/quicopt/client.rb
+- lib/quicopt/indicators.rb
 - lib/quicopt/model.rb
 - lib/quicopt/modeler/v1/program_pb.rb
+- lib/quicopt/structured.rb
 - lib/quicopt/version.rb
 - lib/quicopt/wire.rb
 - proto/quicopt/modeler/v1/program.proto
@@ -45,11 +49,13 @@ files:
 - templates/default/fulldoc/html/css/quicopt-icon-color.svg
 - templates/default/fulldoc/html/css/quicopt-icon-white.svg
 - templates/default/fulldoc/html/setup.rb
-homepage: https://github.com/timbode/quicopt-ruby
+homepage: https://github.com/Quicopt/quicopt-ruby
 licenses:
 - Apache-2.0
 metadata:
-  source_code_uri: https://github.com/timbode/quicopt-ruby
+  source_code_uri: https://github.com/Quicopt/quicopt-ruby
+  documentation_uri: https://quicopt.github.io/quicopt-ruby/
+  bug_tracker_uri: https://github.com/Quicopt/quicopt-ruby/issues
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -67,6 +73,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: Ruby client for the Quicopt service — author models, emit the Quicopt wire
-  IR.
+summary: Ruby client for the Quicopt optimization service.
 test_files: []