specproof 0.1.0

data/lib/specproof/partition_space.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module SpecProof
+  # Enumerates bounded pairs over finite values and declared integer categories.
+  class PartitionSpace
+    MAX_ASSIGNMENTS = 10_000
+    MAX_PAIR_ROWS = 10_000
+    INVALID_CATEGORY = Object.new.freeze
+
+    attr_reader :pairs, :excluded_pairs, :allowed_count, :sources
+
+    def self.for_specification(specification, criterion: nil, validate_geometry: true)
+      group = specification.combination_group
+      has_integer_input = group&.inputs&.any? do |name|
+        specification.inputs[name]&.domain.is_a?(IntegerDomain)
+      end
+      has_partitions = group&.inputs&.any? { |name| specification.inputs[name]&.partitions&.any? }
+      use_partition_space = criterion == Planner::PARTITION_PAIRWISE_CRITERION ||
+                            (criterion != Planner::PAIRWISE_CRITERION && has_integer_input && has_partitions)
+      return new(specification, validate_geometry: validate_geometry) if use_partition_space
+
+      CombinationSpace.new(specification)
+    end
+
+    def initialize(specification, validate_geometry: true)
+      @specification = specification
+      @group = specification.combination_group
+      unless @group
+        raise ConfigurationError.new("target has no combinations declaration: #{specification.target}",
+                                     code: "combinations_required", source: specification.source)
+      end
+
+      validate_group
+      validate_partition_geometry if validate_geometry
+      check_limits
+      enumerate
+    end
+
+    def allowed?(arguments)
+      normalized = arguments.each_with_object({}) do |(name, value), values|
+        values[name.to_sym] = canonical_value(value)
+      end
+      categories = @group.inputs.to_h do |name|
+        value = normalized.fetch(name, INVALID_CATEGORY)
+        [name, value.equal?(INVALID_CATEGORY) ? INVALID_CATEGORY : category_value(name, value)]
+      end
+      return false if categories.values.any? { |value| value.equal?(INVALID_CATEGORY) }
+
+      restrictions_allow?(categories)
+    end
+
+    def allowed_assignments
+      @allowed_assignments ||= complete_assignments.select { |assignment| restrictions_allow?(assignment) }.freeze
+    end
+
+    private
+
+    def validate_group
+      if @group.inputs.length < 2
+        raise ConfigurationError.new("a combinations group requires at least two inputs",
+                                     code: "invalid_combination_inputs", source: @group.source)
+      end
+
+      @inputs = group_inputs.freeze
+      validate_forbidden_assignments
+      collect_sources
+    end
+
+    def validate_forbidden_assignments
+      @group.forbidden.each do |rule|
+        if rule.assignments.empty?
+          raise ConfigurationError.new("forbid requires at least one assignment",
+                                       code: "empty_forbidden_assignment", source: rule.source)
+        end
+        rule.assignments.each do |name, value|
+          input = @inputs[name]
+          unless input
+            raise ConfigurationError.new("forbidden assignment names non-group input #{name.inspect}",
+                                         code: "unknown_forbidden_input", source: rule.source)
+          end
+          if input.domain.is_a?(IntegerDomain)
+            unless value.is_a?(PartitionReference)
+              raise ConfigurationError.new("integer input #{name.inspect} restrictions must use in_partition(:name)",
+                                           code: "partition_selector_required", source: rule.source)
+            end
+            next if input.partitions.any? { |partition| partition.name == value.name }
+
+            raise ConfigurationError.new("unknown partition #{value.name.inspect} for #{name.inspect}",
+                                         code: "unknown_partition_reference", source: rule.source)
+          end
+
+          if value.is_a?(PartitionReference)
+            raise ConfigurationError.new("partition reference for #{name.inspect} requires an integer input",
+                                         code: "partition_reference_requires_integer_input", source: rule.source)
+          end
+          unless Domains.primitive?(value) && Domains.include?(input.domain, value)
+            raise ConfigurationError.new("forbidden value #{value.inspect} is outside #{name.inspect}'s finite domain",
+                                         code: "invalid_combination_value", source: rule.source)
+          end
+        end
+      end
+    end
+
+    def group_inputs
+      @group.inputs.to_h do |name|
+        input = @specification.inputs[name]
+        if @specification.exclusions.key?(name)
+          raise ConfigurationError.new("excluded input #{name.inspect} cannot be in a combinations group",
+                                       code: "excluded_combination_input", source: @group.source)
+        end
+        unless input
+          raise ConfigurationError.new("unknown combinations input #{name.inspect}",
+                                       code: "unknown_combination_input", source: @group.source)
+        end
+
+        if input.domain.is_a?(IntegerDomain)
+          validate_integer_input(input)
+        else
+          validate_finite_input(input)
+        end
+        [name, input]
+      end
+    end
+
+    def validate_integer_input(input)
+      if input.partitions.empty? || !input.exhaustive || !input.disjoint
+        raise ConfigurationError.new(
+          "integer input needs partitions with allow_gaps: false, allow_overlaps: false",
+          code: "partition_policy_required", source: input.source
+        )
+      end
+      return if input.partitions.all? { |partition| partition.domain.is_a?(IntegerDomain) }
+
+      raise ConfigurationError.new("integer input partitions must use integer ranges",
+                                   code: "partition_domain_kind", source: input.source)
+    end
+
+    def validate_finite_input(input)
+      return if input.partitions.empty?
+
+      raise ConfigurationError.new("finite combinations input #{input.name.inspect} cannot declare partitions",
+                                   code: "finite_partitions_unsupported", source: input.source)
+    end
+
+    def validate_partition_geometry
+      findings = Checker.new([@specification], check_combinations: false).findings
+      return if findings.empty?
+
+      raise InvalidSpecificationError, findings
+    end
+
+    def collect_sources
+      @sources = ([@group.source] + @inputs.values.flat_map(&:sources) +
+                  @inputs.values.flat_map { |input| input.partitions.map(&:source) } +
+                  @group.forbidden.map(&:source))
+                 .compact.uniq.sort_by { |source| [source.path, source.line, source.kind] }.freeze
+    end
+
+    def check_limits
+      assignment_count = @inputs.values.reduce(1) { |count, input| count * values_for(input).length }
+      raise limit_error("complete assignments", assignment_count) if assignment_count > MAX_ASSIGNMENTS
+
+      pair_rows = 0
+      @group.inputs.each_with_index do |left, index|
+        @group.inputs.drop(index + 1).each do |right|
+          pair_rows += values_for(@inputs.fetch(left)).length * values_for(@inputs.fetch(right)).length
+          raise limit_error("possible pair rows", pair_rows) if pair_rows > MAX_PAIR_ROWS
+        end
+      end
+    end
+
+    def limit_error(kind, count)
+      ConfigurationError.new("combinations declaration has #{count} #{kind}; limit is #{MAX_ASSIGNMENTS}",
+                             code: "combination_limit_exceeded", source: @group.source)
+    end
+
+    def enumerate
+      assignments = allowed_assignments
+      @allowed_count = assignments.length
+      pair_rows = {}
+      assignments.each do |assignment|
+        each_input_pair do |left, right|
+          row = { left => assignment.fetch(left), right => assignment.fetch(right) }.freeze
+          pair_rows[pair_key(row)] ||= row
+        end
+      end
+      @pairs = pair_rows.values.sort_by { |row| row_key(row) }.freeze
+      all_rows = []
+      each_input_pair do |left, right|
+        values_for(@inputs.fetch(left)).product(values_for(@inputs.fetch(right))).each do |left_value, right_value|
+          all_rows << { left => left_value, right => right_value }.freeze
+        end
+      end
+      feasible = pair_rows.keys.to_h { |key| [key, true] }
+      @excluded_pairs = all_rows.reject { |row| feasible.key?(pair_key(row)) }.sort_by { |row| row_key(row) }.freeze
+    end
+
+    def complete_assignments
+      return [] if @group.inputs.any? { |name| values_for(@inputs.fetch(name)).empty? }
+
+      @group.inputs.sort_by(&:to_s).reduce([{}]) do |rows, name|
+        rows.flat_map do |row|
+          values_for(@inputs.fetch(name)).map { |value| row.merge(name => value) }
+        end
+      end.map(&:freeze).freeze
+    end
+
+    def values_for(input)
+      if input.domain.is_a?(IntegerDomain)
+        input.partitions.map do |partition|
+          PartitionLevel.new(name: partition.name, lower: partition.domain.lower, upper: partition.domain.upper)
+        end.sort_by(&:sort_key)
+      else
+        input.domain.values
+      end
+    end
+
+    def category_value(name, value)
+      input = @inputs.fetch(name)
+      if input.domain.is_a?(IntegerDomain)
+        return INVALID_CATEGORY unless value.instance_of?(Integer) && input.domain.include?(value)
+
+        matching = input.partitions.select { |partition| partition.domain.include?(value) }
+        return INVALID_CATEGORY unless matching.length == 1
+
+        partition = matching.first
+        PartitionLevel.new(name: partition.name, lower: partition.domain.lower, upper: partition.domain.upper)
+      else
+        Domains.include?(input.domain, value) ? value : INVALID_CATEGORY
+      end
+    end
+
+    def restrictions_allow?(assignment)
+      @group.forbidden.none? do |rule|
+        rule.assignments.all? do |name, value|
+          assigned = assignment[name]
+          if value.is_a?(PartitionReference)
+            assigned.is_a?(PartitionLevel) && assigned.name == value.name
+          else
+            assigned.instance_of?(value.class) && assigned.eql?(value)
+          end
+        end
+      end
+    end
+
+    def each_input_pair
+      @group.inputs.each_with_index do |left, index|
+        @group.inputs.drop(index + 1).each { |right| yield left, right }
+      end
+    end
+
+    def pair_key(row)
+      row.map { |name, value| [name.to_s, Report.value(value)] }
+    end
+
+    def row_key(row)
+      row.flat_map { |name, value| [name.to_s, sort_key(value)] }
+    end
+
+    def sort_key(value)
+      value.is_a?(PartitionLevel) ? value.sort_key : Domains.sort_key(value)
+    end
+
+    def canonical_value(value)
+      Domains.supported_string?(value) ? Domains.canonical_string(value) : value
+    end
+  end
+end

