korekto 1.0.210306

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 23a256a294cc625c6d701521f8ac80436501dbad3cfcaddc361418454a2aa5d3
+  data.tar.gz: ee6ed801ec1619b0c3c41946f3d1c1831181ab6f8bfbe798174ab3638e021d7b
+SHA512:
+  metadata.gz: ea659d6feef95bdb03e76e80dc974ba9a8b6288239525ff6bd141f53e7cdedde1432ab816e4831b35c4b7728ff1b14896ed10915a31badd2093e4b50dd33b1f3
+  data.tar.gz: d191041a84be4e648e4ebb18c376090e6a6ec5c375fe69dea7224532bad19a71d3c9e37db6c07d96243a3206545638bc72d9fb4359cb252ba7d825656aafe8c6

data/bin/korekto

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+require 'help_parser'
+
+OPTIONS = HelpParser['1.0.210306', <<HELP]
+Usage:
+  korekto [:options+]
+Options:
+ -h --help
+ -v --version
+ --install   \tInstalls the korekto neovim ruby plugin
+ --readme    \tOpen korekto github page
+# Example usage:
+#   cat MARKDOWN.md | korekto
+#   korekto < MARKDOWN.md
+HELP
+
+if OPTIONS.install?
+  require 'fileutils'
+  # pack
+  dest = File.expand_path '~/.local/share/nvim/site/pack/korekto'
+  FileUtils.mkdir_p dest
+  src = File.join File.dirname(__dir__), 'start'
+  FileUtils.cp_r src, dest
+  # rplugin
+  dest = File.expand_path '~/.config/nvim'
+  src = File.join File.dirname(__dir__), 'rplugin'
+  FileUtils.cp_r src, dest
+  system "nvim -c ':UpdateRemotePlugins|:quit' > /dev/null"
+  exit
+end
+if OPTIONS.readme?
+  Process.detach spawn('xdg-open', 'https://www.github.com/carlosjhr64/korekto')
+  exit
+end
+
+require 'korekto'
+Korekto.run

data/lib/korekto.rb

@@ -0,0 +1,15 @@
+module Korekto
+  VERSION = '1.0.210306'
+  class Error < Exception; end
+  require 'korekto/symbols'
+  require 'korekto/syntax'
+  require 'korekto/heap'
+  require 'korekto/statement'
+  require 'korekto/statements'
+  require 'korekto/main'
+  def Korekto.run = Korekto::Main.new.run
+end
+# Requires:
+# `ruby`
+# `nvim`
+# `xdg-open`

data/lib/korekto/heap.rb

@@ -0,0 +1,26 @@
+module Korekto
+class Heap
+  def initialize(limit)
+    @limit = limit
+    @combos = (0...limit).to_a.combination(2)
+      .sort{|ij, kl| ij[0]**2 + ij[1]**2 <=> kl[0]**2 + kl[1]**2}
+      .map{|i, j| [[i,j], [j,i]]}
+      .inject([]){|a, ij_kl| a<<ij_kl[0]; a<<ij_kl[1]}
+    @a = []
+  end
+
+  def add(s)
+    @a.unshift s
+    @a.pop if @a.length > @limit
+  end
+
+  def combos
+    @combos.each do |i,j|
+      next if [i,j].max >= @a.length
+      yield(@a[i], @a[j])
+    end
+  end
+
+  def each = @a.each{yield _1}
+end
+end

data/lib/korekto/main.rb