data/lib/specproof/planner.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+
+module SpecProof
+  # Builds deterministic input candidates from valid specifications.
+  class Planner
+    CRITERION = "input-basics-v1"
+    PAIRWISE_CRITERION = "pairwise-finite-v1"
+    PARTITION_PAIRWISE_CRITERION = "pairwise-partitions-v1"
+
+    def initialize(specifications, criterion: CRITERION)
+      unless [CRITERION, PAIRWISE_CRITERION, PARTITION_PAIRWISE_CRITERION].include?(criterion)
+        raise ConfigurationError.new("unsupported criterion #{criterion.inspect}", code: "unknown_criterion")
+      end
+
+      @specifications = specifications
+      @criterion = criterion
+    end
+
+    def obligations
+      findings = Checker.new(@specifications, criterion: @criterion).findings
+      raise InvalidSpecificationError, findings unless findings.empty?
+
+      return pair_obligations if [PAIRWISE_CRITERION, PARTITION_PAIRWISE_CRITERION].include?(@criterion)
+
+      candidates = {}
+      @specifications.each do |specification|
+        specification.inputs.each_value do |input|
+          input_candidates(specification, input).each do |value, reason, source|
+            key = [specification.target, input.name, value]
+            candidate = (candidates[key] ||= { reasons: [], sources: [] })
+            candidate[:reasons] << reason
+            if source.is_a?(Array)
+              candidate[:sources].concat(source)
+            else
+              candidate[:sources] << source
+            end
+          end
+        end
+      end
+      obligations = candidates.map do |(target, input, value), details|
+        id = Digest::SHA256.hexdigest(JSON.generate([target, input.to_s, Report.value(value), @criterion]))
+        Obligation.new(id: id, target: target, input: input, value: value,
+                       reasons: details[:reasons], sources: details[:sources])
+      end
+      obligations.sort_by do |obligation|
+        [obligation.target, obligation.input.to_s, Domains.sort_key(obligation.value)]
+      end.freeze
+    end
+
+    private
+
+    def pair_obligations
+      spaces = []
+      count = 0
+      @specifications.each do |specification|
+        space = pairwise_space(specification)
+        next_count = count + space.pairs.length
+        if next_count > CombinationSpace::MAX_PAIR_ROWS
+          raise ConfigurationError.new("pairwise plan has #{next_count} pair obligations; limit is 10000",
+                                       code: "combination_limit_exceeded", source: space.sources.first)
+        end
+
+        count = next_count
+        spaces << [specification, space]
+      end
+
+      obligations = spaces.flat_map do |specification, space|
+        space.pairs.map do |inputs|
+          canonical_inputs = inputs.sort_by { |name, _value| name.to_s }.to_h
+          id_data = canonical_inputs.map { |name, value| [name.to_s, Report.value(value)] }
+          id = Digest::SHA256.hexdigest(JSON.generate([specification.target, id_data, @criterion]))
+          PairObligation.new(id: id, target: specification.target, inputs: canonical_inputs,
+                             reasons: ["feasible input pair"], sources: space.sources)
+        end
+      end
+      obligations.sort_by do |obligation|
+        [obligation.target, obligation.inputs.keys.map(&:to_s),
+         obligation.inputs.values.map { |value| sort_key(value) }]
+      end.freeze
+    end
+
+    def pairwise_space(specification)
+      if @criterion == PARTITION_PAIRWISE_CRITERION
+        PartitionSpace.new(specification)
+      else
+        CombinationSpace.new(specification)
+      end
+    end
+
+    def sort_key(value)
+      value.is_a?(PartitionLevel) ? value.sort_key : Domains.sort_key(value)
+    end
+
+    def input_candidates(_specification, input)
+      domain = input.domain
+      if domain.is_a?(IntegerDomain)
+        base_integer_candidates(domain).map do |value, reason|
+          [value, reason, input.sources]
+        end + input.partitions.flat_map { |partition| partition_candidates(partition) }
+      else
+        domain.values.map { |value| [value, "finite input value", input.sources] }
+      end
+    end
+
+    def base_integer_candidates(domain)
+      return [] if Domains.empty?(domain)
+
+      # These are candidate tuples, so filter by the value's domain membership.
+      [[domain.lower, "input lower endpoint"], [domain.lower + 1, "input lower neighbor"],
+       [domain.upper - 1, "input upper neighbor"], [domain.upper, "input upper endpoint"]]
+        .select { |value, _reason| domain.include?(value) } # rubocop:disable Style/HashSlice
+    end
+
+    def partition_candidates(partition)
+      domain = partition.domain
+      return [] unless domain.is_a?(IntegerDomain) && !Domains.empty?(domain)
+
+      [[domain.lower, "#{partition.name} lower endpoint"], [domain.upper, "#{partition.name} upper endpoint"]]
+        .map { |value, reason| [value, reason, partition.source] }
+    end
+  end
+end

data/lib/specproof/report.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+
+module SpecProof
+  # Builds stable machine and human report representations.
+  module Report
+    module_function
+
+    # Renders primitive and partition pair obligations for human plans.
+    module PairwisePlanRows
+      module_function
+
+      def render(obligations, criterion:)
+        grouped_rows = obligations.group_by { |item| [item.target, item.inputs.keys.map(&:to_s)] }
+        grouped_rows.map do |(target, names), items|
+          lines = ["#{target} / #{names.join(" × ")}", "Criterion: #{criterion}", "Pair obligations: #{items.length}"]
+          items.each do |item|
+            values = item.inputs.map { |name, item_value| "#{name}=#{Report.human_value(item_value)}" }.join(", ")
+            locations = item.sources.map { |item_source| "#{item_source.path}:#{item_source.line}" }.join(", ")
+            lines << "#{values}: #{item.reasons.join("; ")}\n    #{locations}"
+          end
+          lines.join("\n")
+        end
+        .join("\n\n")
+      end
+    end
+
+    def value(value)
+      case value
+      when PartitionLevel then { kind: "partition", name: value.name.to_s, lower: value.lower.to_s,
+                                 upper: value.upper.to_s }
+      when PartitionReference then { kind: "partition_reference", name: value.name.to_s }
+      when NilClass then { kind: "nil", value: nil }
+      when TrueClass, FalseClass then { kind: "boolean", value: value }
+      when Integer then { kind: "integer", value: value.to_s }
+      when Symbol then { kind: "symbol", value: value.to_s }
+      when String
+        raise ArgumentError, "unsupported report value String" unless Domains.supported_string?(value)
+
+        { kind: "string", value: Domains.canonical_string(value) }
+      else
+        raise ArgumentError, "unsupported report value #{value.class}"
+      end
+    end
+
+    def source(source)
+      { path: source.path, line: source.line, kind: source.kind }
+    end
+
+    def obligation(obligation)
+      if obligation.respond_to?(:inputs) && obligation.inputs
+        return { id: obligation.id, target: obligation.target,
+                 inputs: obligation.inputs.to_h { |name, item| [name.to_s, value(item)] },
+                 reasons: obligation.reasons, sources: obligation.sources.map { |item| source(item) } }
+      end
+
+      { id: obligation.id, target: obligation.target, input: obligation.input.to_s,
+        value: value(obligation.value), reasons: obligation.reasons,
+        sources: obligation.sources.map { |item| source(item) } }
+    end
+
+    def digest(specifications)
+      declarations = specifications.flat_map do |specification|
+        specification.inputs.values.map do |input|
+          partitions = input.partitions.map do |partition|
+            { name: partition.name.to_s, domain: normalized_domain(partition.domain) }
+          end
+          partitions = partitions.sort_by { |partition| partition[:name] }
+          { target: specification.target, input: input.name.to_s, domain: normalized_domain(input.domain),
+            exhaustive: input.exhaustive, disjoint: input.disjoint,
+            partitions: partitions }
+        end
+      end
+      declarations = declarations.sort_by { |entry| [entry[:target], entry[:input]] }
+      exclusions = specifications.flat_map do |specification|
+        names = specification.exclusions.keys.sort_by(&:to_s).map(&:to_s)
+        names.empty? ? [] : [{ target: specification.target, excluded_inputs: names }]
+      end
+      exclusions.sort_by! { |entry| [entry[:target], entry[:excluded_inputs]] }
+      declarations.concat(exclusions)
+      declarations.concat(group_declarations(specifications))
+      Digest::SHA256.hexdigest(JSON.generate(declarations))
+    end
+
+    def group_declarations(specifications)
+      groups = specifications.filter_map do |specification|
+        group = specification.respond_to?(:combination_group) && specification.combination_group
+        next unless group
+
+        forbidden = group.forbidden.map { |rule| canonical_assignments(rule) }
+        forbidden.uniq!
+        forbidden.sort_by! { |assignments| JSON.generate(assignments) }
+        { target: specification.target, combination_group: group.inputs.map(&:to_s), forbidden: forbidden }
+      end
+      groups.sort_by { |entry| entry[:target] }
+    end
+
+    def canonical_assignments(rule)
+      rule.assignments.sort_by { |name, _item| name.to_s }
+          .map { |name, item| [name.to_s, value(item)] }
+    end
+
+    def input_scope(specifications)
+      {
+        completeness_scope: "analyzed_inputs",
+        input_scope: specifications.sort_by(&:target).map do |specification|
+          scope = {
+            target: specification.target,
+            analyzed_inputs: specification.inputs.keys.sort_by(&:to_s).map(&:to_s),
+            excluded_inputs: specification.exclusions.values.sort_by { |item| item.name.to_s }.map do |item|
+              { name: item.name.to_s, reason: item.reason, source: source(item.source) }
+            end
+          }
+          group = specification.respond_to?(:combination_group) && specification.combination_group
+          scope[:combination_group] = { inputs: group.inputs.map(&:to_s) } if group
+          scope
+        end
+      }
+    end
+
+    def check(specifications:, findings:, errors: [])
+      envelope(kind: "check", errors: errors).merge(
+        contract_digest: digest(specifications),
+        scope: input_scope(specifications),
+        findings: findings.map { |finding| finding_hash(finding) }
+      )
+    end
+
+    def plan(specifications:, obligations:, criterion: "input-basics-v1", errors: [])
+      result = envelope(kind: "plan", errors: errors).merge(
+        contract_digest: digest(specifications), criterion: criterion,
+        scope: input_scope(specifications),
+        obligations: obligations.map { |item| obligation(item) }
+      )
+      if %w[pairwise-finite-v1 pairwise-partitions-v1].include?(criterion)
+        result[:excluded_pairs] = specifications.flat_map do |specification|
+          next [] unless specification.respond_to?(:combination_group) && specification.combination_group
+
+          space = PartitionSpace.for_specification(specification, criterion: criterion)
+          space.excluded_pairs.map do |inputs|
+            { target: specification.target,
+              inputs: inputs.to_h { |name, item| [name.to_s, value(item)] },
+              reason: "no_allowed_completion", sources: space.sources.map { |item| source(item) } }
+          end
+        end
+      end
+      result
+    end
+
+    def envelope(kind:, errors: [])
+      { schema_version: 1, specproof_version: VERSION, kind: kind, errors: errors }
+    end
+
+    def finding_hash(finding)
+      if finding.respond_to?(:inputs) && finding.inputs
+        return { code: finding.code.to_s, target: finding.target,
+                 inputs: finding.inputs.map(&:to_s), witness: [],
+                 sources: finding.sources.map { |item| source(item) } }
+      end
+
+      { code: finding.code.to_s, target: finding.target, input: finding.input.to_s,
+        witness: if finding.witness.is_a?(Array)
+                   finding.witness.map do |item|
+                     witness_value(item)
+                   end
+                 else
+                   witness_value(finding.witness)
+                 end,
+        sources: finding.sources.map { |item| source(item) } }
+    end
+
+    def finding(finding)
+      if finding.respond_to?(:inputs) && finding.inputs
+        names = finding.inputs.join(", ")
+        return "#{finding.code} #{finding.target} / #{names} (#{finding.sources.map do |item|
+          "#{item.path}:#{item.line}"
+        end.join(", ")})"
+      end
+
+      "#{finding.code} #{finding.target} / #{finding.input}: #{finding.witness.inspect} (#{finding.sources.map do |item|
+        "#{item.path}:#{item.line}"
+      end.join(", ")})"
+    end
+
+    def human_scope(specifications)
+      lines = ["Completeness scope: analyzed inputs only"]
+      specifications.sort_by(&:target).each do |specification|
+        group = specification.respond_to?(:combination_group) && specification.combination_group
+        lines << "Pairwise group for #{specification.target}: #{group.inputs.join(", ")}" if group
+        exclusions = specification.exclusions.values.sort_by { |item| item.name.to_s }
+        next if exclusions.empty?
+
+        details = exclusions.map { |item| "#{item.name} (#{item.reason})" }.join(", ")
+        lines << "Excluded for #{specification.target}: #{details}"
+      end
+      lines.join("\n")
+    end
+
+    def human_plan(obligations, criterion: "input-basics-v1", specifications: [])
+      return human_pairwise_plan(obligations, specifications, criterion: criterion) if
+        %w[pairwise-finite-v1 pairwise-partitions-v1].include?(criterion)
+
+      rows = obligations.group_by { |item| [item.target, item.input] }.map do |(target, input), items|
+        values = items.map { |item| human_value(item.value) }.join(", ")
+        ["#{target} / #{input}", "Criterion: #{criterion}", "Candidates: #{values}"]
+          .concat(items.map do |item|
+            locations = item.sources.map { |item_source| "#{item_source.path}:#{item_source.line}" }.join(", ")
+            "#{human_value(item.value)}: #{item.reasons.join("; ")}\n    #{locations}"
+          end).join("\n")
+      end.join("\n\n")
+      [rows, human_scope(specifications)].reject(&:empty?).join("\n\n")
+    end
+
+    def human_pairwise_plan(obligations, specifications, criterion:)
+      rows = PairwisePlanRows.render(obligations, criterion: criterion)
+      excluded_count = specifications.sum do |specification|
+        next 0 unless specification.respond_to?(:combination_group) && specification.combination_group
+
+        space = PartitionSpace.for_specification(specification, criterion: criterion)
+        space.excluded_pairs.length
+      end
+      rows = "Total pair obligations: #{obligations.length}\n\n#{rows}\n\nExcluded pairs: #{excluded_count}"
+      [rows, human_scope(specifications)].reject(&:empty?).join("\n\n")
+    end
+
+    def human_value(value)
+      return "#{value.name}[#{value.lower}..#{value.upper}]" if value.is_a?(PartitionLevel)
+      return ":#{value}" if value.is_a?(Symbol)
+      return Domains.canonical_string(value).inspect if Domains.supported_string?(value)
+
+      value.inspect
+    end
+
+    def normalized_domain(domain)
+      if domain.is_a?(IntegerDomain)
+        { kind: "integer", lower: domain.lower.to_s, upper: domain.upper.to_s }
+      else
+        { kind: "finite", values: domain.values.map { |value| value(value) } }
+      end
+    end
+
+    def witness_value(value)
+      value(value)
+    end
+  end
+end