@@ -0,0 +1,141 @@
+module Korekto
+class Main
+  MD_STATEMENT_CODE_TITLE = %r{^(?<statement>.*)\s#(?<code>[A-Z](\d+(/[\w,.]+)?)?)( (?<title>\S.*?\S))?$}
+  MD_FILENAME = %r{^< (?<filename>[/\w\-.]+)$}
+  MD_KLASS_METHOD_DEFINITION = /^(?<klass>::[A-Z]\w+)#(?<method>\w+)(?<definition>[^=]*=.+)$/ # patch
+  MD_RULE = /^[?] (?<rule>\S.*)$/
+  MD_TYPE_PATTERN = %r{^! (?<type>\S+)\s*/(?<pattern>.*)/$}
+  MD_TYPE_VARIABLES = /^! (?<type>\S+)\s*\{(?<variables>\S+( \S+)*)\}$/
+  MD_KEY_VALUE = /^! (?<key>\w+):\s*'(?<value>.*)'$/
+
+  M_FENCE = /^```\s*$/
+  M_COMMENT_LINE = /^\s*#/
+
+  BACKUPS = {}
+
+  def initialize(filename='-', statements: Statements.new, imports: [])
+    @filename,@statements,@imports = filename,statements,imports
+    @imports.push @filename
+    @line,@active = nil,false
+    @m_fence_korekto = /^```korekto$/
+  end
+
+  def type_pattern(type, pattern)
+    t2p = @statements.symbols.t2p
+    raise Error, "type #{type} in use" if t2p.has_key? type
+    t2p[type] = pattern
+  end
+
+  def type_variables(type, variables)
+    v2t,t2p = @statements.symbols.v2t,@statements.symbols.t2p
+    pattern = t2p[type]
+    raise Error, "type #{type} not defined" unless pattern
+    variables.each do |variable|
+      raise Error, "variable #{variable} in use" if v2t.has_key? variable
+      v2t[variable] = type
+    end
+  end
+
+  def active?
+    case @line
+    when @m_fence_korekto
+      raise Error, 'unexpected fence' if @active
+      @active = true
+      false
+    when M_FENCE
+      @active = false
+      false
+    else
+      @active and not M_COMMENT_LINE.match?(@line)
+    end
+  end
+
+  def patch(klass, method, definition)
+    raise Error, "overrides: #{klass}##{method}" if eval(klass).method_defined? method
+    eval <<~EVAL
+      class #{klass}
+        def #{method}#{definition}
+      end
+    EVAL
+  end
+
+  def key_value(key, value)
+    case key
+    when 'scanner'
+      @statements.symbols.set_scanner value
+    when 'fence'
+      @m_fence_korekto = Regexp.new "^```#{value}$"
+    when 'save'
+      BACKUPS[value] = Marshal.dump(@statements)
+    when 'restore'
+      if backup = BACKUPS[value]
+        @statements = Marshal.load(backup)
+      else
+        raise Error, "nothing saved as '#{value}'"
+      end
+    else
+      raise Error, "key '#{key}' not implemented"
+    end
+  end
+
+  def preprocess?
+    case @line
+    when MD_FILENAME
+      filename = $~[:filename].strip
+      unless @imports.include? filename
+        Main.new(filename, statements:@statements, imports:@imports).run
+      end
+    when MD_KLASS_METHOD_DEFINITION
+      patch($~[:klass],$~[:method],$~[:definition])
+    when MD_RULE
+      @statements.syntax.push $~[:rule].strip
+    when MD_TYPE_PATTERN
+      type_pattern($~[:type], $~[:pattern])
+    when MD_TYPE_VARIABLES
+      type_variables($~[:type], $~[:variables].split)
+    when MD_KEY_VALUE
+      key_value($~[:key], $~[:value])
+    else
+      return false
+    end
+    true
+  end
+
+  def parse(lines)
+    statement_number = line_number = 0
+    while @line = lines.shift
+      begin
+        line_number += 1
+        next unless active?
+        next if preprocess?
+        if md = MD_STATEMENT_CODE_TITLE.match(@line)
+          statement_number += 1
+          code,title = @statements.add(md[:statement].strip,
+                                       md[:code],
+                                       md[:title],
+                                       @filename,
+                                       statement_number)
+          puts "#{@filename}:#{line_number}:#{code}:#{title}"
+        else
+          raise Error, 'unrecognized korekto line'
+        end
+      rescue Error
+        puts "#{@filename}:#{line_number}:!:#{$!.message}"
+        exit 65
+      rescue
+        puts "#{@filename}:#{line_number}:?:#{$!.message}"
+        $stderr.puts $!.backtrace
+        exit 1
+      end
+    end
+  end
+
+  def run
+    if @filename=='-'
+      parse $stdin.readlines(chomp: true)
+    else
+      parse IO.readlines(@filename, chomp: true)
+    end
+  end
+end
+end

data/lib/korekto/statement.rb

@@ -0,0 +1,196 @@
+module Korekto
+class Statement
+  attr_reader :code,:title,:regexp,:filename,:statement_number
+  def initialize(statement,code,title,filename,statement_number,context)
+    @statement,@code,@title,@statement_number,@context = statement,code,title,statement_number,context
+    @filename = File.basename(filename,'.*')
+    @statement.freeze; @filename.freeze; @statement_number.freeze
+    syntax_check
+    @regexp = nil
+    set_acceptance_code
+    @code.freeze; @title.freeze; @regexp.freeze
+  end
+
+  def type              = @code[0]
+  def to_s              = @statement
+  def to_str            = @statement
+  def match?(statement) = @regexp.match?(statement)
+  def scan(regex, &blk) = @statement.scan(regex, &blk)
+  def pattern?          = !@regexp.nil?
+  def literal_regexp?   = @statement[0]=='/' && @statement[-1]=='/'
+
+  private
+
+  def syntax_check
+    @context.syntax.each do |rule|
+      raise Error, "syntax: #{rule}" unless @statement.instance_eval(rule)
+    rescue # other than Korekto::Error < Exception
+      raise Error, "#{$!.class}: #{rule}"
+    end
+  end
+
+  def set_acceptance_code
+    case @code[0] # type
+    when 'P'
+      postulate
+    when 'D'
+      definition
+    when 'C'
+      conclusion
+    when 'X'
+      instantiation
+    when 'R'
+      result
+    when 'S'
+      set
+    when 'T'
+      tautology
+    when 'A', 'L'
+      # Axiom=>Tautoloty, Let=>Set,
+      pattern_type(0)
+    when 'M', 'E'
+      # Map=>Result, Existential=>Instantiation(X)
+      pattern_type(1)
+    when 'I'
+      # Inference=>Conclusion
+      pattern_type(2)
+    when 'W'
+      ['T','S','R','X','C'].any? do |code|
+        begin
+          @code[0]=code
+          set_acceptance_code
+          true
+        rescue Error
+          false
+        end
+      end or raise Error, 'did not match any statement pattern'
+    else
+      raise Error, "statement type #{@code[0]} not implemented"
+    end
+  end
+
+  # Common helper
+
+  def set_statement(support=nil, title=nil)
+    @code = "#{@code[0]}#{@statement_number}"
+    @code += "/#{support}" if support
+    @title = title.split(':',2).first if title
+  end
+
+  def support(*s)
+    support = []
+    s.each do |s|
+      c = s.code.split('/',2)[0]
+      c = s.filename+'.'+c unless s.filename=='-'
+      support.push(c)
+    end
+    return support.join(',')
+  end
+
+  # Pattern helpers
+
+  def newlines_count(n)
+    raise Error, "expected #{n} newlines" unless n==@regexp.inspect.gsub('\\\\','').scan('\\n').length
+  end
+
+  def set_regexp
+    @regexp = @context.symbols.s2r(@statement)
+  end
+
+  # Searches
+
+  def detect_statement(type)
+    statement = @context.type(type).detect do |statement|
+      statement.match? @statement
+    end
+    raise Error, "does not match any '#{type}' statement" unless statement
+    return statement
+  end
+
+  def heap_combos_search(type)
+    @context.heap.combos do |s1, s2|
+      compound = [s1,s2,@statement].join("\n")
+      @context.type(type).each do |inference|
+        return inference,s1,s2 if inference.match?(compound)
+      end
+    end
+    raise Error, "does not match any '#{type}' statement"
+  end
+
+  def heap_search(type)
+    @context.heap.each do |s1|
+      compound = [s1,@statement].join("\n")
+      @context.type(type).each do |s0|
+        return s0,s1 if s0.match?(compound)
+      end
+    end
+    raise Error, "does not match any '#{type}' statement"
+  end
+
+  # Defined/Undefined
+
+  def expected_instantiations(title=nil, n:nil)
+    undefined = @context.symbols.undefined(self)
+    if n ||= title&.match(/[1-9]\d*/)&.to_s&.to_i
+      raise Error, "expected #{n} undefined: #{undefined.join(' ')}" unless n==undefined.length
+    else
+      raise Error, 'nothing was undefined' if undefined.empty?
+    end
+  end
+
+  def undefined_in_pattern
+    @title = @title.split(':',2).first if @title
+    undefined = @context.symbols.undefined(self)
+    @title = "#{@title}: #{undefined.join(' ')}" unless undefined.empty?
+  end
+
+  # Statement type processing
+
+  def pattern_type(nl)
+    set_regexp
+    newlines_count(nl)
+    undefined_in_pattern
+    set_statement
+  end
+
+  def tautology
+    expected_instantiations(n:0)
+    axiom = detect_statement('A')
+    set_statement(support(axiom), axiom.title)
+  end
+
+  def set
+    let = detect_statement('L')
+    expected_instantiations(let.title)
+    set_statement(support(let), let.title)
+  end
+
+  def result
+    expected_instantiations(n:0)
+    mapping,s1 = heap_search('M')
+    set_statement(support(mapping,s1), mapping.title)
+  end
+
+  def instantiation
+    existential,s1 = heap_search('E')
+    expected_instantiations(existential.title)
+    set_statement(support(existential,s1), existential.title)
+  end
+
+  def conclusion
+    expected_instantiations(n:0)
+    inference,s1,s2 = heap_combos_search('I')
+    set_statement(support(inference,s1,s2), inference.title)
+  end
+
+  def definition
+    expected_instantiations(@title)
+    set_statement
+  end
+
+  def postulate
+    expected_instantiations(n:0)
+    set_statement
+  end
+end
+end

data/lib/korekto/statements.rb

@@ -0,0 +1,41 @@
+module Korekto
+class Statements
+  attr_reader :heap,:symbols,:syntax
+  def initialize
+    @statements = []
+    @heap = Heap.new(13)
+    @symbols = Symbols.new
+    @syntax = Syntax.new
+  end
+
+  def type(c) = @statements.select{_1.type==c}
+  def length = @statements.length
+
+  def add(statement,code,title,filename,statement_number)
+    c = code[0]; w = c=='W'
+    if restatement = @statements.detect{(w or _1.type==c) and _1.to_s==statement}
+      case restatement.type
+      when 'D','X','S','P','T','C','R'
+        @heap.add restatement
+      else
+        raise Error, "restatement: #{restatement.code}"
+      end
+      code,_ = restatement.code
+      title ||= restatement.title
+      return code, title
+    end
+    statement = Statement.new(statement,code,title,filename,statement_number,self)
+    @statements.push statement
+    case statement.type
+    when 'A','I','E','M','L'
+      @symbols.define! statement
+    when 'D','X','S'
+      @symbols.define! statement
+      @heap.add statement
+    when 'P','T','C','R'
+      @heap.add statement
+    end
+    return statement.code, statement.title
+  end
+end
+end

data/lib/korekto/symbols.rb

@@ -0,0 +1,65 @@
+module Korekto
+class Symbols
+  attr_reader :t2p, :v2t
+  def initialize
+    @h   = {}
+    @t2p = {}
+    @v2t = {}
+    @scanner = /:\w+|./
+  end
+
+  def set_scanner(value) = @scanner=Regexp.new(value)
+
+  def undefined(statement)
+    undefined = []
+    if statement.pattern?
+      unless statement.literal_regexp?
+        statement.scan(@scanner){|w| undefined.push(w) unless @v2t.include?(w) or @h.include?(w)}
+      end
+    else
+      statement.scan(@scanner){|w| undefined.push(w) unless @h.include?(w)}
+    end
+    return undefined.uniq
+  end
+
+  def define!(statement)
+    if statement.pattern?
+      unless statement.literal_regexp?
+        statement.scan(@scanner){|w| @h[w]=nil unless @v2t.include?(w) or @h.include?(w)}
+      end
+    else
+      statement.scan(@scanner){|w| @h[w]=nil unless @h.include?(w)}
+    end
+  end
+
+  def s2r(statement)
+    if statement[0]=='/' and statement[-1]=='/'
+      Regexp.new(statement[1..-2])
+    else
+      pattern,count,seen = '^',0,{}
+      Regexp.quote(statement).scan(@scanner) do |v|
+        if n=seen[v]
+          pattern << '\\'+n
+        elsif type = @v2t[v]
+          regex = @t2p[type]
+          if regex=='\n'
+            pattern << regex
+          else
+            count += 1
+            seen[v]=count.to_s
+            pattern << '('+regex+')'
+          end
+        else
+          # To avoid collisions with back-references,
+          # isolate digit in square brackets:
+          '0123456789'.include?(_=v[0]) and v[0]='['+_+']'
+          pattern << v
+        end
+      end
+      raise Error, 'pattern with no captures' if count < 1
+      pattern << '$'
+      Regexp.new(pattern)
+    end
+  end
+end
+end

data/lib/korekto/syntax.rb

@@ -0,0 +1,15 @@
+module Korekto
+class Syntax
+  def initialize = @a=[]
+  def each = @a.each{|s| yield s}
+
+  def push(s)
+    # ensure it'll eval on string and returns boolean
+    b = ''.instance_eval(s)
+    raise Error, 'syntax rule must eval boolean' unless b==!!b
+    @a.push(s)
+  rescue
+    raise Error, "#{$!.class}: #{s}"
+  end
+end
+end

data/rplugin/ruby/korekto.rb

@@ -0,0 +1,30 @@
+Neovim.plugin do |plug|
+  plug.command(:Korekto) do |nvim|
+    validations = nvim.command_output('w !korekto').strip.split("\n").map(&:strip)
+    msg = 'OK'
+    unless validations.empty?
+      buf = nvim.get_current_buf
+      while validation = validations.shift
+        fields = validation.split(':',4)
+        n = fields[1].to_i
+        if n > 0
+          fn,ln,code,title = fields
+          if code=='?' or code=='!'
+            # move onto error if on page
+            nvim.get_current_win.set_cursor([n,0]) if fn=='-'
+            # echo error message
+            msg = "#{fn}:#{ln}: #{title}"
+            # and stop.
+            break
+          elsif fn=='-'
+            line = buf[n].sub(/#.*$/,'').rstrip
+            line << "\t##{code}"
+            line << " #{title}" unless title==''
+            buf[n] = line unless line == buf[n]
+          end
+        end
+      end
+    end
+    nvim.command "echom #{msg.inspect}"
+  end
+end

data/start/korekto/ftdetect/korekto.vim

@@ -0,0 +1 @@
+autocmd BufRead,BufNewFile *.korekto set filetype=korekto

data/start/korekto/syntax/korekto.vim

@@ -0,0 +1,12 @@
+syntax match Comment /^\s*#.\+$/
+syntax match Pass    /\s#[A-Z][^#]*$/
+syntax match Syntax  /^[?] \w.\+$/
+syntax match Patch   /^::[A-Z]\w\+#\w\+[^=]\+=.\+$/
+syntax match Import  /^< [\/A-Za-z\_\-\.]\+$/
+highlight Comment ctermfg=darkblue
+highlight Pass    ctermfg=darkgreen
+highlight Syntax  ctermfg=darkmagenta
+highlight Patch   ctermfg=darkgrey
+highlight Import  ctermfg=darkyellow
+setlocal tabstop=23
+map <F7> :Korekto<CR>

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: korekto
+version: !ruby/object:Gem::Version
+  version: 1.0.210306
+platform: ruby
+authors:
+- carlosjhr64
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-03-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: help_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.200907
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.200907
+description: |
+  A general proof checker.
+
+  Works with neovim(nvim).
+email: carlosjhr64@gmail.com
+executables:
+- korekto
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/korekto
+- lib/korekto.rb
+- lib/korekto/heap.rb
+- lib/korekto/main.rb
+- lib/korekto/statement.rb
+- lib/korekto/statements.rb
+- lib/korekto/symbols.rb
+- lib/korekto/syntax.rb
+- rplugin/ruby/korekto.rb
+- start/korekto/ftdetect/korekto.vim
+- start/korekto/syntax/korekto.vim
+homepage: https://github.com/carlosjhr64/korekto
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- 'ruby: ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-linux]'
+- 'nvim: NVIM v0.4.4'
+- 'xdg-open: xdg-open 1.1.3+'
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: A general proof checker.
+test_files: []