Upload 96 files

ag4masses/alphageometry/alphageometry.py

@@ -0,0 +1,755 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Run DD+AR or AlphaGeometry solver.
+
+Please refer to README.md for detailed instructions.
+"""
+
+import time
+import traceback
+
+from absl import app
+from absl import flags
+from absl import logging
+import ddar
+import graph as gh
+import lm_inference as lm
+import pretty as pt
+import problem as pr
+
+#=============
+import sys, os, math, re
+import multiprocessing
+import warnings
+warnings.filterwarnings("ignore")
+model = None # global variable used in multi-processing workers
+
+_GIN_SEARCH_PATHS = flags.DEFINE_list(
+    'gin_search_paths',
+    ['third_party/py/meliad/transformer/configs'],
+    'List of paths where the Gin config files are located.',
+)
+_GIN_FILE = flags.DEFINE_multi_string(
+    'gin_file', ['base_htrans.gin'], 'List of Gin config files.'
+)
+_GIN_PARAM = flags.DEFINE_multi_string(
+    'gin_param', None, 'Newline separated list of Gin parameter bindings.'
+)
+
+_PROBLEMS_FILE = flags.DEFINE_string(
+    'problems_file',
+    'imo_ag_30.txt',
+    'text file contains the problem strings. See imo_ag_30.txt for example.',
+)
+_PROBLEM_NAME = flags.DEFINE_string(
+    'problem_name',
+    'imo_2000_p1',
+    'name of the problem to solve, must be in the problem_file.',
+)
+_MODE = flags.DEFINE_string(
+    'mode', 'ddar', 'either `ddar` (DD+AR) or `alphageometry`')
+_DEFS_FILE = flags.DEFINE_string(
+    'defs_file',
+    'defs.txt',
+    'definitions of available constructions to state a problem.',
+)
+_RULES_FILE = flags.DEFINE_string(
+    'rules_file', 'rules.txt', 'list of deduction rules used by DD.'
+)
+_CKPT_PATH = flags.DEFINE_string('ckpt_path', '', 'checkpoint of the LM model.')
+_VOCAB_PATH = flags.DEFINE_string(
+    'vocab_path', '', 'path to the LM vocab file.'
+)
+_OUT_FILE = flags.DEFINE_string(
+    'out_file', '', 'path to the solution output file.'
+)  # pylint: disable=line-too-long
+_BEAM_SIZE = flags.DEFINE_integer(
+    'beam_size', 1, 'beam size of the proof search.'
+)  # pylint: disable=line-too-long
+_SEARCH_DEPTH = flags.DEFINE_integer(
+    'search_depth', 1, 'search depth of the proof search.'
+)  # pylint: disable=line-too-long
+
+#===================================
+_N_WORKSERS = flags.DEFINE_integer(
+    'n_workers', 1, 'number of workers'
+)# pylint: disable=line-too-long
+
+DEFINITIONS = None  # contains definitions of construction actions
+RULES = None  # contains rules of deductions
+
+
+def natural_language_statement(logical_statement: pr.Dependency) -> str:
+  """Convert logical_statement to natural language.
+
+  Args:
+    logical_statement: pr.Dependency with .name and .args
+
+  Returns:
+    a string of (pseudo) natural language of the predicate for human reader.
+  """
+  names = [a.name.upper() for a in logical_statement.args]
+  names = [(n[0] + '_' + n[1:]) if len(n) > 1 else n for n in names]
+  return pt.pretty_nl(logical_statement.name, names)
+
+
+def proof_step_string(
+    proof_step: pr.Dependency, refs: dict[tuple[str, ...], int], last_step: bool
+) -> str:
+  """Translate proof to natural language.
+
+  Args:
+    proof_step: pr.Dependency with .name and .args
+    refs: dict(hash: int) to keep track of derived predicates
+    last_step: boolean to keep track whether this is the last step.
+
+  Returns:
+    a string of (pseudo) natural language of the proof step for human reader.
+  """
+  premises, [conclusion] = proof_step
+
+  premises_nl = ' & '.join(
+      [
+          natural_language_statement(p) + ' [{:02}]'.format(refs[p.hashed()])
+          for p in premises
+      ]
+  )
+
+  if not premises:
+    premises_nl = 'similarly'
+
+  refs[conclusion.hashed()] = len(refs)
+
+  conclusion_nl = natural_language_statement(conclusion)
+  if not last_step:
+    conclusion_nl += ' [{:02}]'.format(refs[conclusion.hashed()])
+
+  return f'{premises_nl} \u21d2 {conclusion_nl}'
+
+
+def write_solution(g: gh.Graph, p: pr.Problem, out_file: str) -> None:
+  """Output the solution to out_file.
+
+  Args:
+    g: gh.Graph object, containing the proof state.
+    p: pr.Problem object, containing the theorem.
+    out_file: file to write to, empty string to skip writing to file.
+  """
+  setup, aux, proof_steps, refs = ddar.get_proof_steps(
+      g, p.goal, merge_trivials=False
+  )
+
+  solution = ''
+  solution += 'Theo đề bài ta có:\n'
+  premises_nl = []
+  for premises, [points] in setup:
+    solution += ' '.join([p.name.upper() for p in points]) + ' '
+    if not premises:
+      continue
+    premises_nl += [
+        natural_language_statement(p) + ' [{:02}]'.format(refs[p.hashed()])
+        for p in premises
+    ]
+  solution += ': Points\n' + '\n'.join(premises_nl)
+
+  solution += '\n\nCác điểm cần dựng thêm:\n'
+  aux_premises_nl = []
+  if len(aux) == 0:
+    solution += 'Không cần dựng thêm điểm nào.'
+  else:
+    for premises, [points] in aux:
+      solution += ' '.join([p.name.upper() for p in points]) + ' '
+      aux_premises_nl += [
+          natural_language_statement(p) + ' [{:02}]'.format(refs[p.hashed()])
+          for p in premises
+      ]
+    solution += ': Points\n' + '\n'.join(aux_premises_nl)
+
+  # some special case where the deduction rule has a well known name.
+  r2name = {
+      'r32': '(SSS)',
+      'r33': '(SAS)',
+      'r34': '(Similar Triangles)',
+      'r35': '(Similar Triangles)',
+      'r36': '(ASA)',
+      'r37': '(ASA)',
+      'r38': '(Similar Triangles)',
+      'r39': '(Similar Triangles)',
+      'r40': '(Congruent Triangles)',
+      'a00': '(Distance chase)',
+      'a01': '(Ratio chase)',
+      'a02': '(Angle chase)',
+  }
+
+  solution += '\n\nCác bước chứng minh:\n'
+  for i, step in enumerate(proof_steps):
+    _, [con] = step
+    nl = proof_step_string(step, refs, last_step=i == len(proof_steps) - 1)
+    rule_name = r2name.get(con.rule_name, '')
+    nl = nl.replace('\u21d2', f'{rule_name}\u21d2 ')
+    solution += '{:03}. '.format(i + 1) + nl + '\n'
+  logging.info(solution)
+  if out_file:
+    with open(out_file, 'w') as f:
+      f.write(solution)
+    logging.info('Solution written to %s.', out_file)
+
+def get_lm(ckpt_init: str, vocab_path: str) -> lm.LanguageModelInference:
+  lm.parse_gin_configuration(
+      _GIN_FILE.value, _GIN_PARAM.value, gin_paths=_GIN_SEARCH_PATHS.value
+  )
+
+  return lm.LanguageModelInference(vocab_path, ckpt_init, mode='beam_search')
+
+
+def run_ddar(g: gh.Graph, p: pr.Problem, out_file: str) -> bool:
+  """Run DD+AR.
+
+  Args:
+    g: gh.Graph object, containing the proof state.
+    p: pr.Problem object, containing the problem statement.
+    out_file: path to output file if solution is found.
+
+  Returns:
+    Boolean, whether DD+AR finishes successfully.
+  """
+  ddar.solve(g, RULES, p, max_level=1000)
+
+  goal_args = g.names2nodes(p.goal.args)
+  if not g.check(p.goal.name, goal_args):
+    logging.info('DD+AR failed to solve the problem.')
+    return False
+
+  write_solution(g, p, out_file)
+
+  gh.nm.draw(
+      g.type2nodes[gh.Point],
+      g.type2nodes[gh.Line],
+      g.type2nodes[gh.Circle],
+      g.type2nodes[gh.Segment],
+      save_to="ag4mout/output.png",)
+  return True
+
+
+def translate_constrained_to_constructive(
+    point: str, name: str, args: list[str]
+) -> tuple[str, list[str]]:
+  """Translate a predicate from constraint-based to construction-based.
+
+  Args:
+    point: str: name of the new point
+    name: str: name of the predicate, e.g., perp, para, etc.
+    args: list[str]: list of predicate args.
+
+  Returns:
+    (name, args): translated to constructive predicate.
+  """
+  if name in ['T', 'perp']:
+    a, b, c, d = args
+    if point in [c, d]:
+      a, b, c, d = c, d, a, b
+    if point == b:
+      a, b = b, a
+    if point == d:
+      c, d = d, c
+    if a == c and a == point:
+      return 'on_dia', [a, b, d]
+    return 'on_tline', [a, b, c, d]
+
+  elif name in ['P', 'para']:
+    a, b, c, d = args
+    if point in [c, d]:
+      a, b, c, d = c, d, a, b
+    if point == b:
+      a, b = b, a
+    return 'on_pline', [a, b, c, d]
+
+  elif name in ['D', 'cong']:
+    a, b, c, d = args
+    if point in [c, d]:
+      a, b, c, d = c, d, a, b
+    if point == b:
+      a, b = b, a
+    if point == d:
+      c, d = d, c
+    if a == c and a == point:
+      return 'on_bline', [a, b, d]
+    if b in [c, d]:
+      if b == d:
+        c, d = d, c  # pylint: disable=unused-variable
+      return 'on_circle', [a, b, d]
+    return 'eqdistance', [a, b, c, d]
+
+  elif name in ['C', 'coll']:
+    a, b, c = args
+    if point == b:
+      a, b = b, a
+    if point == c:
+      a, b, c = c, a, b
+    return 'on_line', [a, b, c]
+
+  elif name in ['^', 'eqangle']:
+    a, b, c, d, e, f = args
+
+    if point in [d, e, f]:
+      a, b, c, d, e, f = d, e, f, a, b, c
+
+    x, b, y, c, d = b, c, e, d, f
+    if point == b:
+      a, b, c, d = b, a, d, c
+
+    if point == d and x == y:  # x p x b = x c x p
+      return 'angle_bisector', [point, b, x, c]
+
+    if point == x:
+      return 'eqangle3', [x, a, b, y, c, d]
+
+    return 'on_aline', [a, x, b, c, y, d]
+
+  elif name in ['cyclic', 'O']:
+    a, b, c = [x for x in args if x != point]
+    return 'on_circum', [point, a, b, c]
+
+  return name, args
+
+
+def check_valid_args(name: str, args: list[str]) -> bool:
+  """Check whether a predicate is grammarically correct.
+
+  Args:
+    name: str: name of the predicate
+    args: list[str]: args of the predicate
+
+  Returns:
+    bool: whether the predicate arg count is valid.
+  """
+  if name == 'perp':
+    if len(args) != 4:
+      return False
+    a, b, c, d = args
+    if len({a, b}) < 2:
+      return False
+    if len({c, d}) < 2:
+      return False
+  elif name == 'para':
+    if len(args) != 4:
+      return False
+    a, b, c, d = args
+    if len({a, b, c, d}) < 4:
+      return False
+  elif name == 'cong':
+    if len(args) != 4:
+      return False
+    a, b, c, d = args
+    if len({a, b}) < 2:
+      return False
+    if len({c, d}) < 2:
+      return False
+  elif name == 'coll':
+    if len(args) != 3:
+      return False
+    a, b, c = args
+    if len({a, b, c}) < 3:
+      return False
+  elif name == 'cyclic':
+    if len(args) != 4:
+      return False
+    a, b, c, d = args
+    if len({a, b, c, d}) < 4:
+      return False
+  elif name == 'eqangle':
+    if len(args) != 8:
+      return False
+    a, b, c, d, e, f, g, h = args
+    if len({a, b, c, d}) < 3:
+      return False
+    if len({e, f, g, h}) < 3:
+      return False
+  return True
+
+
+def try_translate_constrained_to_construct(string: str, g: gh.Graph) -> str:
+  """Whether a string of aux construction can be constructed.
+
+  Args:
+    string: str: the string describing aux construction.
+    g: gh.Graph: the current proof state.
+
+  Returns:
+    str: whether this construction is valid. If not, starts with "ERROR:".
+  """
+  if string[-1] != ';':
+    return 'ERROR: must end with ;'
+
+  logging.info(f'PID={os.getpid()}: !! try_translate_constrained_to_construct: string=%s', string)
+
+  # sometimes the LM may return ill-formed result with multiple colons.
+  # example:
+  #
+  # napoleon2
+  # a1 a2 a3 = triangle; c3 = s_angle a1 a2 c3 30, s_angle a2 a1 c3 150; c1 = s_angle a2 a3 c1 30, s_angle a3 a2 c1 150; c2 = s_angle a3 a1 c2 30, s_angle a1 a3 c2 150 ? cong c1 c2 c1 c3
+  #
+  # in the process, 
+  # I0210 17:58:01.513668 140016515833856 alphageometry.py:550] Decoding from {S} a : ; b : ; c : ; d : ^ a d a b 5. pi / 6. 00 ^ b d b a 1. pi / 6. 01 ; e : ^ b e b c 5. pi / 6. 02 ^ c e c b 1. pi / 6. 03 ; f : ^ a f a c 1. pi / 6. 04 ^ c f c a 5. pi / 6. 05 ? D e f e d {F1} x00 g : C a b g 06 D a g b g 07 ; x00 h : C c b h 08 D c h b h 09 ; x00
+  # I0210 18:01:38.182158 140016515833856 alphageometry.py:384] !! try_translate_constrained_to_construct: string=i : C a c i 10 D a i c i 11 ? V d f {F1} x00 j : D g j h j 12 D h j i j 13 ;
+
+  #XXX
+  # str_parts = string.split(' : ')
+  # if len(str_parts) != 2:
+  #   return f'ERROR: string has multiple colons: |{string}|'
+  mch = re.match('(.*?)( \? | \. \{)', string)
+  if mch :
+    strFixed = mch.group(1) + ';'
+    logging.info(f'ID={os.getpid()}: Bad LM output: {string}. Changed to {strFixed}')
+    string = strFixed
+
+  # sometimes the constraint in string is empty:
+  # 0407 17:11:35.470240 126383800963072 alphageometry.py:394] !! try_translate_constrained_to_construct: string=j : ;
+  hdprem = string.split(' : ')
+  if len(hdprem) !=2 or hdprem[1].strip()==';' :
+    logging.info(f'ID={os.getpid()}: Bad LM output: {string}. ERROR')
+    return f'ERROR: Bad LM output: {string}'
+  head, prem_str = hdprem
+  point = head.strip()
+
+  if len(point) != 1 or point == ' ':
+    return f'ERROR: invalid point name {point}'
+
+  existing_points = [p.name for p in g.all_points()]
+  if point in existing_points:
+    return f'ERROR: point {point} already exists.'
+
+  prem_toks = prem_str.split()[:-1]  # remove the EOS ' ;'
+  prems = [[]]
+
+  for i, tok in enumerate(prem_toks):
+    if tok.isdigit():
+      if i < len(prem_toks) - 1:
+        prems.append([])
+    else:
+      prems[-1].append(tok)
+
+  if len(prems) > 2:
+    return 'ERROR: there cannot be more than two predicates.'
+
+  clause_txt = point + ' = '
+  constructions = []
+
+  for prem in prems:
+    name, *args = prem
+
+    if point not in args:
+      return f'ERROR: {point} not found in predicate args.'
+
+    if not check_valid_args(pt.map_symbol(name), args):
+      return 'ERROR: Invalid predicate ' + name + ' ' + ' '.join(args)
+
+    for a in args:
+      if a != point and a not in existing_points:
+        return f'ERROR: point {a} does not exist.'
+
+    try:
+      name, args = translate_constrained_to_constructive(point, name, args)
+    except:  # pylint: disable=bare-except
+      return 'ERROR: Invalid predicate ' + name + ' ' + ' '.join(args)
+
+    if name == 'on_aline':
+      if args.count(point) > 1:
+        return f'ERROR: on_aline involves twice {point}'
+
+    constructions += [name + ' ' + ' '.join(args)]
+
+  clause_txt += ', '.join(constructions)
+  clause = pr.Clause.from_txt(clause_txt)
+
+  try:
+    g.copy().add_clause(clause, 0, DEFINITIONS)
+  except:  # pylint: disable=bare-except
+    return 'ERROR: ' + traceback.format_exc()
+
+  return clause_txt
+
+
+def insert_aux_to_premise(pstring: str, auxstring: str) -> str:
+  """Insert auxiliary constructs from proof to premise.
+
+  Args:
+    pstring: str: describing the problem to solve.
+    auxstring: str: describing the auxiliar construction.
+
+  Returns:
+    str: new pstring with auxstring inserted before the conclusion.
+  """
+  setup, goal = pstring.split(' ? ')
+  return setup + '; ' + auxstring + ' ? ' + goal
+
+
+class BeamQueue:
+  """Keep only the top k objects according to their values."""
+
+  def __init__(self, max_size: int = 512):
+    self.queue = []
+    self.max_size = max_size
+
+  def add(self, node: object, val: float) -> None:
+    """Add a new node to this queue."""
+
+    if len(self.queue) < self.max_size:
+      self.queue.append((val, node))
+      return
+
+    # Find the minimum node:
+    min_idx, (min_val, _) = min(enumerate(self.queue), key=lambda x: x[1])
+
+    # replace it if the new node has higher value.
+    if val > min_val:
+      self.queue[min_idx] = (val, node)
+
+  def __iter__(self):
+    for val, node in self.queue:
+      yield val, node
+
+  def __len__(self) -> int:
+    return len(self.queue)
+
+#XXX
+def bqsearch_init():
+    global model
+    logging.info('Worker initializing. PID=%d', os.getpid())
+    model = get_lm(_CKPT_PATH.value, _VOCAB_PATH.value)
+
+def bqsearch(i_nd, srch_inputs, out_file) -> tuple[int, bool, list]: # ( iNode, solved, [ (node, score) ] )
+    pid = os.getpid()
+    logging.info(f'Worker PID={pid} called for beam search node {i_nd}')
+
+    prev_score, (g, string, pstring) = srch_inputs
+    logging.info(f'Worker PID={pid}: Decoding from {string}')
+    outputs = model.beam_decode(string, eos_tokens=[';'])
+
+    # translate lm output to the constructive language.
+    # so that we can update the graph representing proof states:
+    translations = [
+        try_translate_constrained_to_construct(o, g)
+        for o in outputs['seqs_str']
+    ]
+
+    # couple the lm outputs with its translations
+    candidates = zip(outputs['seqs_str'], translations, outputs['scores'])
+
+    # bring the highest scoring candidate first
+    candidates = reversed(list(candidates))
+
+    ret = []
+    for lm_out, translation, score in candidates:
+      logging.info(f'Worker PID={pid}: LM output (score={score}): "{lm_out}"')
+      logging.info(f'Worker PID={pid}: Translation: "{translation}"')
+
+      if translation.startswith('ERROR:'):
+        # the construction is invalid.
+        continue
+
+      # Update the constructive statement of the problem with the aux point:
+      candidate_pstring = insert_aux_to_premise(pstring, translation)
+
+      #XXX
+      logging.info(f'Worker PID={pid}: string=|{string}| lm_out=|{lm_out}|')
+      logging.info(f'Worker PID={pid}: Solving: "{candidate_pstring}"')
+      p_new = pr.Problem.from_txt(candidate_pstring)
+
+      # This is the new proof state graph representation:
+      g_new, _ = gh.Graph.build_problem(p_new, DEFINITIONS)
+
+      try:
+        if run_ddar(g_new, p_new, out_file):
+          logging.info('Worker PID={pid}: Solved.')
+          return (i_nd, True, None)
+      except Exception as e:
+          logging.info(f'Worker PID={pid}: Error in run_ddar: {e}')
+
+      # Add the candidate to the beam queue.
+      ret.append( [
+          # The string for the new node is old_string + lm output +
+          # the special token asking for a new auxiliary point ' x00':
+          # node
+          (g_new, string + ' ' + lm_out + ' x00', candidate_pstring),
+          # the score of each node is sum of score of all nodes
+          # on the path to itself. For beam search, there is no need to
+          # normalize according to path length because all nodes in beam
+          # is of the same path length.
+          # val
+          prev_score + score ]
+      )
+
+    logging.info(f'Worker PID={pid} beam search node {i_nd}: returning')
+    return (i_nd, False, ret)
+
+def run_alphageometry(
+    #XX model: lm.LanguageModelInference,
+    p: pr.Problem,
+    search_depth: int,
+    beam_size: int,
+    out_file: str,
+) -> bool:
+  """Simplified code to run AlphaGeometry proof search.
+
+  We removed all optimizations that are infrastructure-dependent, e.g.
+  parallelized model inference on multi GPUs,
+  parallelized DD+AR on multiple CPUs,
+  parallel execution of LM and DD+AR,
+  shared pool of CPU workers across different problems, etc.
+
+  Many other speed optimizations and abstractions are also removed to
+  better present the core structure of the proof search.
+
+  Args:
+    model: Interface with inference-related endpoints to JAX's model.
+    p: pr.Problem object describing the problem to solve.
+    search_depth: max proof search depth.
+    beam_size: beam size of the proof search.
+    out_file: path to output file if solution is found.
+
+  Returns:
+    boolean of whether this is solved.
+  """
+  # translate the problem to a string of grammar that the LM is trained on.
+  string = p.setup_str_from_problem(DEFINITIONS)
+  # special tokens prompting the LM to generate auxiliary points.
+  string += ' {F1} x00'
+  # the graph to represent the proof state.
+  g, _ = gh.Graph.build_problem(p, DEFINITIONS)
+
+  # First we run the symbolic engine DD+AR:
+  if run_ddar(g, p, out_file):
+    return True
+  
+  # ?? when pickling graph for some problems, the default recursion limit 1000 is not enough,
+  #    got 'maximum recursion depth exceeded while pickling an object' error
+  sys.setrecursionlimit(10000)
+
+  # beam search for the proof
+  # each node in the search tree is a 3-tuple:
+  # (<graph representation of proof state>,
+  #  <string for LM to decode from>,
+  #  <original problem string>)
+  beam_queue = BeamQueue(max_size=beam_size)
+  # originally the beam search tree starts with a single node (a 3-tuple):
+  beam_queue.add(
+      node=(g, string, p.txt()), val=0.0  # value of the root node is simply 0.
+  )
+
+  pool = None
+  if _N_WORKSERS.value == 1:
+    bqsearch_init()
+  else:
+    pool = multiprocessing.Pool(_N_WORKSERS.value, bqsearch_init)
+
+  for depth in range(search_depth):
+    logging.info(
+        'Depth %s. There are %i nodes to expand:', depth, len(beam_queue)
+    )
+    for _, (_, string, _) in beam_queue:
+      logging.info(string)
+
+    new_queue = BeamQueue(max_size=beam_size)  # to replace beam_queue.
+    if _N_WORKSERS.value==1:
+      for i, srch_inputs in enumerate(beam_queue):
+        _, solved, res = bqsearch(i, srch_inputs, out_file)
+        if solved:
+          return True
+        for node, val in res:
+          # Add the candidate to the beam queue.
+          new_queue.add(node, val)
+          # Note that the queue only maintain at most beam_size nodes
+          # so this new node might possibly be dropped depending on its value.
+    else:      
+      jobs = [pool.apply_async(bqsearch, (i, srch_inputs, out_file)) for i, srch_inputs in enumerate(beam_queue)]
+
+      n_done = 0
+      while n_done < len(beam_queue):
+        for i, jobres in enumerate(jobs):
+          if jobres and jobres.ready():            
+            n_done += 1
+            jobs[i] = None
+            _, solved, res = jobres.get()
+            if solved:
+              # Clean up resources
+              pool.terminate()
+              pool.join()
+              return True
+            for node, val in res:
+              # Add the candidate to the beam queue.
+              new_queue.add(node, val)
+              # Note that the queue only maintain at most beam_size nodes
+              # so this new node might possibly be dropped depending on its value.            
+        time.sleep(1)  # Adjust wait time as needed
+
+    # replace the old queue with new queue before the new proof search depth.
+    beam_queue = new_queue
+
+  # Clean up resources
+  if pool:
+    pool.terminate()
+    pool.join()
+  return False
+
+def main(_):
+  global DEFINITIONS
+  global RULES
+
+  # definitions of terms used in our domain-specific language.
+  DEFINITIONS = pr.Definition.from_txt_file(_DEFS_FILE.value, to_dict=True)
+  # load inference rules used in DD.
+  RULES = pr.Theorem.from_txt_file(_RULES_FILE.value, to_dict=True)
+
+  # when using the language model,
+  # point names will be renamed to alphabetical a, b, c, d, e, ...
+  # instead of staying with their original names,
+  # in order to match the synthetic training data generation.
+  need_rename = _MODE.value != 'ddar'
+
+  # load problems from the problems_file,
+  problems = pr.Problem.from_txt_file(
+      _PROBLEMS_FILE.value, to_dict=True, translate=need_rename
+  )
+
+  if _PROBLEM_NAME.value not in problems:
+    raise ValueError(
+        f'Problem name `{_PROBLEM_NAME.value}` '
+        + f'not found in `{_PROBLEMS_FILE.value}`'
+    )
+
+  this_problem = problems[_PROBLEM_NAME.value]
+
+  if _MODE.value == 'ddar':
+    g, _ = gh.Graph.build_problem(this_problem, DEFINITIONS)
+    run_ddar(g, this_problem, _OUT_FILE.value)
+
+  elif _MODE.value == 'alphageometry':
+    #XX model = get_lm(_CKPT_PATH.value, _VOCAB_PATH.value)
+    run_alphageometry(
+        #XX model,
+        this_problem,
+        _SEARCH_DEPTH.value,
+        _BEAM_SIZE.value,
+        _OUT_FILE.value,
+    )
+
+  else:
+    raise ValueError(f'Unknown FLAGS.mode: {_MODE.value}')
+
+
+if __name__ == '__main__':
+  app.run(main)

ag4masses/alphageometry/alphageometry_test.py

@@ -0,0 +1,103 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Unit tests for alphageometry.py."""
+
+import unittest
+
+from absl.testing import absltest
+import alphageometry
+
+
+class AlphaGeometryTest(unittest.TestCase):
+
+  def test_translate_constrained_to_constructive(self):
+    self.assertEqual(
+        alphageometry.translate_constrained_to_constructive(
+            'd', 'T', list('addb')
+        ),
+        ('on_dia', ['d', 'b', 'a']),
+    )
+    self.assertEqual(
+        alphageometry.translate_constrained_to_constructive(
+            'd', 'T', list('adbc')
+        ),
+        ('on_tline', ['d', 'a', 'b', 'c']),
+    )
+    self.assertEqual(
+        alphageometry.translate_constrained_to_constructive(
+            'd', 'P', list('bcda')
+        ),
+        ('on_pline', ['d', 'a', 'b', 'c']),
+    )
+    self.assertEqual(
+        alphageometry.translate_constrained_to_constructive(
+            'd', 'D', list('bdcd')
+        ),
+        ('on_bline', ['d', 'c', 'b']),
+    )
+    self.assertEqual(
+        alphageometry.translate_constrained_to_constructive(
+            'd', 'D', list('bdcb')
+        ),
+        ('on_circle', ['d', 'b', 'c']),
+    )
+    self.assertEqual(
+        alphageometry.translate_constrained_to_constructive(
+            'd', 'D', list('bacd')
+        ),
+        ('eqdistance', ['d', 'c', 'b', 'a']),
+    )
+    self.assertEqual(
+        alphageometry.translate_constrained_to_constructive(
+            'd', 'C', list('bad')
+        ),
+        ('on_line', ['d', 'b', 'a']),
+    )
+    self.assertEqual(
+        alphageometry.translate_constrained_to_constructive(
+            'd', 'C', list('bad')
+        ),
+        ('on_line', ['d', 'b', 'a']),
+    )
+    self.assertEqual(
+        alphageometry.translate_constrained_to_constructive(
+            'd', 'O', list('abcd')
+        ),
+        ('on_circum', ['d', 'a', 'b', 'c']),
+    )
+
+  def test_insert_aux_to_premise(self):
+    pstring = 'a b c = triangle a b c; d = on_tline d b a c, on_tline d c a b ? perp a d b c'  # pylint: disable=line-too-long
+    auxstring = 'e = on_line e a c, on_line e b d'
+
+    target = 'a b c = triangle a b c; d = on_tline d b a c, on_tline d c a b; e = on_line e a c, on_line e b d ? perp a d b c'  # pylint: disable=line-too-long
+    self.assertEqual(
+        alphageometry.insert_aux_to_premise(pstring, auxstring), target
+    )
+
+  def test_beam_queue(self):
+    beam_queue = alphageometry.BeamQueue(max_size=2)
+
+    beam_queue.add('a', 1)
+    beam_queue.add('b', 2)
+    beam_queue.add('c', 3)
+
+    beam_queue = list(beam_queue)
+    self.assertEqual(beam_queue, [(3, 'c'), (2, 'b')])
+
+
+if __name__ == '__main__':
+  absltest.main()

ag4masses/alphageometry/ar.py

@@ -0,0 +1,752 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Implementing Algebraic Reasoning (AR)."""
+
+from collections import defaultdict  # pylint: disable=g-importing-member
+from fractions import Fraction as frac  # pylint: disable=g-importing-member
+from typing import Any, Generator
+
+import geometry as gm
+import numpy as np
+import problem as pr
+from scipy import optimize
+
+
+class InfQuotientError(Exception):
+  pass
+
+
+def _gcd(x: int, y: int) -> int:
+  while y:
+    x, y = y, x % y
+  return x
+
+
+def simplify(n: int, d: int) -> tuple[int, int]:
+  g = _gcd(n, d)
+  return (n // g, d // g)
+
+
+# maximum denominator for a fraction.
+MAX_DENOMINATOR = 1000000
+
+# tolerance for fraction approximation
+TOL = 1e-15
+
+
+def get_quotient(v: float) -> tuple[int, int]:
+  n = v
+  d = 1
+  while abs(n - round(n)) > TOL:
+    d += 1
+    n += v
+    if d > MAX_DENOMINATOR:
+      e = InfQuotientError(v)
+      raise e
+
+  n = int(round(n))
+  return simplify(n, d)
+
+
+def fix_v(v: float) -> float:
+  n, d = get_quotient(v)
+  return n / d
+
+
+def fix(e: dict[str, float]) -> dict[str, float]:
+  return {k: fix_v(v) for k, v in e.items()}
+
+
+def frac_string(f: frac) -> str:
+  n, d = get_quotient(f)
+  return f'{n}/{d}'
+
+
+def hashed(e: dict[str, float]) -> tuple[tuple[str, float], ...]:
+  return tuple(sorted(list(e.items())))
+
+
+def is_zero(e: dict[str, float]) -> bool:
+  return len(strip(e)) == 0  # pylint: disable=g-explicit-length-test
+
+
+def strip(e: dict[str, float]) -> dict[str, float]:
+  return {v: c for v, c in e.items() if c != 0}
+
+
+def plus(e1: dict[str, float], e2: dict[str, float]) -> dict[str, float]:
+  e = dict(e1)
+  for v, c in e2.items():
+    if v in e:
+      e[v] += c
+    else:
+      e[v] = c
+  return strip(e)
+
+
+def plus_all(*es: list[dict[str, float]]) -> dict[str, float]:
+  result = {}
+  for e in es:
+    result = plus(result, e)
+  return result
+
+
+def mult(e: dict[str, float], m: float) -> dict[str, float]:
+  return {v: m * c for v, c in e.items()}
+
+
+def minus(e1: dict[str, float], e2: dict[str, float]) -> dict[str, float]:
+  return plus(e1, mult(e2, -1))
+
+
+def div(e1: dict[str, float], e2: dict[str, float]) -> float:
+  """Divide e1 by e2."""
+  e1 = strip(e1)
+  e2 = strip(e2)
+  if set(e1.keys()) != set(e2.keys()):
+    return None
+
+  n, d = None, None
+
+  for v, c1 in e1.items():
+    c2 = e2[v]  # we want c1/c2 = n/d => c1*d=c2*n
+    if n is not None and c1 * d != c2 * n:
+      return None
+    n, d = c1, c2
+  return frac(n) / frac(d)
+
+
+def recon(e: dict[str, float], const: str) -> tuple[str, dict[str, float]]:
+  """Reconcile one variable in the expression e=0, given const."""
+  e = strip(e)
+  if len(e) == 0:  # pylint: disable=g-explicit-length-test
+    return None
+
+  v0 = None
+  for v in e:
+    if v != const:
+      v0 = v
+      break
+  if v0 is None:
+    return v0
+
+  c0 = e.pop(v0)
+  return v0, {v: -c / c0 for v, c in e.items()}
+
+
+def replace(
+    e: dict[str, float], v0: str, e0: dict[str, float]
+) -> dict[str, float]:
+  if v0 not in e:
+    return e
+  e = dict(e)
+  m = e.pop(v0)
+  return plus(e, mult(e0, m))
+
+
+def comb2(elems: list[Any]) -> Generator[tuple[Any, Any], None, None]:
+  if len(elems) < 1:
+    return
+  for i, e1 in enumerate(elems[:-1]):
+    for e2 in elems[i + 1 :]:
+      yield e1, e2
+
+
+def perm2(elems: list[Any]) -> Generator[tuple[Any, Any], None, None]:
+  for e1, e2 in comb2(elems):
+    yield e1, e2
+    yield e2, e1
+
+
+def chain2(elems: list[Any]) -> Generator[tuple[Any, Any], None, None]:
+  if len(elems) < 2:
+    return
+  for i, e1 in enumerate(elems[:-1]):
+    yield e1, elems[i + 1]
+
+
+def update_groups(
+    groups1: list[Any], groups2: list[Any]
+) -> tuple[list[Any], list[tuple[Any, Any]], list[list[Any]]]:
+  """Update groups of equivalent elements.
+
+  Given groups1 = [set1, set2, set3, ..]
+  where all elems within each set_i is defined to be "equivalent" to each other.
+  (but not across the sets)
+
+  Incoming groups2 = [set1, set2, ...] similar to set1 - it is the
+  additional equivalent information on elements in groups1.
+
+  Return the new updated groups1 and the set of links
+  that make it that way.
+
+  Example:
+    groups1 = [{1, 2}, {3, 4, 5}, {6, 7}]
+    groups2 = [{2, 3, 8}, {9, 10, 11}]
+
+  => new groups1 and links:
+    groups1 = [{1, 2, 3, 4, 5, 8}, {6, 7}, {9, 10, 11}]
+    links = (2, 3), (3, 8), (9, 10), (10, 11)
+
+  Explain: since groups2 says 2 and 3 are equivalent (with {2, 3, 8}),
+  then {1, 2} and {3, 4, 5} in groups1 will be merged,
+  because 2 and 3 each belong to those 2 groups.
+  Additionally 8 also belong to this same group.
+  {3, 4, 5} is left alone, while {9, 10, 11} is a completely new set.
+
+  The links to make this all happens is:
+  (2, 3): to merge {1, 2} and {3, 4, 5}
+  (3, 8): to link 8 into the merged({1, 2, 3, 4, 5})
+  (9, 10) and (10, 11): to make the new group {9, 10, 11}
+
+  Args:
+    groups1: a list of sets.
+    groups2: a list of sets.
+
+  Returns:
+    groups1, links, history: result of the update.
+  """
+  history = []
+  links = []
+  for g2 in groups2:
+    joins = [None] * len(groups1)  # mark which one in groups1 is merged
+    merged_g1 = set()  # merge them into this.
+    old = None  # any elem in g2 that belong to any set in groups1 (old)
+    new = []  # all elem in g2 that is new
+
+    for e in g2:
+      found = False
+      for i, g1 in enumerate(groups1):
+        if e not in g1:
+          continue
+
+        found = True
+        if joins[i]:
+          continue
+
+        joins[i] = True
+        merged_g1.update(g1)
+
+        if old is not None:
+          links.append((old, e))  # link to make merging happen.
+        old = e
+
+      if not found:  # e is new!
+        new.append(e)
+
+    # now chain elems in new together.
+    if old is not None and new:
+      links.append((old, new[0]))
+      merged_g1.update(new)
+
+    links += chain2(new)
+
+    new_groups1 = []
+    if merged_g1:  # put the merged_g1 in first
+      new_groups1.append(merged_g1)
+
+    # put the remaining (unjoined) groups in
+    new_groups1 += [g1 for j, g1 in zip(joins, groups1) if not j]
+
+    if old is None and new:
+      new_groups1 += [set(new)]
+
+    groups1 = new_groups1
+    history.append(groups1)
+
+  return groups1, links, history
+
+
+class Table:
+  """The coefficient matrix."""
+
+  def __init__(self, const: str = '1'):
+    self.const = const
+    self.v2e = {}
+    self.add_free(const)  # the table {var: expression}
+
+    # to cache what is already derived/inputted
+    self.eqs = set()
+    self.groups = []  # groups of equal pairs.
+
+    # for why (linprog)
+    self.c = []
+    self.v2i = {}  # v -> index of row in A.
+    self.deps = []  # equal number of columns.
+    self.A = np.zeros([0, 0])  # pylint: disable=invalid-name
+    self.do_why = True
+
+  def add_free(self, v: str) -> None:
+    self.v2e[v] = {v: frac(1)}
+
+  def replace(self, v0: str, e0: dict[str, float]) -> None:
+    for v, e in list(self.v2e.items()):
+      self.v2e[v] = replace(e, v0, e0)
+
+  def add_expr(self, vc: list[tuple[str, float]]) -> bool:
+    """Add a new equality, represented by the list of tuples vc=[(v, c), ..]."""
+    result = {}
+    free = []
+
+    for v, c in vc:
+      c = frac(c)
+      if v in self.v2e:
+        result = plus(result, mult(self.v2e[v], c))
+      else:
+        free += [(v, c)]
+
+    if free == []:  # pylint: disable=g-explicit-bool-comparison
+      if is_zero(self.modulo(result)):
+        return False
+      result = recon(result, self.const)
+      if result is None:
+        return False
+      v, e = result
+      self.replace(v, e)
+
+    elif len(free) == 1:
+      v, m = free[0]
+      self.v2e[v] = mult(result, frac(-1, m))
+
+    else:
+      dependent_v = None
+      for v, m in free:
+        if dependent_v is None and v != self.const:
+          dependent_v = (v, m)
+          continue
+
+        self.add_free(v)
+        result = plus(result, {v: m})
+
+      v, m = dependent_v
+      self.v2e[v] = mult(result, frac(-1, m))
+
+    return True
+
+  def register(self, vc: list[tuple[str, float]], dep: pr.Dependency) -> None:
+    """Register a new equality vc=[(v, c), ..] with traceback dependency dep."""
+    result = plus_all(*[{v: c} for v, c in vc])
+    if is_zero(result):
+      return
+
+    vs, _ = zip(*vc)
+    for v in vs:
+      if v not in self.v2i:
+        self.v2i[v] = len(self.v2i)
+
+    (m, n), l = self.A.shape, len(self.v2i)
+    if l > m:
+      self.A = np.concatenate([self.A, np.zeros([l - m, n])], 0)
+
+    new_column = np.zeros([len(self.v2i), 2])  # N, 2
+    for v, c in vc:
+      new_column[self.v2i[v], 0] += float(c)
+      new_column[self.v2i[v], 1] -= float(c)
+
+    self.A = np.concatenate([self.A, new_column], 1)
+    self.c += [1.0, -1.0]
+    self.deps += [dep]
+
+  def register2(
+      self, a: str, b: str, m: float, n: float, dep: pr.Dependency
+  ) -> None:
+    self.register([(a, m), (b, -n)], dep)
+
+  def register3(self, a: str, b: str, f: float, dep: pr.Dependency) -> None:
+    self.register([(a, 1), (b, -1), (self.const, -f)], dep)
+
+  def register4(
+      self, a: str, b: str, c: str, d: str, dep: pr.Dependency
+  ) -> None:
+    self.register([(a, 1), (b, -1), (c, -1), (d, 1)], dep)
+
+  def why(self, e: dict[str, float]) -> list[Any]:
+    """AR traceback == MILP."""
+    if not self.do_why:
+      return []
+    # why expr == 0?
+    # Solve min(c^Tx) s.t. A_eq * x = b_eq, x >= 0
+    e = strip(e)
+    if not e:
+      return []
+
+    b_eq = [0] * len(self.v2i)
+    for v, c in e.items():
+      b_eq[self.v2i[v]] += float(c)
+
+    try:
+      x = optimize.linprog(c=self.c, A_eq=self.A, b_eq=b_eq, method='highs')[
+          'x'
+      ]
+    except:  # pylint: disable=bare-except
+      x = optimize.linprog(
+          c=self.c,
+          A_eq=self.A,
+          b_eq=b_eq,
+      )['x']
+
+    deps = []
+    for i, dep in enumerate(self.deps):
+      if x[2 * i] > 1e-12 or x[2 * i + 1] > 1e-12:
+        if dep not in deps:
+          deps.append(dep)
+    return deps
+
+  def record_eq(self, v1: str, v2: str, v3: str, v4: str) -> None:
+    self.eqs.add((v1, v2, v3, v4))
+    self.eqs.add((v2, v1, v4, v3))
+    self.eqs.add((v3, v4, v1, v2))
+    self.eqs.add((v4, v3, v2, v1))
+
+  def check_record_eq(self, v1: str, v2: str, v3: str, v4: str) -> bool:
+    if (v1, v2, v3, v4) in self.eqs:
+      return True
+    if (v2, v1, v4, v3) in self.eqs:
+      return True
+    if (v3, v4, v1, v2) in self.eqs:
+      return True
+    if (v4, v3, v2, v1) in self.eqs:
+      return True
+    return False
+
+  def add_eq2(
+      self, a: str, b: str, m: float, n: float, dep: pr.Dependency
+  ) -> None:
+    # a/b = m/n
+    if not self.add_expr([(a, n), (b, -m)]):
+      return []
+    self.register2(a, b, m, n, dep)
+
+  def add_eq3(self, a: str, b: str, f: float, dep: pr.Dependency) -> None:
+    # a - b = f * constant
+    self.eqs.add((a, b, frac(f)))
+    self.eqs.add((b, a, frac(1 - f)))
+
+    if not self.add_expr([(a, 1), (b, -1), (self.const, -f)]):
+      return []
+
+    self.register3(a, b, f, dep)
+
+  def add_eq4(self, a: str, b: str, c: str, d: str, dep: pr.Dependency) -> None:
+    # a - b = c - d
+    self.record_eq(a, b, c, d)
+    self.record_eq(a, c, b, d)
+
+    expr = list(minus({a: 1, b: -1}, {c: 1, d: -1}).items())
+
+    if not self.add_expr(expr):
+      return []
+
+    self.register4(a, b, c, d, dep)
+    self.groups, _, _ = update_groups(
+        self.groups, [{(a, b), (c, d)}, {(b, a), (d, c)}]
+    )
+
+  def pairs(self) -> Generator[list[tuple[str, str]], None, None]:
+    for v1, v2 in perm2(list(self.v2e.keys())):  # pylint: disable=g-builtin-op
+      if v1 == self.const or v2 == self.const:
+        continue
+      yield v1, v2
+
+  def modulo(self, e: dict[str, float]) -> dict[str, float]:
+    return strip(e)
+
+  def get_all_eqs(
+      self,
+  ) -> dict[tuple[tuple[str, float], ...], list[tuple[str, str]]]:
+    h2pairs = defaultdict(list)
+    for v1, v2 in self.pairs():
+      e1, e2 = self.v2e[v1], self.v2e[v2]
+      e12 = minus(e1, e2)
+      h12 = hashed(self.modulo(e12))
+      h2pairs[h12].append((v1, v2))
+    return h2pairs
+
+  def get_all_eqs_and_why(
+      self, return_quads: bool = True
+  ) -> Generator[Any, None, None]:
+    """Check all 4/3/2-permutations for new equalities."""
+    groups = []
+
+    for h, vv in self.get_all_eqs().items():
+      if h == ():  # pylint: disable=g-explicit-bool-comparison
+        for v1, v2 in vv:
+          if (v1, v2) in self.eqs or (v2, v1) in self.eqs:
+            continue
+          self.eqs.add((v1, v2))
+          # why v1 - v2 = e12 ?  (note modulo(e12) == 0)
+          why_dict = minus({v1: 1, v2: -1}, minus(self.v2e[v1], self.v2e[v2]))
+          yield v1, v2, self.why(why_dict)
+        continue
+
+      if len(h) == 1 and h[0][0] == self.const:
+        for v1, v2 in vv:
+          frac = h[0][1]  # pylint: disable=redefined-outer-name
+          if (v1, v2, frac) in self.eqs:
+            continue
+          self.eqs.add((v1, v2, frac))
+          # why v1 - v2 = e12 ?  (note modulo(e12) == 0)
+          why_dict = minus({v1: 1, v2: -1}, minus(self.v2e[v1], self.v2e[v2]))
+          value = simplify(frac.numerator, frac.denominator)
+          yield v1, v2, value, self.why(why_dict)
+        continue
+
+      groups.append(vv)
+
+    if not return_quads:
+      return
+
+    self.groups, links, _ = update_groups(self.groups, groups)
+    for (v1, v2), (v3, v4) in links:
+      if self.check_record_eq(v1, v2, v3, v4):
+        continue
+      e12 = minus(self.v2e[v1], self.v2e[v2])
+      e34 = minus(self.v2e[v3], self.v2e[v4])
+
+      why_dict = minus(  # why (v1-v2)-(v3-v4)=e12-e34?
+          minus({v1: 1, v2: -1}, {v3: 1, v4: -1}), minus(e12, e34)
+      )
+      self.record_eq(v1, v2, v3, v4)
+      yield v1, v2, v3, v4, self.why(why_dict)
+
+
+class GeometricTable(Table):
+  """Abstract class representing the coefficient matrix (table) A."""
+
+  def __init__(self, name: str = ''):
+    super().__init__(name)
+    self.v2obj = {}
+
+  def get_name(self, objs: list[Any]) -> list[str]:
+    self.v2obj.update({o.name: o for o in objs})
+    return [o.name for o in objs]
+
+  def map2obj(self, names: list[str]) -> list[Any]:
+    return [self.v2obj[n] for n in names]
+
+  def get_all_eqs_and_why(
+      self, return_quads: bool
+  ) -> Generator[Any, None, None]:
+    for out in super().get_all_eqs_and_why(return_quads):
+      if len(out) == 3:
+        x, y, why = out
+        x, y = self.map2obj([x, y])
+        yield x, y, why
+      if len(out) == 4:
+        x, y, f, why = out
+        x, y = self.map2obj([x, y])
+        yield x, y, f, why
+      if len(out) == 5:
+        a, b, x, y, why = out
+        a, b, x, y = self.map2obj([a, b, x, y])
+        yield a, b, x, y, why
+
+
+class RatioTable(GeometricTable):
+  """Coefficient matrix A for log(distance)."""
+
+  def __init__(self, name: str = ''):
+    name = name or '1'
+    super().__init__(name)
+    self.one = self.const
+
+  def add_eq(self, l1: gm.Length, l2: gm.Length, dep: pr.Dependency) -> None:
+    l1, l2 = self.get_name([l1, l2])
+    return super().add_eq3(l1, l2, 0.0, dep)
+
+  def add_const_ratio(
+      self, l1: gm.Length, l2: gm.Length, m: float, n: float, dep: pr.Dependency
+  ) -> None:
+    l1, l2 = self.get_name([l1, l2])
+    return super().add_eq2(l1, l2, m, n, dep)
+
+  def add_eqratio(
+      self,
+      l1: gm.Length,
+      l2: gm.Length,
+      l3: gm.Length,
+      l4: gm.Length,
+      dep: pr.Dependency,
+  ) -> None:
+    l1, l2, l3, l4 = self.get_name([l1, l2, l3, l4])
+    return self.add_eq4(l1, l2, l3, l4, dep)
+
+  def get_all_eqs_and_why(self) -> Generator[Any, None, None]:
+    return super().get_all_eqs_and_why(True)
+
+
+class AngleTable(GeometricTable):
+  """Coefficient matrix A for slope(direction)."""
+
+  def __init__(self, name: str = ''):
+    name = name or 'pi'
+    super().__init__(name)
+    self.pi = self.const
+
+  def modulo(self, e: dict[str, float]) -> dict[str, float]:
+    e = strip(e)
+    if self.pi not in e:
+      return super().modulo(e)
+
+    e[self.pi] = e[self.pi] % 1
+    return strip(e)
+
+  def add_para(
+      self, d1: gm.Direction, d2: gm.Direction, dep: pr.Dependency
+  ) -> None:
+    return self.add_const_angle(d1, d2, 0, dep)
+
+  def add_const_angle(
+      self, d1: gm.Direction, d2: gm.Direction, ang: float, dep: pr.Dependency
+  ) -> None:
+    if ang and d2._obj.num > d1._obj.num:  # pylint: disable=protected-access
+      d1, d2 = d2, d1
+      ang = 180 - ang
+
+    d1, d2 = self.get_name([d1, d2])
+
+    num, den = simplify(ang, 180)
+    ang = frac(int(num), int(den))
+    return super().add_eq3(d1, d2, ang, dep)
+
+  def add_eqangle(
+      self,
+      d1: gm.Direction,
+      d2: gm.Direction,
+      d3: gm.Direction,
+      d4: gm.Direction,
+      dep: pr.Dependency,
+  ) -> None:
+    """Add the inequality d1-d2=d3-d4."""
+    # Use string as variables.
+    l1, l2, l3, l4 = [d._obj.num for d in [d1, d2, d3, d4]]  # pylint: disable=protected-access
+    d1, d2, d3, d4 = self.get_name([d1, d2, d3, d4])
+    ang1 = {d1: 1, d2: -1}
+    ang2 = {d3: 1, d4: -1}
+
+    if l2 > l1:
+      ang1 = plus({self.pi: 1}, ang1)
+    if l4 > l3:
+      ang2 = plus({self.pi: 1}, ang2)
+
+    ang12 = minus(ang1, ang2)
+    self.record_eq(d1, d2, d3, d4)
+    self.record_eq(d1, d3, d2, d4)
+
+    expr = list(ang12.items())
+    if not self.add_expr(expr):
+      return []
+
+    self.register(expr, dep)
+
+  def get_all_eqs_and_why(self) -> Generator[Any, None, None]:
+    return super().get_all_eqs_and_why(True)
+
+
+class DistanceTable(GeometricTable):
+  """Coefficient matrix A for position(point, line)."""
+
+  def __init__(self, name: str = ''):
+    name = name or '1:1'
+    self.merged = {}
+    self.ratios = set()
+    super().__init__(name)
+
+  def pairs(self) -> Generator[tuple[str, str], None, None]:
+    l2vs = defaultdict(list)
+    for v in list(self.v2e.keys()):  # pylint: disable=g-builtin-op
+      if v == self.const:
+        continue
+      l, p = v.split(':')
+      l2vs[l].append(p)
+
+    for l, ps in l2vs.items():
+      for p1, p2 in perm2(ps):
+        yield l + ':' + p1, l + ':' + p2
+
+  def name(self, l: gm.Line, p: gm.Point) -> str:
+    v = l.name + ':' + p.name
+    self.v2obj[v] = (l, p)
+    return v
+
+  def map2obj(self, names: list[str]) -> list[gm.Point]:
+    return [self.v2obj[n][1] for n in names]
+
+  def add_cong(
+      self,
+      l12: gm.Line,
+      l34: gm.Line,
+      p1: gm.Point,
+      p2: gm.Point,
+      p3: gm.Point,
+      p4: gm.Point,
+      dep: pr.Dependency,
+  ) -> None:
+    """Add that distance between p1 and p2 (on l12) == p3 and p4 (on l34)."""
+    if p2.num > p1.num:
+      p1, p2 = p2, p1
+    if p4.num > p3.num:
+      p3, p4 = p4, p3
+
+    p1 = self.name(l12, p1)
+    p2 = self.name(l12, p2)
+    p3 = self.name(l34, p3)
+    p4 = self.name(l34, p4)
+    return super().add_eq4(p1, p2, p3, p4, dep)
+
+  def get_all_eqs_and_why(self) -> Generator[Any, None, None]:
+    for x in super().get_all_eqs_and_why(True):
+      yield x
+
+    # Now we figure out all the const ratios.
+    h2pairs = defaultdict(list)
+    for v1, v2 in self.pairs():
+      if (v1, v2) in self.merged:
+        continue
+      e1, e2 = self.v2e[v1], self.v2e[v2]
+      e12 = minus(e1, e2)
+      h12 = hashed(e12)
+      h2pairs[h12].append((v1, v2, e12))
+
+    for (_, vves1), (_, vves2) in perm2(list(h2pairs.items())):
+      v1, v2, e12 = vves1[0]
+      for v1_, v2_, _ in vves1[1:]:
+        self.merged[(v1_, v2_)] = (v1, v2)
+
+      v3, v4, e34 = vves2[0]
+      for v3_, v4_, _ in vves2[1:]:
+        self.merged[(v3_, v4_)] = (v3, v4)
+
+      if (v1, v2, v3, v4) in self.ratios:
+        continue
+
+      d12 = div(e12, e34)
+      if d12 is None or d12 > 1 or d12 < 0:
+        continue
+
+      self.ratios.add((v1, v2, v3, v4))
+      self.ratios.add((v2, v1, v4, v3))
+
+      n, d = d12.numerator, d12.denominator
+
+      # (v1 - v2) * d = (v3 - v4) * n
+      why_dict = minus(
+          minus({v1: d, v2: -d}, {v3: n, v4: -n}),
+          minus(mult(e12, d), mult(e34, n)),  # there is no modulo, so this is 0
+      )
+
+      v1, v2, v3, v4 = self.map2obj([v1, v2, v3, v4])
+      yield v1, v2, v3, v4, abs(n), abs(d), self.why(why_dict)

ag4masses/alphageometry/ar_test.py

@@ -0,0 +1,204 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Unit tests for ar.py."""
+import unittest
+
+from absl.testing import absltest
+import ar
+import graph as gh
+import problem as pr
+
+
+class ARTest(unittest.TestCase):
+
+  @classmethod
+  def setUpClass(cls):
+    super().setUpClass()
+    cls.defs = pr.Definition.from_txt_file('defs.txt', to_dict=True)
+    cls.rules = pr.Theorem.from_txt_file('rules.txt', to_dict=True)
+
+  def test_update_groups(self):
+    """Test for update_groups."""
+    groups1 = [{1, 2}, {3, 4, 5}, {6, 7}]
+    groups2 = [{2, 3, 8}, {9, 10, 11}]
+
+    _, links, history = ar.update_groups(groups1, groups2)
+    self.assertEqual(
+        history,
+        [
+            [{1, 2, 3, 4, 5, 8}, {6, 7}],
+            [{1, 2, 3, 4, 5, 8}, {6, 7}, {9, 10, 11}],
+        ],
+    )
+    self.assertEqual(links, [(2, 3), (3, 8), (9, 10), (10, 11)])
+
+    groups1 = [{1, 2}, {3, 4}, {5, 6}, {7, 8}]
+    groups2 = [{2, 3, 8, 9, 10}, {3, 6, 11}]
+
+    _, links, history = ar.update_groups(groups1, groups2)
+    self.assertEqual(
+        history,
+        [
+            [{1, 2, 3, 4, 7, 8, 9, 10}, {5, 6}],
+            [{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}],
+        ],
+    )
+    self.assertEqual(links, [(2, 3), (3, 8), (8, 9), (9, 10), (3, 6), (6, 11)])
+
+    groups1 = []
+    groups2 = [{1, 2}, {3, 4}, {5, 6}, {2, 3}]
+
+    _, links, history = ar.update_groups(groups1, groups2)
+    self.assertEqual(
+        history,
+        [
+            [{1, 2}],
+            [{1, 2}, {3, 4}],
+            [{1, 2}, {3, 4}, {5, 6}],
+            [{1, 2, 3, 4}, {5, 6}],
+        ],
+    )
+    self.assertEqual(links, [(1, 2), (3, 4), (5, 6), (2, 3)])
+
+  def test_generic_table_simple(self):
+    tb = ar.Table()
+
+    # If a-b = b-c & d-a = c-d
+    tb.add_eq4('a', 'b', 'b', 'c', 'fact1')
+    tb.add_eq4('d', 'a', 'c', 'd', 'fact2')
+    tb.add_eq4('x', 'y', 'z', 't', 'fact3')  # distractor fact
+
+    # Then b=d, because {fact1, fact2} but not fact3.
+    result = list(tb.get_all_eqs_and_why())
+    self.assertIn(('b', 'd', ['fact1', 'fact2']), result)
+
+  def test_angle_table_inbisector_exbisector(self):
+    """Test that AR can figure out bisector & ex-bisector are perpendicular."""
+    # Load the scenario that we have cd is bisector of acb and
+    # ce is the ex-bisector of acb.
+    p = pr.Problem.from_txt(
+        'a b c = triangle a b c; d = incenter d a b c; e = excenter e a b c ?'
+        ' perp d c c e'
+    )
+    g, _ = gh.Graph.build_problem(p, ARTest.defs)
+
+    # Create an external angle table:
+    tb = ar.AngleTable('pi')
+
+    # Add bisector & ex-bisector facts into the table:
+    ca, cd, cb, ce = g.names2nodes(['d(ac)', 'd(cd)', 'd(bc)', 'd(ce)'])
+    tb.add_eqangle(ca, cd, cd, cb, 'fact1')
+    tb.add_eqangle(ce, ca, cb, ce, 'fact2')
+
+    # Add a distractor fact to make sure traceback does not include this fact
+    ab = g.names2nodes(['d(ab)'])[0]
+    tb.add_eqangle(ab, cb, cb, ca, 'fact3')
+
+    # Check for all new equalities
+    result = list(tb.get_all_eqs_and_why())
+
+    # halfpi is represented as a tuple (1, 2)
+    halfpi = (1, 2)
+
+    # check that cd-ce == halfpi and this is because fact1 & fact2, not fact3
+    self.assertCountEqual(
+        result,
+        [
+            (cd, ce, halfpi, ['fact1', 'fact2']),
+            (ce, cd, halfpi, ['fact1', 'fact2']),
+        ],
+    )
+
+  def test_angle_table_equilateral_triangle(self):
+    """Test that AR can figure out triangles with 3 equal angles => each is pi/3."""
+    # Load an equaliteral scenario
+    p = pr.Problem.from_txt('a b c = ieq_triangle ? cong a b a c')
+    g, _ = gh.Graph.build_problem(p, ARTest.defs)
+
+    # Add two eqangles facts because ieq_triangle only add congruent sides
+    a, b, c = g.names2nodes('abc')
+    g.add_eqangle([a, b, b, c, b, c, c, a], pr.EmptyDependency(0, None))
+    g.add_eqangle([b, c, c, a, c, a, a, b], pr.EmptyDependency(0, None))
+
+    # Create an external angle table:
+    tb = ar.AngleTable('pi')
+
+    # Add the fact that there are three equal angles
+    ab, bc, ca = g.names2nodes(['d(ab)', 'd(bc)', 'd(ac)'])
+    tb.add_eqangle(ab, bc, bc, ca, 'fact1')
+    tb.add_eqangle(bc, ca, ca, ab, 'fact2')
+
+    # Now check for all new equalities
+    result = list(tb.get_all_eqs_and_why())
+    result = [(x.name, y.name, z, t) for x, y, z, t in result]
+
+    # 1/3 pi is represented as a tuple angle_60
+    angle_60 = (1, 3)
+    angle_120 = (2, 3)
+
+    # check that angles constants are created and figured out:
+    self.assertCountEqual(
+        result,
+        [
+            ('d(bc)', 'd(ac)', angle_120, ['fact1', 'fact2']),
+            ('d(ab)', 'd(bc)', angle_120, ['fact1', 'fact2']),
+            ('d(ac)', 'd(ab)', angle_120, ['fact1', 'fact2']),
+            ('d(ac)', 'd(bc)', angle_60, ['fact1', 'fact2']),
+            ('d(bc)', 'd(ab)', angle_60, ['fact1', 'fact2']),
+            ('d(ab)', 'd(ac)', angle_60, ['fact1', 'fact2']),
+        ],
+    )
+
+  def test_incenter_excenter_touchpoints(self):
+    """Test that AR can figure out incenter/excenter touchpoints are equidistant to midpoint."""
+
+    p = pr.Problem.from_txt(
+        'a b c = triangle a b c; d1 d2 d3 d = incenter2 a b c; e1 e2 e3 e ='
+        ' excenter2 a b c ? perp d c c e',
+        translate=False,
+    )
+    g, _ = gh.Graph.build_problem(p, ARTest.defs)
+
+    a, b, c, ab, bc, ca, d1, d2, d3, e1, e2, e3 = g.names2nodes(
+        ['a', 'b', 'c', 'ab', 'bc', 'ac', 'd1', 'd2', 'd3', 'e1', 'e2', 'e3']
+    )
+
+    # Create an external distance table:
+    tb = ar.DistanceTable()
+
+    # DD can figure out the following facts,
+    # we manually add them to AR.
+    tb.add_cong(ab, ca, a, d3, a, d2, 'fact1')
+    tb.add_cong(ab, ca, a, e3, a, e2, 'fact2')
+    tb.add_cong(ca, bc, c, d2, c, d1, 'fact5')
+    tb.add_cong(ca, bc, c, e2, c, e1, 'fact6')
+    tb.add_cong(bc, ab, b, d1, b, d3, 'fact3')
+    tb.add_cong(bc, ab, b, e1, b, e3, 'fact4')
+
+    # Now we check whether tb has figured out that
+    # distance(b, d1) == distance(e1, c)
+
+    # linear comb exprssion of each variables:
+    b = tb.v2e['bc:b']
+    c = tb.v2e['bc:c']
+    d1 = tb.v2e['bc:d1']
+    e1 = tb.v2e['bc:e1']
+
+    self.assertEqual(ar.minus(d1, b), ar.minus(c, e1))
+
+
+if __name__ == '__main__':
+  absltest.main()

ag4masses/alphageometry/beam_search.py

@@ -0,0 +1,463 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Fast decoding routines for inference from a trained model.
+
+Modified https://github.com/google/flax/blob/main/examples/wmt/decode.py
+to acommodate
+
+(a) continued decoding from a previous beam cache.
+(b) init with with a single beam and then expand into beam_size beams.
+"""
+
+from typing import Any
+
+import flax
+import jax
+from jax import lax
+import jax.numpy as jnp
+import numpy as np
+
+
+# Constants
+# "Effective negative infinity" constant for masking in beam search.
+NEG_INF = np.array(-1.0e7)
+
+# Beam search parameters
+BEAM_SEARCH_DEFAULT_ALPHA = 0.6
+MAX_DECODE_LEN = 32
+
+# Brevity penalty parameters
+BREVITY_LEN_BIAS_NUMERATOR = 5.0
+BREVITY_LEN_BIAS_DENOMINATOR = 6.0
+
+
+def brevity_penalty(alpha: float, length: int):
+  """Brevity penalty function for beam search penalizing short sequences.
+
+  Args:
+    alpha: float: brevity-penalty scaling parameter.
+    length: int: length of considered sequence.
+
+  Returns:
+    Brevity penalty score as jax scalar.
+  """
+  return jnp.power(
+      ((BREVITY_LEN_BIAS_NUMERATOR + length) / BREVITY_LEN_BIAS_DENOMINATOR),
+      alpha,
+  )
+
+
+# Beam handling utility functions:
+
+
+def add_beam_dim(x: jnp.ndarray, beam_size: int) -> jnp.ndarray:
+  """Creates new beam dimension in non-scalar array and tiles into it."""
+  if x.ndim == 0:  # ignore scalars (e.g. cache index)
+    return x
+  x = jnp.expand_dims(x, axis=1)
+  tile_dims = [1] * x.ndim
+  tile_dims[1] = beam_size
+  return jnp.tile(x, tile_dims)
+
+
+def add_beam_dim_cache(
+    cache: tuple[dict[str, jnp.ndarray], ...], beam_size: int
+) -> tuple[dict[str, jnp.ndarray], ...]:
+  """Creates new beam dimension in non-scalar array and tiles into it."""
+  new_cache = []
+
+  for layer in cache:
+    new_layer = {}
+    for key, x in layer.items():
+      if key in ['keys', 'vals']:
+        x = add_beam_dim(x, beam_size)
+      new_layer[key] = x
+    new_cache.append(new_layer)
+
+  return tuple(new_cache)
+
+
+def flatten_beam_dim(x):
+  """Flattens the first two dimensions of a non-scalar array."""
+  if x.ndim < 2:  # ignore scalars (e.g. cache index)
+    return x
+  return x.reshape((x.shape[0] * x.shape[1],) + x.shape[2:])
+
+
+def unflatten_beam_dim(x, batch_size, beam_size):
+  """Unflattens the first, flat batch*beam dimension of a non-scalar array."""
+  if x.ndim == 0:  # ignore scalars (e.g. cache index)
+    return x
+  assert batch_size * beam_size == x.shape[0]
+  return x.reshape((batch_size, beam_size) + x.shape[1:])
+
+
+def flat_batch_beam_expand(x, beam_size):
+  """Expands the each batch item by beam_size in batch_dimension."""
+  return flatten_beam_dim(add_beam_dim(x, beam_size))
+
+
+def gather_beams(nested, beam_indices, batch_size, new_beam_size):
+  """Gathers the beam slices indexed by beam_indices into new beam array.
+
+  Args:
+    nested: pytree of arrays or scalars (the latter ignored).
+    beam_indices: array of beam_indices
+    batch_size: int: size of batch.
+    new_beam_size: int: size of _new_ beam dimension.
+
+  Returns:
+    New pytree with new beam arrays.
+    [batch_size, old_beam_size, ...] --> [batch_size, new_beam_size, ...]
+  """
+  batch_indices = jnp.reshape(
+      jnp.arange(batch_size * new_beam_size) // new_beam_size,
+      (batch_size, new_beam_size),
+  )
+
+  def gather_fn(x):
+    if x.ndim == 0:  # ignore scalars (e.g. cache index)
+      return x
+    else:
+      return x[batch_indices, beam_indices]
+
+  return jax.tree_util.tree_map(gather_fn, nested)
+
+
+def gather_topk_beams(nested, score_or_log_prob, batch_size, new_beam_size):
+  """Gathers the top-k beam slices given by score_or_log_prob array.
+
+  Args:
+    nested: pytree of arrays or scalars (the latter ignored).
+    score_or_log_prob: [batch_size, old_beam_size] array of values to sort by
+      for top-k selection of beam slices.
+    batch_size: int: size of batch.
+    new_beam_size: int: size of _new_ top-k selected beam dimension
+
+  Returns:
+    New pytree with new beam arrays containing top k new_beam_size slices.
+    [batch_size, old_beam_size, ...] --> [batch_size, new_beam_size, ...]
+  """
+  _, topk_indices = lax.top_k(score_or_log_prob, k=new_beam_size)
+  topk_indices = jnp.flip(topk_indices, axis=1)
+  return gather_beams(nested, topk_indices, batch_size, new_beam_size)
+
+
+def apply_on_cache(fn, cache, *args, **kwargs):
+  """Apply fn(val) only when key is 'keys' or 'val'."""
+  new_cache = []
+  for layer in cache:
+    new_layer = {}
+    for key, val in layer.items():
+      if key in ['keys', 'values', 'current_index', 'relative_position_bias']:
+        val = fn(val, *args, **kwargs)
+      new_layer[key] = val
+    new_cache.append(new_layer)
+  return tuple(new_cache)
+
+
+# Beam search state:
+
+
+@flax.struct.dataclass
+class BeamState:
+  """Holds beam search state data."""
+
+  # The position of the decoding loop in the length dimension.
+  cur_index: jax.Array  # scalar int32: current decoded length index
+  # The active sequence log probabilities and finished sequence scores.
+  live_logprobs: jax.Array  # float32: [batch_size, beam_size]
+  finished_scores: jax.Array  # float32: [batch_size, beam_size]
+  # The current active-beam-searching and finished sequences.
+  live_seqs: jax.Array  # int32: [batch_size, beam_size, max_decode_len]
+  finished_seqs: jax.Array  # int32: [batch_size, beam_size,
+  #                                         max_decode_len]
+  # Records which of the 'finished_seqs' is occupied and not a filler slot.
+  finished_flags: jax.Array  # bool: [batch_size, beam_size]
+  # The current state of the autoregressive decoding caches.
+  cache: Any  # Any pytree of arrays, e.g. flax attention Cache object
+
+
+def beam_init(seed_token, batch_size, beam_size, max_decode_len, cache):
+  """Initializes the beam search state data structure."""
+  cur_index0 = jnp.array(0)
+  live_logprobs0 = jnp.tile(
+      jnp.array([0.0] + [NEG_INF] * (beam_size - 1)), [batch_size, 1]
+  )
+  finished_scores0 = jnp.ones((batch_size, beam_size)) * NEG_INF
+
+  live_seqs0 = jnp.concatenate(
+      [
+          jnp.reshape(seed_token, (batch_size, beam_size, 1)),
+          jnp.zeros((batch_size, beam_size, max_decode_len - 1), jnp.int32),
+      ],
+      axis=-1,
+  )  # (batch, beam, max_decode_len)
+
+  finished_seqs0 = jnp.zeros((batch_size, beam_size, max_decode_len), jnp.int32)
+  finished_flags0 = jnp.zeros((batch_size, beam_size), jnp.bool_)
+  beam_cache0 = apply_on_cache(lambda x: jnp.expand_dims(x, axis=0), cache)
+  return BeamState(
+      cur_index=cur_index0,
+      live_logprobs=live_logprobs0,
+      finished_scores=finished_scores0,
+      live_seqs=live_seqs0,
+      finished_seqs=finished_seqs0,
+      finished_flags=finished_flags0,
+      cache=beam_cache0,
+  )
+
+
+# Beam search routine:
+
+
+def beam_search_flat(
+    seed_token,
+    cache,
+    tokens_to_logits,
+    alpha=BEAM_SEARCH_DEFAULT_ALPHA,
+    eos=None,
+    max_decode_len=MAX_DECODE_LEN,
+    mask=None,
+):
+  """Beam search for LM.
+
+  inputs and cache is already flat! i.e. first dimention == batch*beam.
+
+  Args:
+    seed_token: array: [beam_size, 1] int32 sequence of tokens.
+    cache: flax attention cache.
+    tokens_to_logits: fast autoregressive decoder function taking single token
+      slices and cache and returning next-token logits and updated cache.
+    alpha: float: scaling factor for brevity penalty.
+    eos: array: [vocab] 1 for end-of-sentence tokens, 0 for not.
+    max_decode_len: int: maximum length of decoded translations.
+    mask: array: [vocab] binary mask for vocab. 1 to keep the prob, 0 to set the
+      prob := 0.
+
+  Returns:
+     Tuple of:
+       [beam_size, max_decode_len] top-scoring sequences
+       [beam_size] beam-search scores.
+  """
+  # We liberally annotate shape information for clarity below.
+  batch_size, beam_size = 1, seed_token.shape[0]
+  mask = mask.reshape((1, 1, -1))
+  eos = eos.reshape((1, 1, -1))
+  mask_bias = (1 - mask) * NEG_INF
+
+  # initialize beam search state
+  beam_search_init_state = beam_init(
+      seed_token, batch_size, beam_size, max_decode_len, cache
+  )
+
+  def beam_search_loop_cond_fn(state):
+    """Beam search loop termination condition."""
+    # Have we reached max decoding length?
+    not_at_end = state.cur_index < max_decode_len - 1
+
+    # Is no further progress in the beam search possible?
+    # Get the best possible scores from alive sequences.
+    min_brevity_penalty = brevity_penalty(alpha, max_decode_len)
+    best_live_scores = state.live_logprobs[:, -1:] / min_brevity_penalty
+    # Get the worst scores from finished sequences.
+    worst_finished_scores = jnp.min(
+        state.finished_scores, axis=1, keepdims=True
+    )
+    # Mask out scores from slots without any actual finished sequences.
+    worst_finished_scores = jnp.where(
+        state.finished_flags, worst_finished_scores, NEG_INF
+    )
+    # If no best possible live score is better than current worst finished
+    # scores, the search cannot improve the finished set further.
+    search_terminated = jnp.all(worst_finished_scores > best_live_scores)
+
+    # If we're not at the max decode length, and the search hasn't terminated,
+    # continue looping.
+    return not_at_end & (~search_terminated)
+
+  def beam_search_loop_body_fn(state):
+    """Beam search loop state update function."""
+    # Collect the current position slice along length to feed the fast
+    # autoregressive decoder model.  Flatten the beam dimension into batch
+    # dimension for feeding into the model.
+    # --> [batch * beam, 1]
+    flat_ids = flatten_beam_dim(
+        lax.dynamic_slice(
+            state.live_seqs, (0, 0, state.cur_index), (batch_size, beam_size, 1)
+        )
+    )
+    # Flatten beam dimension into batch to be compatible with model.
+    # {[batch, beam, ...], ...} --> {[batch * beam, ...], ...}
+    flat_cache = apply_on_cache(flatten_beam_dim, state.cache)
+
+    # Call fast-decoder model on current tokens to get next-position logits.
+    # --> [batch * beam, vocab]
+    flat_logits, new_flat_cache = tokens_to_logits(flat_ids, flat_cache)
+
+    # unflatten beam dimension
+    # [batch * beam, vocab] --> [batch, beam, vocab]
+    logits = unflatten_beam_dim(flat_logits, batch_size, beam_size)
+
+    # Unflatten beam dimension in attention cache arrays
+    # {[batch * beam, ...], ...} --> {[batch, beam, ...], ...}
+    new_cache = apply_on_cache(
+        unflatten_beam_dim, new_flat_cache, batch_size, beam_size
+    )
+
+    # Gather log probabilities from logits
+    candidate_log_probs = jax.nn.log_softmax(logits)
+    # Add new logprobs to existing prefix logprobs.
+    # --> [batch, beam, vocab]
+    log_probs = candidate_log_probs + jnp.expand_dims(
+        state.live_logprobs, axis=2
+    )
+
+    # We'll need the vocab size, gather it from the log probability dimension.
+    vocab_size = log_probs.shape[2]
+
+    # mask away some tokens.
+    log_probs += mask_bias  # [batch,beam,vocab]+[1,1,vocab]
+
+    # Each item in batch has beam_size * vocab_size candidate sequences.
+    # For each item, get the top 2*k candidates with the highest log-
+    # probabilities. We gather the top 2*K beams here so that even if the best
+    # K sequences reach EOS simultaneously, we have another K sequences
+    # remaining to continue the live beam search.
+    beams_to_keep = 2 * beam_size
+    # Flatten beam and vocab dimensions.
+    flat_log_probs = log_probs.reshape((batch_size, beam_size * vocab_size))
+    # Gather the top 2*K scores from _all_ beams.
+    # --> [batch, 2*beams], [batch, 2*beams]
+    topk_log_probs, topk_indices = lax.top_k(flat_log_probs, k=beams_to_keep)
+    # Recover the beam index by floor division.
+    topk_beam_indices = topk_indices // vocab_size
+    # Gather 2*k top beams.
+    # --> [batch, 2*beams, length]
+    topk_seq = gather_beams(
+        state.live_seqs, topk_beam_indices, batch_size, beams_to_keep
+    )
+
+    # Append the most probable 2*K token IDs to the top 2*K sequences
+    # Recover token id by modulo division and expand Id array for broadcasting.
+    # --> [batch, 2*beams, 1]
+    topk_ids = jnp.expand_dims(topk_indices % vocab_size, axis=2)
+    # Update sequences for the 2*K top-k new sequences.
+    # --> [batch, 2*beams, length]
+    topk_seq = lax.dynamic_update_slice(
+        topk_seq, topk_ids, (0, 0, state.cur_index + 1)
+    )
+
+    # Update LIVE (in-progress) sequences:
+    # Did any of these sequences reach an end marker?
+    # --> [batch, 2*beams]
+    last_token = topk_seq[:, :, state.cur_index + 1]
+    last_token = jax.nn.one_hot(last_token, vocab_size, dtype=jnp.bfloat16)
+
+    # any([batch, 2b, vocab] * [1, 1, vocab], axis=-1) == [batch, 2b]
+    newly_finished = jnp.any(last_token * eos, axis=-1)
+
+    # To prevent these newly finished sequences from being added to the LIVE
+    # set of active beam search sequences, set their log probs to a very large
+    # negative value.
+    new_log_probs = topk_log_probs + newly_finished * NEG_INF
+    # Determine the top k beam indices (from top 2*k beams) from log probs.
+    # --> [batch, beams]
+    _, new_topk_indices = lax.top_k(new_log_probs, k=beam_size)
+    new_topk_indices = jnp.flip(new_topk_indices, axis=1)
+    # Gather the top k beams (from top 2*k beams).
+    # --> [batch, beams, length], [batch, beams]
+    top_alive_seq, top_alive_log_probs = gather_beams(
+        [topk_seq, new_log_probs], new_topk_indices, batch_size, beam_size
+    )
+
+    # Determine the top k beam indices from the original set of all beams.
+    # --> [batch, beams]
+    top_alive_indices = gather_beams(
+        topk_beam_indices, new_topk_indices, batch_size, beam_size
+    )
+    # With these, gather the top k beam-associated caches.
+    # --> {[batch, beams, ...], ...}
+    top_alive_cache = apply_on_cache(
+        gather_beams, new_cache, top_alive_indices, batch_size, beam_size
+    )
+
+    # Update FINISHED (reached end of sentence) sequences:
+    # Calculate new seq scores from log probabilities.
+    new_scores = topk_log_probs / brevity_penalty(alpha, state.cur_index + 1)
+    # Mask out the still unfinished sequences by adding large negative value.
+    # --> [batch, 2*beams]
+    new_scores += (~newly_finished) * NEG_INF
+
+    # Combine sequences, scores, and flags along the beam dimension and compare
+    # new finished sequence scores to existing finished scores and select the
+    # best from the new set of beams.
+    finished_seqs = jnp.concatenate(  # --> [batch, 3*beams, length]
+        [state.finished_seqs, topk_seq], axis=1
+    )
+    finished_scores = jnp.concatenate(  # --> [batch, 3*beams]
+        [state.finished_scores, new_scores], axis=1
+    )
+    finished_flags = jnp.concatenate(  # --> [batch, 3*beams]
+        [state.finished_flags, newly_finished], axis=1
+    )
+    # --> [batch, beams, length], [batch, beams], [batch, beams]
+    top_finished_seq, top_finished_scores, top_finished_flags = (
+        gather_topk_beams(
+            [finished_seqs, finished_scores, finished_flags],
+            finished_scores,
+            batch_size,
+            beam_size,
+        )
+    )
+
+    return BeamState(
+        cur_index=state.cur_index + 1,
+        live_logprobs=top_alive_log_probs,
+        finished_scores=top_finished_scores,
+        live_seqs=top_alive_seq,
+        finished_seqs=top_finished_seq,
+        finished_flags=top_finished_flags,
+        cache=top_alive_cache,
+    )
+
+  # Run while loop and get final beam search state.
+  final_state = lax.while_loop(
+      beam_search_loop_cond_fn, beam_search_loop_body_fn, beam_search_init_state
+  )
+
+  # Account for the edge-case where there are no finished sequences for a
+  # particular batch item. If so, return live sequences for that batch item.
+  # --> [batch]
+  none_finished = jnp.any(final_state.finished_flags, axis=1)
+  # --> [batch, beams, length]
+  finished_seqs = jnp.where(
+      none_finished[:, None, None],
+      final_state.finished_seqs,
+      final_state.live_seqs,
+  )
+  # --> [batch, beams]
+  finished_scores = jnp.where(
+      none_finished[:, None],
+      final_state.finished_scores,
+      final_state.live_logprobs,
+  )
+
+  finished_seqs = jnp.reshape(finished_seqs, (beam_size, max_decode_len))
+  finished_scores = jnp.reshape(finished_scores, (beam_size,))
+
+  final_cache = apply_on_cache(flatten_beam_dim, final_state.cache)
+  return finished_seqs, finished_scores, final_cache

ag4masses/alphageometry/dd.py

@@ -0,0 +1,1156 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Implements Deductive Database (DD)."""
+
+# pylint: disable=g-multiple-import,g-importing-member
+from collections import defaultdict
+import time
+from typing import Any, Callable, Generator
+
+import geometry as gm
+import graph as gh
+import graph_utils as utils
+import numericals as nm
+import problem as pr
+from problem import Dependency, EmptyDependency
+
+
+def intersect1(set1: set[Any], set2: set[Any]) -> Any:
+  for x in set1:
+    if x in set2:
+      return x
+  return None
+
+
+def diff_point(l: gm.Line, a: gm.Point) -> gm.Point:
+  for x in l.neighbors(gm.Point):
+    if x != a:
+      return x
+  return None
+
+
+# pylint: disable=protected-access
+# pylint: disable=unused-argument
+
+
+def match_eqratio_eqratio_eqratio(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match eqratio a b c d m n p q, eqratio c d e f p q r u => eqratio a b e f m n r u."""
+  for m1 in g.type2nodes[gm.Value]:
+    for m2 in g.type2nodes[gm.Value]:
+      rats1 = []
+      for rat in m1.neighbors(gm.Ratio):
+        l1, l2 = rat.lengths
+        if l1 is None or l2 is None:
+          continue
+        rats1.append((l1, l2))
+
+      rats2 = []
+      for rat in m2.neighbors(gm.Ratio):
+        l1, l2 = rat.lengths
+        if l1 is None or l2 is None:
+          continue
+        rats2.append((l1, l2))
+
+      pairs = []
+      for (l1, l2), (l3, l4) in utils.cross(rats1, rats2):
+        if l2 == l3:
+          pairs.append((l1, l2, l4))
+
+      for (l1, l12, l2), (l3, l34, l4) in utils.comb2(pairs):
+        if (l1, l12, l2) == (l3, l34, l4):
+          continue
+        if l1 == l2 or l3 == l4:
+          continue
+        if l1 == l12 or l12 == l2 or l3 == l34 or l4 == l34:
+          continue
+        # d12 - d1 = d34 - d3 = m1
+        # d2 - d12 = d4 - d34 = m2
+        # => d2 - d1 = d4 - d3 (= m1+m2)
+        a, b = g.two_points_of_length(l1)
+        c, d = g.two_points_of_length(l12)
+        m, n = g.two_points_of_length(l3)
+        p, q = g.two_points_of_length(l34)
+        # eqangle a b c d m n p q
+        e, f = g.two_points_of_length(l2)
+        r, u = g.two_points_of_length(l4)
+        yield dict(zip('abcdefmnpqru', [a, b, c, d, e, f, m, n, p, q, r, u]))
+
+
+def match_eqangle_eqangle_eqangle(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match eqangle a b c d m n p q, eqangle c d e f p q r u => eqangle a b e f m n r u."""
+  for m1 in g.type2nodes[gm.Measure]:
+    for m2 in g.type2nodes[gm.Measure]:
+      angs1 = []
+      for ang in m1.neighbors(gm.Angle):
+        d1, d2 = ang.directions
+        if d1 is None or d2 is None:
+          continue
+        angs1.append((d1, d2))
+
+      angs2 = []
+      for ang in m2.neighbors(gm.Angle):
+        d1, d2 = ang.directions
+        if d1 is None or d2 is None:
+          continue
+        angs2.append((d1, d2))
+
+      pairs = []
+      for (d1, d2), (d3, d4) in utils.cross(angs1, angs2):
+        if d2 == d3:
+          pairs.append((d1, d2, d4))
+
+      for (d1, d12, d2), (d3, d34, d4) in utils.comb2(pairs):
+        if (d1, d12, d2) == (d3, d34, d4):
+          continue
+        if d1 == d2 or d3 == d4:
+          continue
+        if d1 == d12 or d12 == d2 or d3 == d34 or d4 == d34:
+          continue
+        # d12 - d1 = d34 - d3 = m1
+        # d2 - d12 = d4 - d34 = m2
+        # => d2 - d1 = d4 - d3
+        a, b = g.two_points_on_direction(d1)
+        c, d = g.two_points_on_direction(d12)
+        m, n = g.two_points_on_direction(d3)
+        p, q = g.two_points_on_direction(d34)
+        # eqangle a b c d m n p q
+        e, f = g.two_points_on_direction(d2)
+        r, u = g.two_points_on_direction(d4)
+        yield dict(zip('abcdefmnpqru', [a, b, c, d, e, f, m, n, p, q, r, u]))
+
+
+def match_perp_perp_npara_eqangle(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match perp A B C D, perp E F G H, npara A B E F => eqangle A B E F C D G H."""
+  dpairs = []
+  for ang in g.vhalfpi.neighbors(gm.Angle):
+    d1, d2 = ang.directions
+    if d1 is None or d2 is None:
+      continue
+    dpairs.append((d1, d2))
+
+  for (d1, d2), (d3, d4) in utils.comb2(dpairs):
+    a, b = g.two_points_on_direction(d1)
+    c, d = g.two_points_on_direction(d2)
+    m, n = g.two_points_on_direction(d3)
+    p, q = g.two_points_on_direction(d4)
+    if g.check_npara([a, b, m, n]):
+      if ({a, b}, {c, d}) == ({m, n}, {p, q}):
+        continue
+      if ({a, b}, {c, d}) == ({p, q}, {m, n}):
+        continue
+
+      yield dict(zip('ABCDEFGH', [a, b, c, d, m, n, p, q]))
+
+
+def match_circle_coll_eqangle_midp(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match circle O A B C, coll M B C, eqangle A B A C O B O M => midp M B C."""
+  for p, a, b, c in g.all_circles():
+    ab = g._get_line(a, b)
+    if ab is None:
+      continue
+    if ab.val is None:
+      continue
+    ac = g._get_line(a, c)
+    if ac is None:
+      continue
+    if ac.val is None:
+      continue
+    pb = g._get_line(p, b)
+    if pb is None:
+      continue
+    if pb.val is None:
+      continue
+
+    bc = g._get_line(b, c)
+    if bc is None:
+      continue
+    bc_points = bc.neighbors(gm.Point, return_set=True)
+
+    anga, _ = g._get_angle(ab.val, ac.val)
+
+    for angp in pb.val.neighbors(gm.Angle):
+      if not g.is_equal(anga, angp):
+        continue
+
+      _, d = angp.directions
+      for l in d.neighbors(gm.Line):
+        l_points = l.neighbors(gm.Point, return_set=True)
+        m = intersect1(bc_points, l_points)
+        if m is not None:
+          yield dict(zip('ABCMO', [a, b, c, m, p]))
+
+
+def match_midp_perp_cong(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match midp M A B, perp O M A B => cong O A O B."""
+  for m, a, b in g.all_midps():
+    ab = g._get_line(a, b)
+    for l in m.neighbors(gm.Line):
+      if g.check_perpl(l, ab):
+        for o in l.neighbors(gm.Point):
+          if o != m:
+            yield dict(zip('ABMO', [a, b, m, o]))
+
+
+def match_cyclic_eqangle_cong(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match cyclic A B C P Q R, eqangle C A C B R P R Q => cong A B P Q."""
+  for c in g.type2nodes[gm.Circle]:
+    ps = c.neighbors(gm.Point)
+    for (a, b, c), (x, y, z) in utils.comb2(list(utils.perm3(ps))):
+      if {a, b, c} == {x, y, z}:
+        continue
+      if g.check_eqangle([c, a, c, b, z, x, z, y]):
+        yield dict(zip('ABCPQR', [a, b, c, x, y, z]))
+
+
+def match_circle_eqangle_perp(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match circle O A B C, eqangle A X A B C A C B => perp O A A X."""
+  for p, a, b, c in g.all_circles():
+    ca = g._get_line(c, a)
+    if ca is None:
+      continue
+    cb = g._get_line(c, b)
+    if cb is None:
+      continue
+    ab = g._get_line(a, b)
+    if ab is None:
+      continue
+
+    if ca.val is None:
+      continue
+    if cb.val is None:
+      continue
+    if ab.val is None:
+      continue
+
+    c_ang, _ = g._get_angle(cb.val, ca.val)
+    if c_ang is None:
+      continue
+
+    for ang in ab.val.neighbors(gm.Angle):
+      if g.is_equal(ang, c_ang):
+        _, d = ang.directions
+        for l in d.neighbors(gm.Line):
+          if a not in l.neighbors(gm.Point):
+            continue
+          x = diff_point(l, a)
+          if x is None:
+            continue
+          yield dict(zip('OABCX', [p, a, b, c, x]))
+        break
+
+
+def match_circle_perp_eqangle(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match circle O A B C, perp O A A X => eqangle A X A B C A C B."""
+  for p, a, b, c in g.all_circles():
+    pa = g._get_line(p, a)
+    if pa is None:
+      continue
+    if pa.val is None:
+      continue
+    for l in a.neighbors(gm.Line):
+      if g.check_perpl(pa, l):
+        x = diff_point(l, a)
+        if x is not None:
+          yield dict(zip('OABCX', [p, a, b, c, x]))
+
+
+def match_perp_perp_ncoll_para(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match perp A B C D, perp C D E F, ncoll A B E => para A B E F."""
+  d2d = defaultdict(list)
+  for ang in g.vhalfpi.neighbors(gm.Angle):
+    d1, d2 = ang.directions
+    if d1 is None or d2 is None:
+      continue
+    d2d[d1] += [d2]
+    d2d[d2] += [d1]
+
+  for x, ys in d2d.items():
+    if len(ys) < 2:
+      continue
+    c, d = g.two_points_on_direction(x)
+    for y1, y2 in utils.comb2(ys):
+      a, b = g.two_points_on_direction(y1)
+      e, f = g.two_points_on_direction(y2)
+      if nm.check_ncoll([a.num, b.num, e.num]):
+        yield dict(zip('ABCDEF', [a, b, c, d, e, f]))
+
+
+def match_eqangle6_ncoll_cong(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match eqangle6 A O A B B A B O, ncoll O A B => cong O A O B."""
+  for a in g.type2nodes[gm.Point]:
+    for b, c in utils.comb2(g.type2nodes[gm.Point]):
+      if a == b or a == c:
+        continue
+      if g.check_eqangle([b, a, b, c, c, b, c, a]):
+        if g.check_ncoll([a, b, c]):
+          yield dict(zip('OAB', [a, b, c]))
+
+
+def match_eqangle_perp_perp(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match eqangle A B P Q C D U V, perp P Q U V => perp A B C D."""
+  for ang in g.vhalfpi.neighbors(gm.Angle):
+    # d1 perp d2
+    d1, d2 = ang.directions
+    if d1 is None or d2 is None:
+      continue
+    for d3, d4 in utils.comb2(g.type2nodes[gm.Direction]):
+      if d1 == d3 or d2 == d4:
+        continue
+      # if d1 - d3 = d2 - d4 => d3 perp d4
+      a13, a31 = g._get_angle(d1, d3)
+      a24, a42 = g._get_angle(d2, d4)
+      if a13 is None or a31 is None or a24 is None or a42 is None:
+        continue
+      if g.is_equal(a13, a24) and g.is_equal(a31, a42):
+        a, b = g.two_points_on_direction(d1)
+        c, d = g.two_points_on_direction(d2)
+        m, n = g.two_points_on_direction(d3)
+        p, q = g.two_points_on_direction(d4)
+        yield dict(zip('ABCDPQUV', [m, n, p, q, a, b, c, d]))
+
+
+def match_eqangle_ncoll_cyclic(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match eqangle6 P A P B Q A Q B, ncoll P Q A B => cyclic A B P Q."""
+  for l1, l2, l3, l4 in g.all_eqangles_distinct_linepairss():
+    if len(set([l1, l2, l3, l4])) < 4:
+      continue  # they all must be distinct.
+
+    p1s = l1.neighbors(gm.Point, return_set=True)
+    p2s = l2.neighbors(gm.Point, return_set=True)
+    p3s = l3.neighbors(gm.Point, return_set=True)
+    p4s = l4.neighbors(gm.Point, return_set=True)
+
+    p = intersect1(p1s, p2s)
+    if not p:
+      continue
+    q = intersect1(p3s, p4s)
+    if not q:
+      continue
+    a = intersect1(p1s, p3s)
+    if not a:
+      continue
+    b = intersect1(p2s, p4s)
+    if not b:
+      continue
+    if len(set([a, b, p, q])) < 4:
+      continue
+
+    if not g.check_ncoll([a, b, p, q]):
+      continue
+
+    yield dict(zip('ABPQ', [a, b, p, q]))
+
+
+def match_eqangle_para(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match eqangle A B P Q C D P Q => para A B C D."""
+  for measure in g.type2nodes[gm.Measure]:
+    angs = measure.neighbors(gm.Angle)
+    d12, d21 = defaultdict(list), defaultdict(list)
+    for ang in angs:
+      d1, d2 = ang.directions
+      if d1 is None or d2 is None:
+        continue
+      d12[d1].append(d2)
+      d21[d2].append(d1)
+
+    for d1, d2s in d12.items():
+      a, b = g.two_points_on_direction(d1)
+      for d2, d3 in utils.comb2(d2s):
+        c, d = g.two_points_on_direction(d2)
+        e, f = g.two_points_on_direction(d3)
+        yield dict(zip('ABCDPQ', [c, d, e, f, a, b]))
+
+
+def match_cyclic_eqangle(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match cyclic A B P Q => eqangle P A P B Q A Q B."""
+  record = set()
+  for a, b, c, d in g_matcher('cyclic'):
+    if (a, b, c, d) in record:
+      continue
+    record.add((a, b, c, d))
+    record.add((a, b, d, c))
+    record.add((b, a, c, d))
+    record.add((b, a, d, c))
+    yield dict(zip('ABPQ', [a, b, c, d]))
+
+
+def rotate_simtri(
+    a: gm.Point, b: gm.Point, c: gm.Point, x: gm.Point, y: gm.Point, z: gm.Point
+) -> Generator[tuple[gm.Point, ...], None, None]:
+  """Rotate points around for similar triangle predicates."""
+  yield (z, y, x, c, b, a)
+  for p in [
+      (b, c, a, y, z, x),
+      (c, a, b, z, x, y),
+      (x, y, z, a, b, c),
+      (y, z, x, b, c, a),
+      (z, x, y, c, a, b),
+  ]:
+    yield p
+    yield p[::-1]
+
+
+def match_cong_cong_cong_cyclic(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match cong O A O B, cong O B O C, cong O C O D => cyclic A B C D."""
+  for l in g.type2nodes[gm.Length]:
+    p2p = defaultdict(list)
+    for s in l.neighbors(gm.Segment):
+      a, b = s.points
+      p2p[a].append(b)
+      p2p[b].append(a)
+
+    for p, ps in p2p.items():
+      if len(ps) >= 4:
+        for a, b, c, d in utils.comb4(ps):
+          yield dict(zip('OABCD', [p, a, b, c, d]))
+
+
+def match_cong_cong_cong_ncoll_contri(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match cong A B P Q, cong B C Q R, cong C A R P, ncoll A B C => contri* A B C P Q R."""
+  record = set()
+  for a, b, p, q in g_matcher('cong'):
+    for c in g.type2nodes[gm.Point]:
+      for r in g.type2nodes[gm.Point]:
+        if any([x in record for x in rotate_simtri(a, b, c, p, q, r)]):
+          continue
+        if not g.check_ncoll([a, b, c]):
+          continue
+        if g.check_cong([b, c, q, r]) and g.check_cong([c, a, r, p]):
+          record.add((a, b, c, p, q, r))
+          yield dict(zip('ABCPQR', [a, b, c, p, q, r]))
+
+
+def match_cong_cong_eqangle6_ncoll_contri(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match cong A B P Q, cong B C Q R, eqangle6 B A B C Q P Q R, ncoll A B C => contri* A B C P Q R."""
+  record = set()
+  for a, b, p, q in g_matcher('cong'):
+    for c in g.type2nodes[gm.Point]:
+      if c in (a, b):
+        continue
+      for r in g.type2nodes[gm.Point]:
+        if r in (p, q):
+          continue
+
+        in_record = False
+        for x in [
+            (c, b, a, r, q, p),
+            (p, q, r, a, b, c),
+            (r, q, p, c, b, a),
+        ]:
+          if x in record:
+            in_record = True
+            break
+
+        if in_record:
+          continue
+
+        if not g.check_cong([b, c, q, r]):
+          continue
+        if not g.check_ncoll([a, b, c]):
+          continue
+
+        if nm.same_clock(a.num, b.num, c.num, p.num, q.num, r.num):
+          if g.check_eqangle([b, a, b, c, q, p, q, r]):
+            record.add((a, b, c, p, q, r))
+            yield dict(zip('ABCPQR', [a, b, c, p, q, r]))
+        else:
+          if g.check_eqangle([b, a, b, c, q, r, q, p]):
+            record.add((a, b, c, p, q, r))
+            yield dict(zip('ABCPQR', [a, b, c, p, q, r]))
+
+
+def match_eqratio6_eqangle6_ncoll_simtri(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match eqratio6 B A B C Q P Q R, eqratio6 C A C B R P R Q, ncoll A B C => simtri* A B C P Q R."""
+  enums = g_matcher('eqratio6')
+
+  record = set()
+  for b, a, b, c, q, p, q, r in enums:  # pylint: disable=redeclared-assigned-name,unused-variable
+    if (a, b, c) == (p, q, r):
+      continue
+    if any([x in record for x in rotate_simtri(a, b, c, p, q, r)]):
+      continue
+    if not g.check_ncoll([a, b, c]):
+      continue
+
+    if nm.same_clock(a.num, b.num, c.num, p.num, q.num, r.num):
+      if g.check_eqangle([b, a, b, c, q, p, q, r]):
+        record.add((a, b, c, p, q, r))
+        yield dict(zip('ABCPQR', [a, b, c, p, q, r]))
+    elif g.check_eqangle([b, a, b, c, q, r, q, p]):
+      record.add((a, b, c, p, q, r))
+      yield dict(zip('ABCPQR', [a, b, c, p, q, r]))
+
+
+def match_eqangle6_eqangle6_ncoll_simtri(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match eqangle6 B A B C Q P Q R, eqangle6 C A C B R P R Q, ncoll A B C => simtri A B C P Q R."""
+  enums = g_matcher('eqangle6')
+
+  record = set()
+  for b, a, b, c, q, p, q, r in enums:  # pylint: disable=redeclared-assigned-name,unused-variable
+    if (a, b, c) == (p, q, r):
+      continue
+    if any([x in record for x in rotate_simtri(a, b, c, p, q, r)]):
+      continue
+    if not g.check_eqangle([c, a, c, b, r, p, r, q]):
+      continue
+    if not g.check_ncoll([a, b, c]):
+      continue
+
+    mapping = dict(zip('ABCPQR', [a, b, c, p, q, r]))
+    record.add((a, b, c, p, q, r))
+    yield mapping
+
+
+def match_eqratio6_eqratio6_ncoll_simtri(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match eqratio6 B A B C Q P Q R, eqratio6 C A C B R P R Q, ncoll A B C => simtri* A B C P Q R."""
+  enums = g_matcher('eqratio6')
+
+  record = set()
+  for b, a, b, c, q, p, q, r in enums:  # pylint: disable=redeclared-assigned-name,unused-variable
+    if (a, b, c) == (p, q, r):
+      continue
+    if any([x in record for x in rotate_simtri(a, b, c, p, q, r)]):
+      continue
+    if not g.check_eqratio([c, a, c, b, r, p, r, q]):
+      continue
+    if not g.check_ncoll([a, b, c]):
+      continue
+
+    mapping = dict(zip('ABCPQR', [a, b, c, p, q, r]))
+    record.add((a, b, c, p, q, r))
+    yield mapping
+
+
+def match_eqangle6_eqangle6_ncoll_simtri2(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match eqangle6 B A B C Q R Q P, eqangle6 C A C B R Q R P, ncoll A B C => simtri2 A B C P Q R."""
+  enums = g_matcher('eqangle6')
+
+  record = set()
+  for b, a, b, c, q, r, q, p in enums:  # pylint: disable=redeclared-assigned-name,unused-variable
+    if (a, b, c) == (p, q, r):
+      continue
+    if any([x in record for x in rotate_simtri(a, b, c, p, q, r)]):
+      continue
+    if not g.check_eqangle([c, a, c, b, r, q, r, p]):
+      continue
+    if not g.check_ncoll([a, b, c]):
+      continue
+
+    mapping = dict(zip('ABCPQR', [a, b, c, p, q, r]))
+    record.add((a, b, c, p, q, r))
+    yield mapping
+
+
+def rotate_contri(
+    a: gm.Point, b: gm.Point, c: gm.Point, x: gm.Point, y: gm.Point, z: gm.Point
+) -> Generator[tuple[gm.Point, ...], None, None]:
+  for p in [(b, a, c, y, x, z), (x, y, z, a, b, c), (y, x, z, b, a, c)]:
+    yield p
+
+
+def match_eqangle6_eqangle6_ncoll_cong_contri(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match eqangle6 B A B C Q P Q R, eqangle6 C A C B R P R Q, ncoll A B C, cong A B P Q => contri A B C P Q R."""
+  enums = g_matcher('eqangle6')
+
+  record = set()
+  for b, a, b, c, q, p, q, r in enums:  # pylint: disable=redeclared-assigned-name,unused-variable
+    if not g.check_cong([a, b, p, q]):
+      continue
+    if (a, b, c) == (p, q, r):
+      continue
+    if any([x in record for x in rotate_contri(a, b, c, p, q, r)]):
+      continue
+    if not g.check_eqangle([c, a, c, b, r, p, r, q]):
+      continue
+
+    if not g.check_ncoll([a, b, c]):
+      continue
+
+    mapping = dict(zip('ABCPQR', [a, b, c, p, q, r]))
+    record.add((a, b, c, p, q, r))
+    yield mapping
+
+
+def match_eqratio6_eqratio6_ncoll_cong_contri(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match eqratio6 B A B C Q P Q R, eqratio6 C A C B R P R Q, ncoll A B C, cong A B P Q => contri* A B C P Q R."""
+  enums = g_matcher('eqratio6')
+
+  record = set()
+  for b, a, b, c, q, p, q, r in enums:  # pylint: disable=redeclared-assigned-name,unused-variable
+    if not g.check_cong([a, b, p, q]):
+      continue
+    if (a, b, c) == (p, q, r):
+      continue
+    if any([x in record for x in rotate_contri(a, b, c, p, q, r)]):
+      continue
+    if not g.check_eqratio([c, a, c, b, r, p, r, q]):
+      continue
+
+    if not g.check_ncoll([a, b, c]):
+      continue
+
+    mapping = dict(zip('ABCPQR', [a, b, c, p, q, r]))
+    record.add((a, b, c, p, q, r))
+    yield mapping
+
+
+def match_eqangle6_eqangle6_ncoll_cong_contri2(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match eqangle6 B A B C Q R Q P, eqangle6 C A C B R Q R P, ncoll A B C, cong A B P Q => contri2 A B C P Q R."""
+  enums = g_matcher('eqangle6')
+
+  record = set()
+  for b, a, b, c, q, r, q, p in enums:  # pylint: disable=redeclared-assigned-name,unused-variable
+    if not g.check_cong([a, b, p, q]):
+      continue
+    if (a, b, c) == (p, q, r):
+      continue
+    if any([x in record for x in rotate_contri(a, b, c, p, q, r)]):
+      continue
+    if not g.check_eqangle([c, a, c, b, r, q, r, p]):
+      continue
+    if not g.check_ncoll([a, b, c]):
+      continue
+
+    mapping = dict(zip('ABCPQR', [a, b, c, p, q, r]))
+    record.add((a, b, c, p, q, r))
+    yield mapping
+
+
+def match_eqratio6_coll_ncoll_eqangle6(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match eqratio6 d b d c a b a c, coll d b c, ncoll a b c => eqangle6 a b a d a d a c."""
+  records = set()
+  for b, d, c in g_matcher('coll'):
+    for a in g.all_points():
+      if g.check_coll([a, b, c]):
+        continue
+      if (a, b, d, c) in records or (a, c, d, b) in records:
+        continue
+      records.add((a, b, d, c))
+
+      if g.check_eqratio([d, b, d, c, a, b, a, c]):
+        yield dict(zip('abcd', [a, b, c, d]))
+
+
+def match_eqangle6_coll_ncoll_eqratio6(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match eqangle6 a b a d a d a c, coll d b c, ncoll a b c => eqratio6 d b d c a b a c."""
+  records = set()
+  for b, d, c in g_matcher('coll'):
+    for a in g.all_points():
+      if g.check_coll([a, b, c]):
+        continue
+      if (a, b, d, c) in records or (a, c, d, b) in records:
+        continue
+      records.add((a, b, d, c))
+
+      if g.check_eqangle([a, b, a, d, a, d, a, c]):
+        yield dict(zip('abcd', [a, b, c, d]))
+
+
+def match_eqangle6_ncoll_cyclic(
+    g: gh.Graph,
+    g_matcher: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem,
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match eqangle6 P A P B Q A Q B, ncoll P Q A B => cyclic A B P Q."""
+  for a, b, a, c, x, y, x, z in g_matcher('eqangle6'):  # pylint: disable=redeclared-assigned-name,unused-variable
+    if (b, c) != (y, z) or a == x:
+      continue
+    if nm.check_ncoll([x.num for x in [a, b, c, x]]):
+      yield dict(zip('ABPQ', [b, c, a, x]))
+
+
+def match_all(
+    name: str, g: gh.Graph
+) -> Generator[tuple[gm.Point, ...], None, None]:
+  """Match all instances of a certain relation."""
+  if name in ['ncoll', 'npara', 'nperp']:
+    return []
+  if name == 'coll':
+    return g.all_colls()
+  if name == 'para':
+    return g.all_paras()
+  if name == 'perp':
+    return g.all_perps()
+  if name == 'cong':
+    return g.all_congs()
+  if name == 'eqangle':
+    return g.all_eqangles_8points()
+  if name == 'eqangle6':
+    return g.all_eqangles_6points()
+  if name == 'eqratio':
+    return g.all_eqratios_8points()
+  if name == 'eqratio6':
+    return g.all_eqratios_6points()
+  if name == 'cyclic':
+    return g.all_cyclics()
+  if name == 'midp':
+    return g.all_midps()
+  if name == 'circle':
+    return g.all_circles()
+  raise ValueError(f'Unrecognize {name}')
+
+
+def cache_match(
+    graph: gh.Graph,
+) -> Callable[str, list[tuple[gm.Point, ...]]]:
+  """Cache throughout one single BFS level."""
+  cache = {}
+
+  def match_fn(name: str) -> list[tuple[gm.Point, ...]]:
+    if name in cache:
+      return cache[name]
+
+    result = list(match_all(name, graph))
+    cache[name] = result
+    return result
+
+  return match_fn
+
+
+def try_to_map(
+    clause_enum: list[tuple[pr.Clause, list[tuple[gm.Point, ...]]]],
+    mapping: dict[str, gm.Point],
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Recursively try to match the remaining points given current mapping."""
+  if not clause_enum:
+    yield mapping
+    return
+
+  clause, enum = clause_enum[0]
+  for points in enum:
+    mpcpy = dict(mapping)
+
+    fail = False
+    for p, a in zip(points, clause.args):
+      if a in mpcpy and mpcpy[a] != p or p in mpcpy and mpcpy[p] != a:
+        fail = True
+        break
+      mpcpy[a] = p
+      mpcpy[p] = a
+
+    if fail:
+      continue
+
+    for m in try_to_map(clause_enum[1:], mpcpy):
+      yield m
+
+
+def match_generic(
+    g: gh.Graph,
+    cache: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match any generic rule that is not one of the above match_*() rules."""
+  clause2enum = {}
+
+  clauses = []
+  numerical_checks = []
+  for clause in theorem.premise:
+    if clause.name in ['ncoll', 'npara', 'nperp', 'sameside']:
+      numerical_checks.append(clause)
+      continue
+
+    enum = cache(clause.name)
+    if len(enum) == 0:  # pylint: disable=g-explicit-length-test
+      return 0
+
+    clause2enum[clause] = enum
+    clauses.append((len(set(clause.args)), clause))
+
+  clauses = sorted(clauses, key=lambda x: x[0], reverse=True)
+  _, clauses = zip(*clauses)
+
+  for mapping in try_to_map([(c, clause2enum[c]) for c in clauses], {}):
+    if not mapping:
+      continue
+
+    checks_ok = True
+    for check in numerical_checks:
+      args = [mapping[a] for a in check.args]
+      if check.name == 'ncoll':
+        checks_ok = g.check_ncoll(args)
+      elif check.name == 'npara':
+        checks_ok = g.check_npara(args)
+      elif check.name == 'nperp':
+        checks_ok = g.check_nperp(args)
+      elif check.name == 'sameside':
+        checks_ok = g.check_sameside(args)
+      if not checks_ok:
+        break
+    if not checks_ok:
+      continue
+
+    yield mapping
+
+
+BUILT_IN_FNS = {
+    'cong_cong_cong_cyclic': match_cong_cong_cong_cyclic,
+    'cong_cong_cong_ncoll_contri*': match_cong_cong_cong_ncoll_contri,
+    'cong_cong_eqangle6_ncoll_contri*': match_cong_cong_eqangle6_ncoll_contri,
+    'eqangle6_eqangle6_ncoll_simtri': match_eqangle6_eqangle6_ncoll_simtri,
+    'eqangle6_eqangle6_ncoll_cong_contri': (
+        match_eqangle6_eqangle6_ncoll_cong_contri
+    ),  # pylint: disable=line-too-long
+    'eqangle6_eqangle6_ncoll_simtri2': match_eqangle6_eqangle6_ncoll_simtri2,
+    'eqangle6_eqangle6_ncoll_cong_contri2': (
+        match_eqangle6_eqangle6_ncoll_cong_contri2
+    ),  # pylint: disable=line-too-long
+    'eqratio6_eqratio6_ncoll_simtri*': match_eqratio6_eqratio6_ncoll_simtri,
+    'eqratio6_eqratio6_ncoll_cong_contri*': (
+        match_eqratio6_eqratio6_ncoll_cong_contri
+    ),  # pylint: disable=line-too-long
+    'eqangle_para': match_eqangle_para,
+    'eqangle_ncoll_cyclic': match_eqangle_ncoll_cyclic,
+    'eqratio6_eqangle6_ncoll_simtri*': match_eqratio6_eqangle6_ncoll_simtri,
+    'eqangle_perp_perp': match_eqangle_perp_perp,
+    'eqangle6_ncoll_cong': match_eqangle6_ncoll_cong,
+    'perp_perp_ncoll_para': match_perp_perp_ncoll_para,
+    'circle_perp_eqangle': match_circle_perp_eqangle,
+    'circle_eqangle_perp': match_circle_eqangle_perp,
+    'cyclic_eqangle_cong': match_cyclic_eqangle_cong,
+    'midp_perp_cong': match_midp_perp_cong,
+    'perp_perp_npara_eqangle': match_perp_perp_npara_eqangle,
+    'cyclic_eqangle': match_cyclic_eqangle,
+    'eqangle_eqangle_eqangle': match_eqangle_eqangle_eqangle,
+    'eqratio_eqratio_eqratio': match_eqratio_eqratio_eqratio,
+    'eqratio6_coll_ncoll_eqangle6': match_eqratio6_coll_ncoll_eqangle6,
+    'eqangle6_coll_ncoll_eqratio6': match_eqangle6_coll_ncoll_eqratio6,
+    'eqangle6_ncoll_cyclic': match_eqangle6_ncoll_cyclic,
+}
+
+
+SKIP_THEOREMS = set()
+
+
+def set_skip_theorems(theorems: set[str]) -> None:
+  SKIP_THEOREMS.update(theorems)
+
+
+MAX_BRANCH = 50_000
+
+
+def match_one_theorem(
+    g: gh.Graph,
+    cache: Callable[str, list[tuple[gm.Point, ...]]],
+    theorem: pr.Theorem
+) -> Generator[dict[str, gm.Point], None, None]:
+  """Match all instances of a single theorem (rule)."""
+  if cache is None:
+    cache = cache_match(g)
+
+  if theorem.name in SKIP_THEOREMS:
+    return []
+
+  if theorem.name.split('_')[-1] in SKIP_THEOREMS:
+    return []
+
+  if theorem.name in BUILT_IN_FNS:
+    mps = BUILT_IN_FNS[theorem.name](g, cache, theorem)
+  else:
+    mps = match_generic(g, cache, theorem)
+
+  mappings = []
+  for mp in mps:
+    mappings.append(mp)
+    if len(mappings) > MAX_BRANCH:  # cap branching at this number.
+      break
+
+  return mappings
+
+
+def match_all_theorems(
+    g: gh.Graph, theorems: list[pr.Theorem], goal: pr.Clause
+) -> dict[pr.Theorem, dict[pr.Theorem, dict[str, gm.Point]]]:
+  """Match all instances of all theorems (rules)."""
+  cache = cache_match(g)
+  # for BFS, collect all potential matches
+  # and then do it at the same time
+  theorem2mappings = {}
+
+  # Step 1: list all matches
+  for _, theorem in theorems.items():
+    name = theorem.name
+    if name.split('_')[-1] in [
+        'acompute',
+        'rcompute',
+        'fixl',
+        'fixc',
+        'fixb',
+        'fixt',
+        'fixp',
+    ]:
+      if goal and goal.name != name:
+        continue
+
+    mappings = match_one_theorem(g, cache, theorem)
+    if len(mappings):  # pylint: disable=g-explicit-length-test
+      theorem2mappings[theorem] = list(mappings)
+  return theorem2mappings
+
+
+def bfs_one_level(
+    g: gh.Graph,
+    theorems: list[pr.Theorem],
+    level: int,
+    controller: pr.Problem,
+    verbose: bool = False,
+    nm_check: bool = False,
+    timeout: int = 600,
+) -> tuple[
+    list[pr.Dependency],
+    dict[str, list[tuple[gm.Point, ...]]],
+    dict[str, list[tuple[gm.Point, ...]]],
+    int,
+]:
+  """Forward deduce one breadth-first level."""
+
+  # Step 1: match all theorems:
+  theorem2mappings = match_all_theorems(g, theorems, controller.goal)
+
+  # Step 2: traceback for each deduce:
+  theorem2deps = {}
+  t0 = time.time()
+  for theorem, mappings in theorem2mappings.items():
+    if time.time() - t0 > timeout:
+      break
+    mp_deps = []
+    for mp in mappings:
+      deps = EmptyDependency(level=level, rule_name=theorem.rule_name)
+      fail = False  # finding why deps might fail.
+
+      for p in theorem.premise:
+        p_args = [mp[a] for a in p.args]
+        # Trivial deps.
+        if p.name == 'cong':
+          a, b, c, d = p_args
+          if {a, b} == {c, d}:
+            continue
+        if p.name == 'para':
+          a, b, c, d = p_args
+          if {a, b} == {c, d}:
+            continue
+
+        if theorem.name in [
+            'cong_cong_eqangle6_ncoll_contri*',
+            'eqratio6_eqangle6_ncoll_simtri*',
+        ]:
+          if p.name in ['eqangle', 'eqangle6']:  # SAS or RAR
+            b, a, b, c, y, x, y, z = (  # pylint: disable=redeclared-assigned-name,unused-variable
+                p_args
+            )
+            if not nm.same_clock(a.num, b.num, c.num, x.num, y.num, z.num):
+              p_args = b, a, b, c, y, z, y, x
+
+        dep = Dependency(p.name, p_args, rule_name='', level=level)
+        try:
+          dep = dep.why_me_or_cache(g, level)
+        except:  # pylint: disable=bare-except
+          fail = True
+          break
+
+        if dep.why is None:
+          fail = True
+          break
+        g.cache_dep(p.name, p_args, dep)
+        deps.why.append(dep)
+
+      if fail:
+        continue
+
+      mp_deps.append((mp, deps))
+    theorem2deps[theorem] = mp_deps
+
+  theorem2deps = list(theorem2deps.items())
+
+  # Step 3: add conclusions to graph.
+  # Note that we do NOT mix step 2 and 3, strictly going for BFS.
+  added = []
+  for theorem, mp_deps in theorem2deps:
+    for mp, deps in mp_deps:
+      if time.time() - t0 > timeout:
+        break
+      name, args = theorem.conclusion_name_args(mp)
+      hash_conclusion = pr.hashed(name, args)
+      if hash_conclusion in g.cache:
+        continue
+
+      add = g.add_piece(name, args, deps=deps)
+      added += add
+
+  branching = len(added)
+
+  # Check if goal is found
+  if controller.goal:
+    args = []
+
+    for a in controller.goal.args:
+      if a in g._name2node:
+        a = g._name2node[a]
+      elif '/' in a:
+        a = create_consts_str(g, a)
+      elif a.isdigit():
+        a = int(a)
+      args.append(a)
+
+    if g.check(controller.goal.name, args):
+      return added, {}, {}, branching
+
+  # Run AR, but do NOT apply to the proof state (yet).
+  for dep in added:
+    g.add_algebra(dep, level)
+  derives, eq4s = g.derive_algebra(level, verbose=False)
+
+  branching += sum([len(x) for x in derives.values()])
+  branching += sum([len(x) for x in eq4s.values()])
+
+  return added, derives, eq4s, branching
+
+
+def create_consts_str(g: gh.Graph, s: str) -> gm.Angle | gm.Ratio:
+  if 'pi/' in s:
+    n, d = s.split('pi/')
+    n, d = int(n), int(d)
+    p0, _ = g.get_or_create_const_ang(n, d)
+  else:
+    n, d = s.split('/')
+    n, d = int(n), int(d)
+    p0, _ = g.get_or_create_const_rat(n, d)
+  return p0
+
+
+def do_algebra(
+    g: gh.Graph, added: list[pr.Dependency], verbose: bool = False
+) -> None:
+  for add in added:
+    g.add_algebra(add, None)
+  derives, eq4s = g.derive_algebra(level=None, verbose=verbose)
+  apply_derivations(g, derives)
+  apply_derivations(g, eq4s)
+
+
+def apply_derivations(
+    g: gh.Graph, derives: dict[str, list[tuple[gm.Point, ...]]]
+) -> list[pr.Dependency]:
+  applied = []
+  all_derives = list(derives.items())
+  for name, args in all_derives:
+    for arg in args:
+      applied += g.do_algebra(name, arg)
+  return applied

ag4masses/alphageometry/dd_test.py

@@ -0,0 +1,79 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Unit tests for dd."""
+import unittest
+
+from absl.testing import absltest
+import dd
+import graph as gh
+import problem as pr
+
+
+MAX_LEVEL = 1000
+
+
+class DDTest(unittest.TestCase):
+
+  @classmethod
+  def setUpClass(cls):
+    super().setUpClass()
+    cls.defs = pr.Definition.from_txt_file('defs.txt', to_dict=True)
+    cls.rules = pr.Theorem.from_txt_file('rules.txt', to_dict=True)
+
+  def test_imo_2022_p4_should_succeed(self):
+    p = pr.Problem.from_txt(
+        'a b = segment a b; g1 = on_tline g1 a a b; g2 = on_tline g2 b b a; m ='
+        ' on_circle m g1 a, on_circle m g2 b; n = on_circle n g1 a, on_circle n'
+        ' g2 b; c = on_pline c m a b, on_circle c g1 a; d = on_pline d m a b,'
+        ' on_circle d g2 b; e = on_line e a c, on_line e b d; p = on_line p a'
+        ' n, on_line p c d; q = on_line q b n, on_line q c d ? cong e p e q'
+    )
+    g, _ = gh.Graph.build_problem(p, DDTest.defs)
+    goal_args = g.names2nodes(p.goal.args)
+
+    success = False
+    for level in range(MAX_LEVEL):
+      added, _, _, _ = dd.bfs_one_level(g, DDTest.rules, level, p)
+      if g.check(p.goal.name, goal_args):
+        success = True
+        break
+      if not added:  # saturated
+        break
+
+    self.assertTrue(success)
+
+  def test_incenter_excenter_should_fail(self):
+    p = pr.Problem.from_txt(
+        'a b c = triangle a b c; d = incenter d a b c; e = excenter e a b c ?'
+        ' perp d c c e'
+    )
+    g, _ = gh.Graph.build_problem(p, DDTest.defs)
+    goal_args = g.names2nodes(p.goal.args)
+
+    success = False
+    for level in range(MAX_LEVEL):
+      added, _, _, _ = dd.bfs_one_level(g, DDTest.rules, level, p)
+      if g.check(p.goal.name, goal_args):
+        success = True
+        break
+      if not added:  # saturated
+        break
+
+    self.assertFalse(success)
+
+
+if __name__ == '__main__':
+  absltest.main()

ag4masses/alphageometry/ddar.py

@@ -0,0 +1,159 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Implements the combination DD+AR."""
+import time
+
+from absl import logging
+import dd
+import graph as gh
+import problem as pr
+from problem import Dependency  # pylint: disable=g-importing-member
+import trace_back
+
+
+def saturate_or_goal(
+    g: gh.Graph,
+    theorems: list[pr.Theorem],
+    level_times: list[float],
+    p: pr.Problem,
+    max_level: int = 100,
+    timeout: int = 600,
+) -> tuple[
+    list[dict[str, list[tuple[gh.Point, ...]]]],
+    list[dict[str, list[tuple[gh.Point, ...]]]],
+    list[int],
+    list[pr.Dependency],
+]:
+  """Run DD until saturation or goal found."""
+  derives = []
+  eq4s = []
+  branching = []
+  all_added = []
+
+  while len(level_times) < max_level:
+    level = len(level_times) + 1
+
+    t = time.time()
+    added, derv, eq4, n_branching = dd.bfs_one_level(
+        g, theorems, level, p, verbose=False, nm_check=True, timeout=timeout
+    )
+    all_added += added
+    branching.append(n_branching)
+
+    derives.append(derv)
+    eq4s.append(eq4)
+    level_time = time.time() - t
+
+    logging.info(f'Depth {level}/{max_level} time = {level_time}')  # pylint: disable=logging-fstring-interpolation
+    level_times.append(level_time)
+
+    if p.goal is not None:
+      goal_args = list(map(lambda x: g.get(x, lambda: int(x)), p.goal.args))
+      if g.check(p.goal.name, goal_args):  # found goal
+        break
+
+    if not added:  # saturated
+      break
+
+    if level_time > timeout:
+      break
+
+  return derives, eq4s, branching, all_added
+
+
+def solve(
+    g: gh.Graph,
+    theorems: list[pr.Problem],
+    controller: pr.Problem,
+    max_level: int = 1000,
+    timeout: int = 600,
+) -> tuple[gh.Graph, list[float], str, list[int], list[pr.Dependency]]:
+  """Alternate between DD and AR until goal is found."""
+  status = 'saturated'
+  level_times = []
+
+  dervs, eq4 = g.derive_algebra(level=0, verbose=False)
+  derives = [dervs]
+  eq4s = [eq4]
+  branches = []
+  all_added = []
+
+  while len(level_times) < max_level:
+    dervs, eq4, next_branches, added = saturate_or_goal(
+        g, theorems, level_times, controller, max_level, timeout=timeout
+    )
+    all_added += added
+
+    derives += dervs
+    eq4s += eq4
+    branches += next_branches
+
+    # Now, it is either goal or saturated
+    if controller.goal is not None:
+      goal_args = g.names2points(controller.goal.args)
+      if g.check(controller.goal.name, goal_args):  # found goal
+        status = 'solved'
+        break
+
+    if not derives:  # officially saturated.
+      logging.info("derives empty, breaking")
+      break
+
+    # Now we resort to algebra derivations.
+    added = []
+    while derives and not added:
+      added += dd.apply_derivations(g, derives.pop(0))
+
+    if added:
+      continue
+
+    # Final help from AR.
+    while eq4s and not added:
+      added += dd.apply_derivations(g, eq4s.pop(0))
+
+    all_added += added
+
+    if not added:  # Nothing left. saturated.
+      logging.info("Nothing added, breaking")
+      break
+
+  return g, level_times, status, branches, all_added
+
+
+def get_proof_steps(
+    g: gh.Graph, goal: pr.Clause, merge_trivials: bool = False
+) -> tuple[
+    list[pr.Dependency],
+    list[pr.Dependency],
+    list[tuple[list[pr.Dependency], list[pr.Dependency]]],
+    dict[tuple[str, ...], int],
+]:
+  """Extract proof steps from the built DAG."""
+  goal_args = g.names2nodes(goal.args)
+  query = Dependency(goal.name, goal_args, None, None)
+
+  setup, aux, log, setup_points = trace_back.get_logs(
+      query, g, merge_trivials=merge_trivials
+  )
+
+  refs = {}
+  setup = trace_back.point_log(setup, refs, set())
+  aux = trace_back.point_log(aux, refs, setup_points)
+
+  setup = [(prems, [tuple(p)]) for p, prems in setup]
+  aux = [(prems, [tuple(p)]) for p, prems in aux]
+
+  return setup, aux, log, refs

ag4masses/alphageometry/ddar_test.py

@@ -0,0 +1,65 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Unit tests for ddar.py."""
+import unittest
+
+from absl.testing import absltest
+import ddar
+import graph as gh
+import problem as pr
+
+
+class DDARTest(unittest.TestCase):
+
+  @classmethod
+  def setUpClass(cls):
+    super().setUpClass()
+    cls.defs = pr.Definition.from_txt_file('defs.txt', to_dict=True)
+    cls.rules = pr.Theorem.from_txt_file('rules.txt', to_dict=True)
+
+  def test_orthocenter_should_fail(self):
+    txt = 'a b c = triangle a b c; d = on_tline d b a c, on_tline d c a b ? perp a d b c'  # pylint: disable=line-too-long
+    p = pr.Problem.from_txt(txt)
+    g, _ = gh.Graph.build_problem(p, DDARTest.defs)
+
+    ddar.solve(g, DDARTest.rules, p, max_level=1000)
+    goal_args = g.names2nodes(p.goal.args)
+    self.assertFalse(g.check(p.goal.name, goal_args))
+
+  def test_orthocenter_aux_should_succeed(self):
+    txt = 'a b c = triangle a b c; d = on_tline d b a c, on_tline d c a b; e = on_line e a c, on_line e b d ? perp a d b c'  # pylint: disable=line-too-long
+    p = pr.Problem.from_txt(txt)
+    g, _ = gh.Graph.build_problem(p, DDARTest.defs)
+
+    ddar.solve(g, DDARTest.rules, p, max_level=1000)
+    goal_args = g.names2nodes(p.goal.args)
+    self.assertTrue(g.check(p.goal.name, goal_args))
+
+  def test_incenter_excenter_should_succeed(self):
+    # Note that this same problem should fail in dd_test.py
+    p = pr.Problem.from_txt(
+        'a b c = triangle a b c; d = incenter d a b c; e = excenter e a b c ?'
+        ' perp d c c e'
+    )  # pylint: disable=line-too-long
+    g, _ = gh.Graph.build_problem(p, DDARTest.defs)
+
+    ddar.solve(g, DDARTest.rules, p, max_level=1000)
+    goal_args = g.names2nodes(p.goal.args)
+    self.assertTrue(g.check(p.goal.name, goal_args))
+
+
+if __name__ == '__main__':
+  absltest.main()

ag4masses/alphageometry/decoder_stack.py

@@ -0,0 +1,55 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""The decoder stack in inference mode."""
+
+from typing import Any, Tuple
+
+import gin
+from transformer import decoder_stack
+import transformer_layer as tl
+
+
+struct = decoder_stack.struct
+nn_components = decoder_stack.nn_components
+position = decoder_stack.position
+jnp = decoder_stack.jnp
+attention = decoder_stack.attention
+
+DStackWindowState = decoder_stack.DStackWindowState
+
+Array = Any
+
+TransformerTaskConfig = decoder_stack.TransformerTaskConfig
+
+DStackDecoderState = Tuple[tl.DecoderState, ...]
+
+
+@gin.configurable
+class DecoderStackGenerate(decoder_stack.DecoderStack):
+  """Stack of transformer decoder layers."""
+
+  layer_factory = tl.TransformerLayerGenerate
+
+  def init_decoder_state_vanilla(
+      self, sequence_length: int, start_of_sequence: Array
+  ) -> DStackDecoderState:
+    """Return initial state for autoregressive generation."""
+    return tuple(
+        [
+            layer.init_decoder_state_vanilla(sequence_length, start_of_sequence)
+            for layer in self.transformer_layers
+        ]
+    )

ag4masses/alphageometry/defs.txt

@@ -0,0 +1,407 @@
+angle_bisector x a b c
+x : a b c x
+a b c = ncoll a b c
+x : eqangle b a b x b x b c
+bisect a b c
+
+angle_mirror x a b c
+x : a b c x
+a b c = ncoll a b c
+x : eqangle b a b c b c b x
+amirror a b c
+
+circle x a b c
+x : a b c
+a b c = ncoll a b c
+x : cong x a x b, cong x b x c
+bline a b, bline a c
+
+circumcenter x a b c
+x : a b c
+a b c = ncoll a b c
+x : cong x a x b, cong x b x c
+bline a b, bline a c
+
+eq_quadrangle a b c d
+d : a b c d
+ =
+a : ; b : ; c : ; d : cong d a b c
+eq_quadrangle
+
+eq_trapezoid a b c d
+d : a b c
+ =
+a : ; b : ; c : ; d : para d c a b, cong d a b c
+eq_trapezoid
+
+eq_triangle x b c
+x : b c
+b c = diff b c
+x : cong x b b c, cong b c c x; eqangle b x b c c b c x, eqangle x c x b b x b c
+circle b b c, circle c b c
+
+eqangle2 x a b c
+x : a b c x
+a b c = ncoll a b c
+x : eqangle a b a x c x c b
+eqangle2 a b c
+
+eqdia_quadrangle a b c d
+d : a b c d
+ =
+a : ; b : ; c : ; d : cong d b a c
+eqdia_quadrangle
+
+eqdistance x a b c
+x : a b c x
+a b c = diff b c
+x : cong x a b c
+circle a b c
+
+foot x a b c
+x : a b c
+a b c = ncoll a b c
+x : perp x a b c, coll x b c
+tline a b c, line b c
+
+free a
+a : a
+ =
+a :
+free
+
+incenter x a b c
+x : a b c
+a b c = ncoll a b c
+x : eqangle a b a x a x a c, eqangle c a c x c x c b; eqangle b c b x b x b a
+bisect a b c, bisect b c a
+
+incenter2 x y z i a b c
+i : a b c, x : i b c, y : i c a, z : i a b
+a b c = ncoll a b c
+i : eqangle a b a i a i a c, eqangle c a c i c i c b; eqangle b c b i b i b a; x : coll x b c, perp i x b c; y : coll y c a, perp i y c a; z : coll z a b, perp i z a b; cong i x i y, cong i y i z
+incenter2 a b c
+
+excenter x a b c
+x : a b c
+a b c = ncoll a b c
+x : eqangle a b a x a x a c, eqangle c a c x c x c b; eqangle b c b x b x b a
+bisect b a c, exbisect b c a
+
+excenter2 x y z i a b c
+i : a b c, x : i b c, y : i c a, z : i a b
+a b c = ncoll a b c
+i : eqangle a b a i a i a c, eqangle c a c i c i c b; eqangle b c b i b i b a; x : coll x b c, perp i x b c; y : coll y c a, perp i y c a; z : coll z a b, perp i z a b; cong i x i y, cong i y i z
+excenter2 a b c
+
+centroid x y z i a b c
+x : b c, y : c a, z : a b, i : a x b y
+a b c = ncoll a b c
+x : coll x b c, cong x b x c; y : coll y c a, cong y c y a; z : coll z a b, cong z a z b; i : coll a x i, coll b y i; coll c z i
+centroid a b c
+
+ninepoints x y z i a b c
+x : b c, y : c a, z : a b, i : x y z
+a b c = ncoll a b c
+x : coll x b c, cong x b x c; y : coll y c a, cong y c y a; z : coll z a b, cong z a z b; i : cong i x i y, cong i y i z
+ninepoints a b c
+
+intersection_cc x o w a
+x : o w a
+o w a = ncoll o w a
+x : cong o a o x, cong w a w x
+circle o o a, circle w w a
+
+intersection_lc x a o b
+x : a o b
+a o b = diff a b, diff o b, nperp b o b a
+x : coll x a b, cong o b o x
+line b a, circle o o b
+
+intersection_ll x a b c d
+x : a b c d
+a b c d = npara a b c d, ncoll a b c d
+x : coll x a b, coll x c d
+line a b, line c d
+
+intersection_lp x a b c m n
+x : a b c m n
+a b c m n = npara m n a b, ncoll a b c, ncoll c m n
+x : coll x a b, para c x m n
+line a b, pline c m n
+
+intersection_lt x a b c d e
+x : a b c d e
+a b c d e = ncoll a b c, nperp a b d e
+x : coll x a b, perp x c d e
+line a b, tline c d e
+
+intersection_pp x a b c d e f
+x : a b c d e f
+a b c d e f = diff a d, npara b c e f
+x : para x a b c, para x d e f
+pline a b c, pline d e f
+
+intersection_tt x a b c d e f
+x : a b c d e f
+a b c d e f = diff a d, npara b c e f
+x : perp x a b c, perp x d e f
+tline a b c, tline d e f
+
+iso_triangle a b c
+c : a b c
+ =
+a : ; b : ; c : eqangle b a b c c b c a, cong a b a c
+isos
+
+lc_tangent x a o
+x : x a o
+a o = diff a o
+x : perp a x a o
+tline a a o
+
+midpoint x a b
+x : a b
+a b = diff a b
+x : coll x a b, cong x a x b
+midp a b
+
+mirror x a b
+x : a b
+a b = diff a b
+x : coll x a b, cong b a b x
+pmirror a b
+
+nsquare x a b
+x : a b
+a b = diff a b
+x : cong x a a b, perp x a a b
+rotaten90 a b
+
+on_aline x a b c d e
+x : x a b c d e
+a b c d e = ncoll c d e
+x : eqangle a x a b d c d e
+aline e d c b a
+
+on_aline2 x a b c d e
+x : x a b c d e
+a b c d e = ncoll c d e
+x : eqangle x a x b d c d e
+aline2 e d c b a
+
+on_bline x a b
+x : x a b
+a b = diff a b
+x : cong x a x b, eqangle a x a b b a b x
+bline a b
+
+on_circle x o a
+x : x o a
+o a = diff o a
+x : cong o x o a
+circle o o a
+
+on_line x a b
+x : x a b
+a b = diff a b
+x : coll x a b
+line a b
+
+on_pline x a b c
+x : x a b c
+a b c = diff b c, ncoll a b c
+x : para x a b c
+pline a b c
+
+on_tline x a b c
+x : x a b c
+a b c = diff b c
+x : perp x a b c
+tline a b c
+
+orthocenter x a b c
+x : a b c
+a b c = ncoll a b c
+x : perp x a b c, perp x b c a; perp x c a b
+tline a b c, tline b c a
+
+parallelogram a b c x
+x : a b c
+a b c = ncoll a b c
+x : para a b c x, para a x b c; cong a b c x, cong a x b c
+pline a b c, pline c a b
+
+pentagon a b c d e
+
+ =
+a : ; b : ; c : ; d : ; e :
+pentagon
+
+psquare x a b
+x : a b
+a b = diff a b
+x : cong x a a b, perp x a a b
+rotatep90 a b
+
+quadrangle a b c d
+
+ =
+a : ; b : ; c : ; d :
+quadrangle
+
+r_trapezoid a b c d
+d : a b c
+ =
+a : ; b : ; c : ; d : para a b c d, perp a b a d
+r_trapezoid
+
+r_triangle a b c
+c : a b c
+ =
+a : ; b : ; c : perp a b a c
+r_triangle
+
+rectangle a b c d
+c : a b c , d : a b c
+ =
+a : ; b : ; c : perp a b b c ; d : para a b c d, para a d b c; perp a b a d, cong a b c d, cong a d b c, cong a c b d
+rectangle
+
+reflect x a b c
+x : a b c
+a b c = diff b c, ncoll a b c
+x : cong b a b x, cong c a c x; perp b c a x
+reflect a b c
+
+risos a b c
+c : a b
+ =
+a : ; b : ; c : perp a b a c, cong a b a c; eqangle b a b c c b c a
+risos
+
+s_angle a b x y
+x : a b x
+a b = diff a b
+x : s_angle a b x y
+s_angle a b y
+
+segment a b
+
+ =
+a : ; b :
+segment
+
+shift x b c d
+x : b c d
+b c d = diff d b
+x : cong x b c d, cong x c b d
+shift d c b
+
+square a b x y
+x : a b, y : a b x
+a b = diff a b
+x : perp a b b x, cong a b b x; y : para a b x y, para a y b x; perp a y y x, cong b x x y, cong x y y a, perp a x b y, cong a x b y
+square a b
+
+isquare a b c d
+c : a b , d : a b c
+ =
+a : ; b : ; c : perp a b b c, cong a b b c; d : para a b c d, para a d b c; perp a d d c, cong b c c d, cong c d d a, perp a c b d, cong a c b d
+isquare
+
+trapezoid a b c d
+d : a b c d
+ =
+a : ; b : ; c : ; d : para a b c d
+trapezoid
+
+triangle a b c
+
+ =
+a : ; b : ; c :
+triangle
+
+triangle12 a b c
+c : a b c
+ =
+a : ; b : ; c : rconst a b a c 1 2
+triangle12
+
+2l1c x y z i a b c o
+x : a b c o y z i, y : a b c o x z i, z : a b c o x y i, i : a b c o x y z
+a b c o = cong o a o b, ncoll a b c
+x y z i : coll x a c, coll y b c, cong o a o z, coll i o z, cong i x i y, cong i y i z, perp i x a c, perp i y b c
+2l1c a b c o
+
+e5128 x y a b c d
+x : a b c d y, y : a b c d x
+a b c d = cong c b c d, perp b c b a
+x y : cong c b c x, coll y a b, coll x y d, eqangle a b a d x a x y
+e5128 a b c d
+
+3peq x y z a b c
+z : b c z , x : a b c z y, y : a b c z x
+a b c = ncoll a b c
+z : coll z b c ; x y : coll x a b, coll y a c, coll x y z, cong z x z y
+3peq a b c
+
+trisect x y a b c
+x : a b c y, y : a b c x
+a b c = ncoll a b c
+x y : coll x a c, coll y a c, eqangle b a b x b x b y, eqangle b x b y b y b c
+trisect a b c
+
+trisegment x y a b
+x : a b y, y : a b x
+a b = diff a b
+x y : coll x a b, coll y a b, cong x a x y, cong y x y b
+trisegment a b
+
+on_dia x a b
+x : x a b
+a b = diff a b
+x : perp x a x b
+dia a b
+
+ieq_triangle a b c
+c : a b
+ =
+a : ; b : ; c : cong a b b c, cong b c c a; eqangle a b a c c a c b, eqangle c a c b b c b a
+ieq_triangle
+
+on_opline x a b
+x : x a b
+a b = diff a b
+x : coll x a b
+on_opline a b
+
+cc_tangent0 x y o a w b
+x : o a w b y, y : o a w b x
+o a w b = diff o a, diff w b, diff o w
+x y : cong o x o a, cong w y w b, perp x o x y, perp y w y x
+cc_tangent0 o a w b
+
+cc_tangent x y z i o a w b
+x : o a w b y, y : o a w b x, z : o a w b i, i : o a w b z
+o a w b = diff o a, diff w b, diff o w
+x y : cong o x o a, cong w y w b, perp x o x y, perp y w y x; z i : cong o z o a, cong w i w b, perp z o z i, perp i w i z
+cc_tangent o a w b
+
+eqangle3 x a b d e f
+x : x a b d e f
+a b d e f = ncoll d e f, diff a b, diff d e, diff e f
+x : eqangle x a x b d e d f
+eqangle3 a b d e f
+
+tangent x y a o b
+x y : o a b
+a o b = diff o a, diff o b, diff a b
+x : cong o x o b, perp a x o x; y : cong o y o b, perp a y o y
+tangent a o b
+
+on_circum x a b c
+x : a b c
+a b c = ncoll a b c
+x : cyclic a b c x
+cyclic a b c

ag4masses/alphageometry/download.sh

@@ -0,0 +1,17 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+gdown --folder https://bit.ly/alphageometry
+export DATA=ag_ckpt_vocab

ag4masses/alphageometry/examples.txt

@@ -0,0 +1,8 @@
+orthocenter
+a b c = triangle; h = on_tline b a c, on_tline c a b ? perp a h b c
+orthocenter_aux
+a b c = triangle; d = on_tline d b a c, on_tline d c a b; e = on_line e a c, on_line e b d ? perp a d b c
+incenter_excenter
+a b c = triangle a b c; d1 d2 d3 d = incenter2 a b c; e1 e2 e3 e = excenter2 a b c ? perp d c c e
+euler
+a b c = triangle a b c; h = orthocenter a b c; h1 = foot a b c; h2 = foot b c a; h3 = foot c a b; g1 g2 g3 g = centroid g1 g2 g3 g a b c; o = circle a b c ? coll h g o

ag4masses/alphageometry/geometry.py

@@ -0,0 +1,578 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Implements geometric objects used in the graph representation."""
+from __future__ import annotations
+from collections import defaultdict  # pylint: disable=g-importing-member
+from typing import Any, Type
+
+# pylint: disable=protected-access
+
+
+class Node:
+  r"""Node in the proof state graph.
+
+  Can be Point, Line, Circle, etc.
+
+  Each node maintains a merge history to
+  other nodes if they are (found out to be) equivalent
+
+    a -> b -
+            \
+         c -> d -> e -> f -> g
+
+  d.merged_to = e
+  d.rep = g
+  d.merged_from = {a, b, c, d}
+  d.equivs = {a, b, c, d, e, f, g}
+  """
+
+  def __init__(self, name: str = '', graph: Any = None):
+    self.name = name or str(self)
+    self.graph = graph
+
+    self.edge_graph = {}
+    # Edge graph: what other nodes is connected to this node.
+    # edge graph = {
+    #   other1: {self1: deps, self2: deps},
+    #   other2: {self2: deps, self3: deps}
+    # }
+
+    self.merge_graph = {}
+    # Merge graph: history of merges with other nodes.
+    # merge_graph = {self1: {self2: deps1, self3: deps2}}
+
+    self.rep_by = None  # represented by.
+    self.members = {self}
+
+    self._val = None
+    self._obj = None
+
+    self.deps = []
+
+    # numerical representation.
+    self.num = None
+    self.change = set()  # what other nodes' num rely on this node?
+
+  def set_rep(self, node: Node) -> None:
+    if node == self:
+      return
+    self.rep_by = node
+    node.merge_edge_graph(self.edge_graph)
+    node.members.update(self.members)
+
+  def rep(self) -> Node:
+    x = self
+    while x.rep_by:
+      x = x.rep_by
+    return x
+
+  def why_rep(self) -> list[Any]:
+    return self.why_equal([self.rep()], None)
+
+  def rep_and_why(self) -> tuple[Node, list[Any]]:
+    rep = self.rep()
+    return rep, self.why_equal([rep], None)
+
+  def neighbors(
+      self, oftype: Type[Node], return_set: bool = False, do_rep: bool = True
+  ) -> list[Node]:
+    """Neighbors of this node in the proof state graph."""
+    if do_rep:
+      rep = self.rep()
+    else:
+      rep = self
+    result = set()
+
+    for n in rep.edge_graph:
+      if oftype is None or oftype and isinstance(n, oftype):
+        if do_rep:
+          result.add(n.rep())
+        else:
+          result.add(n)
+
+    if return_set:
+      return result
+    return list(result)
+
+  def merge_edge_graph(
+      self, new_edge_graph: dict[Node, dict[Node, list[Node]]]
+  ) -> None:
+    for x, xdict in new_edge_graph.items():
+      if x in self.edge_graph:
+        self.edge_graph[x].update(dict(xdict))
+      else:
+        self.edge_graph[x] = dict(xdict)
+
+  def merge(self, nodes: list[Node], deps: list[Any]) -> None:
+    for node in nodes:
+      self.merge_one(node, deps)
+
+  def merge_one(self, node: Node, deps: list[Any]) -> None:
+    node.rep().set_rep(self.rep())
+
+    if node in self.merge_graph:
+      return
+
+    self.merge_graph[node] = deps
+    node.merge_graph[self] = deps
+
+  def is_val(self, node: Node) -> bool:
+    return (
+        isinstance(self, Line)
+        and isinstance(node, Direction)
+        or isinstance(self, Segment)
+        and isinstance(node, Length)
+        or isinstance(self, Angle)
+        and isinstance(node, Measure)
+        or isinstance(self, Ratio)
+        and isinstance(node, Value)
+    )
+
+  def set_val(self, node: Node) -> None:
+    self._val = node
+
+  def set_obj(self, node: Node) -> None:
+    self._obj = node
+
+  @property
+  def val(self) -> Node:
+    if self._val is None:
+      return None
+    return self._val.rep()
+
+  @property
+  def obj(self) -> Node:
+    if self._obj is None:
+      return None
+    return self._obj.rep()
+
+  def equivs(self) -> set[Node]:
+    return self.rep().members
+
+  def connect_to(self, node: Node, deps: list[Any] = None) -> None:
+    rep = self.rep()
+
+    if node in rep.edge_graph:
+      rep.edge_graph[node].update({self: deps})
+    else:
+      rep.edge_graph[node] = {self: deps}
+
+    if self.is_val(node):
+      self.set_val(node)
+      node.set_obj(self)
+
+  def equivs_upto(self, level: int) -> dict[Node, Node]:
+    """What are the equivalent nodes up to a certain level."""
+    parent = {self: None}
+    visited = set()
+    queue = [self]
+    i = 0
+
+    while i < len(queue):
+      current = queue[i]
+      i += 1
+      visited.add(current)
+
+      for neighbor in current.merge_graph:
+        if (
+            level is not None
+            and current.merge_graph[neighbor].level is not None
+            and current.merge_graph[neighbor].level >= level
+        ):
+          continue
+        if neighbor not in visited:
+          queue.append(neighbor)
+          parent[neighbor] = current
+
+    return parent
+
+  def why_equal(self, others: list[Node], level: int) -> list[Any]:
+    """BFS why this node is equal to other nodes."""
+    others = set(others)
+    found = 0
+
+    parent = {}
+    queue = [self]
+    i = 0
+
+    while i < len(queue):
+      current = queue[i]
+      if current in others:
+        found += 1
+      if found == len(others):
+        break
+
+      i += 1
+
+      for neighbor in current.merge_graph:
+        if (
+            level is not None
+            and current.merge_graph[neighbor].level is not None
+            and current.merge_graph[neighbor].level >= level
+        ):
+          continue
+        if neighbor not in parent:
+          queue.append(neighbor)
+          parent[neighbor] = current
+
+    return bfs_backtrack(self, others, parent)
+
+  def why_equal_groups(
+      self, groups: list[list[Node]], level: int
+  ) -> tuple[list[Any], list[Node]]:
+    """BFS for why self is equal to at least one member of each group."""
+    others = [None for _ in groups]
+    found = 0
+
+    parent = {}
+    queue = [self]
+    i = 0
+
+    while i < len(queue):
+      current = queue[i]
+
+      for j, grp in enumerate(groups):
+        if others[j] is None and current in grp:
+          others[j] = current
+          found += 1
+
+      if found == len(others):
+        break
+
+      i += 1
+
+      for neighbor in current.merge_graph:
+        if (
+            level is not None
+            and current.merge_graph[neighbor].level is not None
+            and current.merge_graph[neighbor].level >= level
+        ):
+          continue
+        if neighbor not in parent:
+          queue.append(neighbor)
+          parent[neighbor] = current
+
+    return bfs_backtrack(self, others, parent), others
+
+  def why_val(self, level: int) -> list[Any]:
+    return self._val.why_equal([self.val], level)
+
+  def why_connect(self, node: Node, level: int = None) -> list[Any]:
+    rep = self.rep()
+    equivs = list(rep.edge_graph[node].keys())
+    if not equivs:
+      return None
+    equiv = equivs[0]
+    dep = rep.edge_graph[node][equiv]
+    return [dep] + self.why_equal(equiv, level)
+
+
+def why_connect(*pairs: list[tuple[Node, Node]]) -> list[Any]:
+  result = []
+  for node1, node2 in pairs:
+    result += node1.why_connect(node2)
+  return result
+
+
+def is_equiv(x: Node, y: Node, level: int = None) -> bool:
+  level = level or float('inf')
+  return x.why_equal([y], level) is not None
+
+
+def is_equal(x: Node, y: Node, level: int = None) -> bool:
+  if x == y:
+    return True
+  if x._val is None or y._val is None:
+    return False
+  if x.val != y.val:
+    return False
+  return is_equiv(x._val, y._val, level)
+
+
+def bfs_backtrack(
+    root: Node, leafs: list[Node], parent: dict[Node, Node]
+) -> list[Any]:
+  """Return the path given BFS trace of parent nodes."""
+  backtracked = {root}  # no need to backtrack further when touching this set.
+  deps = []
+  for node in leafs:
+    if node is None:
+      return None
+    if node in backtracked:
+      continue
+    if node not in parent:
+      return None
+    while node not in backtracked:
+      backtracked.add(node)
+      deps.append(node.merge_graph[parent[node]])
+      node = parent[node]
+
+  return deps
+
+
+class Point(Node):
+  pass
+
+
+class Line(Node):
+  """Node of type Line."""
+
+  def new_val(self) -> Direction:
+    return Direction()
+
+  def why_coll(self, points: list[Point], level: int = None) -> list[Any]:
+    """Why points are connected to self."""
+    level = level or float('inf')
+
+    groups = []
+    for p in points:
+      group = [
+          l
+          for l, d in self.edge_graph[p].items()
+          if d is None or d.level < level
+      ]
+      if not group:
+        return None
+      groups.append(group)
+
+    min_deps = None
+    for line in groups[0]:
+      deps, others = line.why_equal_groups(groups[1:], level)
+      if deps is None:
+        continue
+      for p, o in zip(points, [line] + others):
+        deps.append(self.edge_graph[p][o])
+      if min_deps is None or len(deps) < len(min_deps):
+        min_deps = deps
+
+    if min_deps is None:
+      return None
+    return [d for d in min_deps if d is not None]
+
+
+class Segment(Node):
+
+  def new_val(self) -> Length:
+    return Length()
+
+
+class Circle(Node):
+  """Node of type Circle."""
+
+  def why_cyclic(self, points: list[Point], level: int = None) -> list[Any]:
+    """Why points are connected to self."""
+    level = level or float('inf')
+
+    groups = []
+    for p in points:
+      group = [
+          c
+          for c, d in self.edge_graph[p].items()
+          if d is None or d.level < level
+      ]
+      if not group:
+        return None
+      groups.append(group)
+
+    min_deps = None
+    for circle in groups[0]:
+      deps, others = circle.why_equal_groups(groups[1:], level)
+      if deps is None:
+        continue
+      for p, o in zip(points, [circle] + others):
+        deps.append(self.edge_graph[p][o])
+
+      if min_deps is None or len(deps) < len(min_deps):
+        min_deps = deps
+
+    if min_deps is None:
+      return None
+    return [d for d in min_deps if d is not None]
+
+
+def why_equal(x: Node, y: Node, level: int = None) -> list[Any]:
+  if x == y:
+    return []
+  if not x._val or not y._val:
+    return None
+  if x._val == y._val:
+    return []
+  return x._val.why_equal([y._val], level)
+
+
+class Direction(Node):
+  pass
+
+
+def get_lines_thru_all(*points: list[Point]) -> list[Line]:
+  line2count = defaultdict(lambda: 0)
+  points = set(points)
+  for p in points:
+    for l in p.neighbors(Line):
+      line2count[l] += 1
+  return [l for l, count in line2count.items() if count == len(points)]
+
+
+def line_of_and_why(
+    points: list[Point], level: int = None
+) -> tuple[Line, list[Any]]:
+  """Why points are collinear."""
+  for l0 in get_lines_thru_all(*points):
+    for l in l0.equivs():
+      if all([p in l.edge_graph for p in points]):
+        x, y = l.points
+        colls = list({x, y} | set(points))
+        # if len(colls) < 3:
+        #   return l, []
+        why = l.why_coll(colls, level)
+        if why is not None:
+          return l, why
+
+  return None, None
+
+
+def get_circles_thru_all(*points: list[Point]) -> list[Circle]:
+  circle2count = defaultdict(lambda: 0)
+  points = set(points)
+  for p in points:
+    for c in p.neighbors(Circle):
+      circle2count[c] += 1
+  return [c for c, count in circle2count.items() if count == len(points)]
+
+
+def circle_of_and_why(
+    points: list[Point], level: int = None
+) -> tuple[Circle, list[Any]]:
+  """Why points are concyclic."""
+  for c0 in get_circles_thru_all(*points):
+    for c in c0.equivs():
+      if all([p in c.edge_graph for p in points]):
+        cycls = list(set(points))
+        why = c.why_cyclic(cycls, level)
+        if why is not None:
+          return c, why
+
+  return None, None
+
+
+def name_map(struct: Any) -> Any:
+  if isinstance(struct, list):
+    return [name_map(x) for x in struct]
+  elif isinstance(struct, tuple):
+    return tuple([name_map(x) for x in struct])
+  elif isinstance(struct, set):
+    return set([name_map(x) for x in struct])
+  elif isinstance(struct, dict):
+    return {name_map(x): name_map(y) for x, y in struct.items()}
+  else:
+    return getattr(struct, 'name', '')
+
+
+class Angle(Node):
+  """Node of type Angle."""
+
+  def new_val(self) -> Measure:
+    return Measure()
+
+  def set_directions(self, d1: Direction, d2: Direction) -> None:
+    self._d = d1, d2
+
+  @property
+  def directions(self) -> tuple[Direction, Direction]:
+    d1, d2 = self._d
+    if d1 is None or d2 is None:
+      return d1, d2
+    return d1.rep(), d2.rep()
+
+
+class Measure(Node):
+  pass
+
+
+class Length(Node):
+  pass
+
+
+class Ratio(Node):
+  """Node of type Ratio."""
+
+  def new_val(self) -> Value:
+    return Value()
+
+  def set_lengths(self, l1: Length, l2: Length) -> None:
+    self._l = l1, l2
+
+  @property
+  def lengths(self) -> tuple[Length, Length]:
+    l1, l2 = self._l
+    if l1 is None or l2 is None:
+      return l1, l2
+    return l1.rep(), l2.rep()
+
+
+class Value(Node):
+  pass
+
+
+def all_angles(
+    d1: Direction, d2: Direction, level: int = None
+) -> tuple[Angle, list[Direction], list[Direction]]:
+  level = level or float('inf')
+  d1s = d1.equivs_upto(level)
+  d2s = d2.equivs_upto(level)
+
+  for ang in d1.rep().neighbors(Angle):
+    d1_, d2_ = ang._d
+    if d1_ in d1s and d2_ in d2s:
+      yield ang, d1s, d2s
+
+
+def all_ratios(
+    d1, d2, level=None
+) -> tuple[Angle, list[Direction], list[Direction]]:
+  level = level or float('inf')
+  d1s = d1.equivs_upto(level)
+  d2s = d2.equivs_upto(level)
+
+  for ang in d1.rep().neighbors(Ratio):
+    d1_, d2_ = ang._l
+    if d1_ in d1s and d2_ in d2s:
+      yield ang, d1s, d2s
+
+
+RANKING = {
+    Point: 0,
+    Line: 1,
+    Segment: 2,
+    Circle: 3,
+    Direction: 4,
+    Length: 5,
+    Angle: 6,
+    Ratio: 7,
+    Measure: 8,
+    Value: 9,
+}
+
+
+def val_type(x: Node) -> Type[Node]:
+  if isinstance(x, Line):
+    return Direction
+  if isinstance(x, Segment):
+    return Length
+  if isinstance(x, Angle):
+    return Measure
+  if isinstance(x, Ratio):
+    return Value

ag4masses/alphageometry/geometry_150M_generate.gin

@@ -0,0 +1,47 @@
+NUM_EMBEDDINGS = 1024
+
+# Number of parameters = 152M
+NUM_LAYERS = 12
+EMBED_DIM = 1024
+NUM_HEADS = 8
+HEAD_DIM = 128
+MLP_DIM = 4096
+
+
+transformer_layer.TransformerLayerGenerate:
+  num_heads = %NUM_HEADS
+  head_size = %HEAD_DIM
+  window_length = 1024
+  use_long_xl_architecture = False
+  max_unrolled_windows = -1           # Always unroll.
+  relative_position_type = "t5"       # Can be "fourier", "t5", or None.
+  use_causal_mask = True
+  attn_dropout_rate = %ATTN_DROPOUT_RATE   # Attention matrix dropout.
+  memory_num_neighbors = 0
+  dtype = %DTYPE
+
+decoder_stack.DecoderStackGenerate:
+  num_layers = %NUM_LAYERS
+  embedding_size = %EMBED_DIM
+  embedding_stddev = 1.0
+  layer_factory = @transformer_layer.TransformerLayerGenerate
+  dstack_window_length = 0
+  use_absolute_positions = False
+  use_final_layernorm = True          # Final layernorm before token lookup.
+  final_dropout_rate = %DROPOUT_RATE  # Dropout before token lookup.
+  final_mlp_factory = None            # Final MLP to predict target tokens.
+  recurrent_layer_indices = ()
+  memory_factory = None     # e.g. @memory_factory.memory_on_tpu_factory
+  memory_layer_indices = ()
+  dtype = %DTYPE
+
+
+models.DecoderOnlyLanguageModelGenerate:
+  num_heads = %NUM_HEADS
+  head_size = %HEAD_DIM
+  task_config = @decoder_stack.TransformerTaskConfig()
+  decoder_factory = @decoder_stack.DecoderStackGenerate
+
+
+training_loop.Trainer:
+  model_definition = @models.DecoderOnlyLanguageModelGenerate

ag4masses/alphageometry/geometry_test.py

@@ -0,0 +1,80 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Unit tests for geometry.py."""
+import unittest
+
+from absl.testing import absltest
+import geometry as gm
+
+
+class GeometryTest(unittest.TestCase):
+
+  def _setup_equality_example(self):
+    # Create 4 nodes a, b, c, d
+    # and their lengths
+    a = gm.Segment('a')
+    la = gm.Length('l(a)')
+    a.connect_to(la)
+    la.connect_to(a)
+
+    b = gm.Segment('b')
+    lb = gm.Length('l(b)')
+    b.connect_to(lb)
+    lb.connect_to(b)
+
+    c = gm.Segment('c')
+    lc = gm.Length('l(c)')
+    c.connect_to(lc)
+    lc.connect_to(c)
+
+    d = gm.Segment('d')
+    ld = gm.Length('l(d)')
+    d.connect_to(ld)
+    ld.connect_to(d)
+
+    # Now let a=b, b=c, a=c, c=d
+    la.merge([lb], 'fact1')
+    lb.merge([lc], 'fact2')
+    la.merge([lc], 'fact3')
+    lc.merge([ld], 'fact4')
+    return a, b, c, d, la, lb, lc, ld
+
+  def test_merged_node_representative(self):
+    _, _, _, _, la, lb, lc, ld = self._setup_equality_example()
+
+    # all nodes are now represented by la.
+    self.assertEqual(la.rep(), la)
+    self.assertEqual(lb.rep(), la)
+    self.assertEqual(lc.rep(), la)
+    self.assertEqual(ld.rep(), la)
+
+  def test_merged_node_equivalence(self):
+    _, _, _, _, la, lb, lc, ld = self._setup_equality_example()
+    # all la, lb, lc, ld are equivalent
+    self.assertCountEqual(la.equivs(), [la, lb, lc, ld])
+    self.assertCountEqual(lb.equivs(), [la, lb, lc, ld])
+    self.assertCountEqual(lc.equivs(), [la, lb, lc, ld])
+    self.assertCountEqual(ld.equivs(), [la, lb, lc, ld])
+
+  def test_bfs_for_equality_transitivity(self):
+    a, _, _, d, _, _, _, _ = self._setup_equality_example()
+
+    # check that a==d because fact3 & fact4, not fact1 & fact2
+    self.assertCountEqual(gm.why_equal(a, d), ['fact3', 'fact4'])
+
+
+if __name__ == '__main__':
+  absltest.main()

ag4masses/alphageometry/graph.py

@@ -0,0 +1,3057 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Implements the graph representation of the proof state."""
+
+# pylint: disable=g-multiple-import
+from __future__ import annotations
+
+from collections import defaultdict  # pylint: disable=g-importing-member
+from typing import Callable, Generator, Optional, Type, Union
+
+from absl import logging
+import ar
+import geometry as gm
+from geometry import Angle, Direction, Length, Ratio
+from geometry import Circle, Line, Point, Segment
+from geometry import Measure, Value
+import graph_utils as utils
+import numericals as nm
+import problem
+from problem import Dependency, EmptyDependency
+
+
+np = nm.np
+
+
+FREE = [
+    'free',
+    'segment',
+    'r_triangle',
+    'risos',
+    'triangle',
+    'triangle12',
+    'ieq_triangle',
+    'eq_quadrangle',
+    'eq_trapezoid',
+    'eqdia_quadrangle',
+    'quadrangle',
+    'r_trapezoid',
+    'rectangle',
+    'isquare',
+    'trapezoid',
+    'pentagon',
+    'iso_triangle',
+]
+
+INTERSECT = [
+    'angle_bisector',
+    'angle_mirror',
+    'eqdistance',
+    'lc_tangent',
+    'on_aline',
+    'on_bline',
+    'on_circle',
+    'on_line',
+    'on_pline',
+    'on_tline',
+    'on_dia',
+    's_angle',
+    'on_opline',
+    'eqangle3',
+]
+
+
+# pylint: disable=protected-access
+# pylint: disable=unused-argument
+
+
+class DepCheckFailError(Exception):
+  pass
+
+
+class PointTooCloseError(Exception):
+  pass
+
+
+class PointTooFarError(Exception):
+  pass
+
+
+class Graph:
+  """Graph data structure representing proof state."""
+
+  def __init__(self):
+    self.type2nodes = {
+        Point: [],
+        Line: [],
+        Segment: [],
+        Circle: [],
+        Direction: [],
+        Length: [],
+        Angle: [],
+        Ratio: [],
+        Measure: [],
+        Value: [],
+    }
+    self._name2point = {}
+    self._name2node = {}
+
+    self.rconst = {}  # contains all constant ratios
+    self.aconst = {}  # contains all constant angles.
+
+    self.halfpi, _ = self.get_or_create_const_ang(1, 2)
+    self.vhalfpi = self.halfpi.val
+
+    self.atable = ar.AngleTable()
+    self.dtable = ar.DistanceTable()
+    self.rtable = ar.RatioTable()
+
+    # to quick access deps.
+    self.cache = {}
+
+    self._pair2line = {}
+    self._triplet2circle = {}
+
+  def copy(self) -> Graph:
+    """Make a copy of self."""
+    p, definitions = self.build_def
+
+    p = p.copy()
+    for clause in p.clauses:
+      clause.nums = []
+      for pname in clause.points:
+        clause.nums.append(self._name2node[pname].num)
+
+    g, _ = Graph.build_problem(p, definitions, verbose=False, init_copy=False)
+
+    g.build_clauses = list(getattr(self, 'build_clauses', []))
+    return g
+
+  def _create_const_ang(self, n: int, d: int) -> None:
+    n, d = ar.simplify(n, d)
+    ang = self.aconst[(n, d)] = self.new_node(Angle, f'{n}pi/{d}')
+    ang.set_directions(None, None)
+    self.connect_val(ang, deps=None)
+
+  def _create_const_rat(self, n: int, d: int) -> None:
+    n, d = ar.simplify(n, d)
+    rat = self.rconst[(n, d)] = self.new_node(Ratio, f'{n}/{d}')
+    rat.set_lengths(None, None)
+    self.connect_val(rat, deps=None)
+
+  def get_or_create_const_ang(self, n: int, d: int) -> None:
+    n, d = ar.simplify(n, d)
+    if (n, d) not in self.aconst:
+      self._create_const_ang(n, d)
+    ang1 = self.aconst[(n, d)]
+
+    n, d = ar.simplify(d - n, d)
+    if (n, d) not in self.aconst:
+      self._create_const_ang(n, d)
+    ang2 = self.aconst[(n, d)]
+    return ang1, ang2
+
+  def get_or_create_const_rat(self, n: int, d: int) -> None:
+    n, d = ar.simplify(n, d)
+    if (n, d) not in self.rconst:
+      self._create_const_rat(n, d)
+    rat1 = self.rconst[(n, d)]
+
+    if (d, n) not in self.rconst:
+      self._create_const_rat(d, n)  # pylint: disable=arguments-out-of-order
+    rat2 = self.rconst[(d, n)]
+    return rat1, rat2
+
+  def add_algebra(self, dep: Dependency, level: int) -> None:
+    """Add new algebraic predicates."""
+    _ = level
+    if dep.name not in [
+        'para',
+        'perp',
+        'eqangle',
+        'eqratio',
+        'aconst',
+        'rconst',
+        'cong',
+    ]:
+      return
+
+    name, args = dep.name, dep.args
+
+    if name == 'para':
+      ab, cd = dep.algebra
+      self.atable.add_para(ab, cd, dep)
+
+    if name == 'perp':
+      ab, cd = dep.algebra
+      self.atable.add_const_angle(ab, cd, 90, dep)
+
+    if name == 'eqangle':
+      ab, cd, mn, pq = dep.algebra
+      if (ab, cd) == (pq, mn):
+        self.atable.add_const_angle(ab, cd, 90, dep)
+      else:
+        self.atable.add_eqangle(ab, cd, mn, pq, dep)
+
+    if name == 'eqratio':
+      ab, cd, mn, pq = dep.algebra
+      if (ab, cd) == (pq, mn):
+        self.rtable.add_eq(ab, cd, dep)
+      else:
+        self.rtable.add_eqratio(ab, cd, mn, pq, dep)
+
+    if name == 'aconst':
+      bx, ab, y = dep.algebra
+      self.atable.add_const_angle(bx, ab, y, dep)
+
+    if name == 'rconst':
+      l1, l2, m, n = dep.algebra
+      self.rtable.add_const_ratio(l1, l2, m, n, dep)
+
+    if name == 'cong':
+      a, b, c, d = args
+      ab, _ = self.get_line_thru_pair_why(a, b)
+      cd, _ = self.get_line_thru_pair_why(c, d)
+      self.dtable.add_cong(ab, cd, a, b, c, d, dep)
+
+      ab, cd = dep.algebra
+      self.rtable.add_eq(ab, cd, dep)
+
+  def add_eqrat_const(
+      self, args: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    """Add new algebraic predicates of type eqratio-constant."""
+    a, b, c, d, num, den = args
+    nd, dn = self.get_or_create_const_rat(num, den)
+
+    if num == den:
+      return self.add_cong([a, b, c, d], deps)
+
+    ab = self._get_or_create_segment(a, b, deps=None)
+    cd = self._get_or_create_segment(c, d, deps=None)
+
+    self.connect_val(ab, deps=None)
+    self.connect_val(cd, deps=None)
+
+    if ab.val == cd.val:
+      raise ValueError(f'{ab.name} and {cd.name} cannot be equal')
+
+    args = [a, b, c, d, nd]
+    i = 0
+    for x, y, xy in [(a, b, ab), (c, d, cd)]:
+      i += 1
+      x_, y_ = list(xy._val._obj.points)
+      if {x, y} == {x_, y_}:
+        continue
+      if deps:
+        deps = deps.extend(self, 'rconst', list(args), 'cong', [x, y, x_, y_])
+      args[2 * i - 2] = x_
+      args[2 * i - 1] = y_
+
+    ab_cd, cd_ab, why = self._get_or_create_ratio(ab, cd, deps=None)
+    if why:
+      dep0 = deps.populate('rconst', [a, b, c, d, nd])
+      deps = EmptyDependency(level=deps.level, rule_name=None)
+      deps.why = [dep0] + why
+
+    lab, lcd = ab_cd._l
+    a, b = list(lab._obj.points)
+    c, d = list(lcd._obj.points)
+
+    add = []
+    if not self.is_equal(ab_cd, nd):
+      args = [a, b, c, d, nd]
+      dep1 = deps.populate('rconst', args)
+      dep1.algebra = ab._val, cd._val, num, den
+      self.make_equal(nd, ab_cd, deps=dep1)
+      self.cache_dep('rconst', [a, b, c, d, nd], dep1)
+      add += [dep1]
+
+    if not self.is_equal(cd_ab, dn):
+      args = [c, d, a, b, dn]
+      dep2 = deps.populate('rconst', args)
+      dep2.algebra = cd._val, ab._val, den, num
+      self.make_equal(dn, cd_ab, deps=dep2)
+      self.cache_dep('rconst', [c, d, a, b, dn], dep2)
+      add += [dep2]
+
+    return add
+
+  def do_algebra(self, name: str, args: list[Point]) -> list[Dependency]:
+    """Derive (but not add) new algebraic predicates."""
+    if name == 'para':
+      a, b, dep = args
+      if gm.is_equiv(a, b):
+        return []
+      (x, y), (m, n) = a._obj.points, b._obj.points
+      return self.add_para([x, y, m, n], dep)
+
+    if name == 'aconst':
+      a, b, n, d, dep = args
+      ab, ba, why = self.get_or_create_angle_d(a, b, deps=None)
+      nd, dn = self.get_or_create_const_ang(n, d)
+
+      (x, y), (m, n) = a._obj.points, b._obj.points
+
+      if why:
+        dep0 = dep.populate('aconst', [x, y, m, n, nd])
+        dep = EmptyDependency(level=dep.level, rule_name=None)
+        dep.why = [dep0] + why
+
+      a, b = ab._d
+      (x, y), (m, n) = a._obj.points, b._obj.points
+
+      added = []
+      if not self.is_equal(ab, nd):
+        if nd == self.halfpi:
+          added += self.add_perp([x, y, m, n], dep)
+        # else:
+        name = 'aconst'
+        args = [x, y, m, n, nd]
+        dep1 = dep.populate(name, args)
+        self.cache_dep(name, args, dep1)
+        self.make_equal(nd, ab, deps=dep1)
+        added += [dep1]
+
+      if not self.is_equal(ba, dn):
+        if dn == self.halfpi:
+          added += self.add_perp([m, n, x, y], dep)
+        name = 'aconst'
+        args = [m, n, x, y, dn]
+        dep2 = dep.populate(name, args)
+        self.cache_dep(name, args, dep2)
+        self.make_equal(dn, ba, deps=dep2)
+        added += [dep2]
+      return added
+
+    if name == 'rconst':
+      a, b, c, d, num, den, dep = args
+      return self.add_eqrat_const([a, b, c, d, num, den], dep)
+
+    if name == 'eqangle':
+      d1, d2, d3, d4, dep = args
+      a, b = d1._obj.points
+      c, d = d2._obj.points
+      e, f = d3._obj.points
+      g, h = d4._obj.points
+
+      return self.add_eqangle([a, b, c, d, e, f, g, h], dep)
+
+    if name == 'eqratio':
+      d1, d2, d3, d4, dep = args
+      a, b = d1._obj.points
+      c, d = d2._obj.points
+      e, f = d3._obj.points
+      g, h = d4._obj.points
+
+      return self.add_eqratio([a, b, c, d, e, f, g, h], dep)
+
+    if name in ['cong', 'cong2']:
+      a, b, c, d, dep = args
+      if not (a != b and c != d and (a != c or b != d)):
+        return []
+      return self.add_cong([a, b, c, d], dep)
+
+    return []
+
+  def derive_algebra(
+      self, level: int, verbose: bool = False
+  ) -> tuple[
+      dict[str, list[tuple[Point, ...]]], dict[str, [tuple[Point, ...]]]
+  ]:
+    """Derive new algebraic predicates."""
+    derives = {}
+    ang_derives = self.derive_angle_algebra(level, verbose=verbose)
+    dist_derives = self.derive_distance_algebra(level, verbose=verbose)
+    rat_derives = self.derive_ratio_algebra(level, verbose=verbose)
+
+    derives.update(ang_derives)
+    derives.update(dist_derives)
+    derives.update(rat_derives)
+
+    # Separate eqangle and eqratio derivations
+    # As they are too numerous => slow down DD+AR.
+    # & reserve them only for last effort.
+    eqs = {'eqangle': derives.pop('eqangle'), 'eqratio': derives.pop('eqratio')}
+    return derives, eqs
+
+  def derive_ratio_algebra(
+      self, level: int, verbose: bool = False
+  ) -> dict[str, list[tuple[Point, ...]]]:
+    """Derive new eqratio predicates."""
+    added = {'cong2': [], 'eqratio': []}
+
+    for x in self.rtable.get_all_eqs_and_why():
+      x, why = x[:-1], x[-1]
+      dep = EmptyDependency(level=level, rule_name='a01')
+      dep.why = why
+
+      if len(x) == 2:
+        a, b = x
+        if gm.is_equiv(a, b):
+          continue
+
+        (m, n), (p, q) = a._obj.points, b._obj.points
+        added['cong2'].append((m, n, p, q, dep))
+
+      if len(x) == 4:
+        a, b, c, d = x
+        added['eqratio'].append((a, b, c, d, dep))
+
+    return added
+
+  def derive_angle_algebra(
+      self, level: int, verbose: bool = False
+  ) -> dict[str, list[tuple[Point, ...]]]:
+    """Derive new eqangles predicates."""
+    added = {'eqangle': [], 'aconst': [], 'para': []}
+
+    for x in self.atable.get_all_eqs_and_why():
+      x, why = x[:-1], x[-1]
+      dep = EmptyDependency(level=level, rule_name='a02')
+      dep.why = why
+
+      if len(x) == 2:
+        a, b = x
+        if gm.is_equiv(a, b):
+          continue
+
+        (e, f), (p, q) = a._obj.points, b._obj.points
+        if not nm.check('para', [e, f, p, q]):
+          continue
+
+        added['para'].append((a, b, dep))
+
+      if len(x) == 3:
+        a, b, (n, d) = x
+
+        (e, f), (p, q) = a._obj.points, b._obj.points
+        if not nm.check('aconst', [e, f, p, q, n, d]):
+          continue
+
+        added['aconst'].append((a, b, n, d, dep))
+
+      if len(x) == 4:
+        a, b, c, d = x
+        added['eqangle'].append((a, b, c, d, dep))
+
+    return added
+
+  def derive_distance_algebra(
+      self, level: int, verbose: bool = False
+  ) -> dict[str, list[tuple[Point, ...]]]:
+    """Derive new cong predicates."""
+    added = {'inci': [], 'cong': [], 'rconst': []}
+    for x in self.dtable.get_all_eqs_and_why():
+      x, why = x[:-1], x[-1]
+      dep = EmptyDependency(level=level, rule_name='a00')
+      dep.why = why
+
+      if len(x) == 2:
+        a, b = x
+        if a == b:
+          continue
+
+        dep.name = f'inci {a.name} {b.name}'
+        added['inci'].append((x, dep))
+
+      if len(x) == 4:
+        a, b, c, d = x
+        if not (a != b and c != d and (a != c or b != d)):
+          continue
+        added['cong'].append((a, b, c, d, dep))
+
+      if len(x) == 6:
+        a, b, c, d, num, den = x
+        if not (a != b and c != d and (a != c or b != d)):
+          continue
+        added['rconst'].append((a, b, c, d, num, den, dep))
+
+    return added
+
+  @classmethod
+  def build_problem(
+      cls,
+      pr: problem.Problem,
+      definitions: dict[str, problem.Definition],
+      verbose: bool = True,
+      init_copy: bool = True,
+  ) -> tuple[Graph, list[Dependency]]:
+    """Build a problem into a gr.Graph object."""
+    check = False
+    g = None
+    added = None
+    if verbose:
+      logging.info(pr.url)
+      logging.info(pr.txt())
+    while not check:
+      try:
+        g = Graph()
+        added = []
+        plevel = 0
+        for clause in pr.clauses:
+          adds, plevel = g.add_clause(
+              clause, plevel, definitions, verbose=verbose
+          )
+          added += adds
+        g.plevel = plevel
+
+      except (nm.InvalidLineIntersectError, nm.InvalidQuadSolveError):
+        continue
+      except DepCheckFailError:
+        continue
+      except (PointTooCloseError, PointTooFarError):
+        continue
+
+      if not pr.goal:
+        break
+
+      args = list(map(lambda x: g.get(x, lambda: int(x)), pr.goal.args))
+      check = nm.check(pr.goal.name, args)
+
+    g.url = pr.url
+    g.build_def = (pr, definitions)
+    for add in added:
+      g.add_algebra(add, level=0)
+
+    return g, added
+
+  def all_points(self) -> list[Point]:
+    """Return all nodes of type Point."""
+    return list(self.type2nodes[Point])
+
+  def all_nodes(self) -> list[gm.Node]:
+    """Return all nodes."""
+    return list(self._name2node.values())
+
+  def add_points(self, pnames: list[str]) -> list[Point]:
+    """Add new points with given names in list pnames."""
+    result = [self.new_node(Point, name) for name in pnames]
+    self._name2point.update(zip(pnames, result))
+    return result
+
+  def names2nodes(self, pnames: list[str]) -> list[gm.Node]:
+    return [self._name2node[name] for name in pnames]
+
+  def names2points(
+      self, pnames: list[str], create_new_point: bool = False
+  ) -> list[Point]:
+    """Return Point objects given names."""
+    result = []
+    for name in pnames:
+      if name not in self._name2node and not create_new_point:
+        raise ValueError(f'Cannot find point {name} in graph')
+      elif name in self._name2node:
+        obj = self._name2node[name]
+      else:
+        obj = self.new_node(Point, name)
+      result.append(obj)
+
+    return result
+
+  def names2points_or_int(self, pnames: list[str]) -> list[Point]:
+    """Return Point objects given names."""
+    result = []
+    for name in pnames:
+      if name.isdigit():
+        result += [int(name)]
+      elif 'pi/' in name:
+        n, d = name.split('pi/')
+        ang, _ = self.get_or_create_const_ang(int(n), int(d))
+        result += [ang]
+      elif '/' in name:
+        n, d = name.split('/')
+        rat, _ = self.get_or_create_const_rat(int(n), int(d))
+        result += [rat]
+      else:
+        result += [self._name2point[name]]
+
+    return result
+
+  def get(self, pointname: str, default_fn: Callable[str, Point]) -> Point:
+    if pointname in self._name2point:
+      return self._name2point[pointname]
+    if pointname in self._name2node:
+      return self._name2node[pointname]
+    return default_fn()
+
+  def new_node(self, oftype: Type[gm.Node], name: str = '') -> gm.Node:
+    node = oftype(name, self)
+
+    self.type2nodes[oftype].append(node)
+    self._name2node[name] = node
+
+    if isinstance(node, Point):
+      self._name2point[name] = node
+
+    return node
+
+  def merge(self, nodes: list[gm.Node], deps: Dependency) -> gm.Node:
+    """Merge all nodes."""
+    if len(nodes) < 2:
+      return
+
+    node0, *nodes1 = nodes
+    all_nodes = self.type2nodes[type(node0)]
+
+    # find node0 that exists in all_nodes to be the rep
+    # and merge all other nodes into node0
+    for node in nodes:
+      if node in all_nodes:
+        node0 = node
+        nodes1 = [n for n in nodes if n != node0]
+        break
+    return self.merge_into(node0, nodes1, deps)
+
+  def merge_into(
+      self, node0: gm.Node, nodes1: list[gm.Node], deps: Dependency
+  ) -> gm.Node:
+    """Merge nodes1 into a single node0."""
+    node0.merge(nodes1, deps)
+    for n in nodes1:
+      if n.rep() != n:
+        self.remove([n])
+
+    nodes = [node0] + nodes1
+    if any([node._val for node in nodes]):
+      for node in nodes:
+        self.connect_val(node, deps=None)
+
+      vals1 = [n._val for n in nodes1]
+      node0._val.merge(vals1, deps)
+
+      for v in vals1:
+        if v.rep() != v:
+          self.remove([v])
+
+    return node0
+
+  def remove(self, nodes: list[gm.Node]) -> None:
+    """Remove nodes out of self because they are merged."""
+    if not nodes:
+      return
+
+    for node in nodes:
+      all_nodes = self.type2nodes[type(nodes[0])]
+
+      if node in all_nodes:
+        all_nodes.remove(node)
+
+      if node.name in self._name2node.values():
+        self._name2node.pop(node.name)
+
+  def connect(self, a: gm.Node, b: gm.Node, deps: Dependency) -> None:
+    a.connect_to(b, deps)
+    b.connect_to(a, deps)
+
+  def connect_val(self, node: gm.Node, deps: Dependency) -> gm.Node:
+    """Connect a node into its value (equality) node."""
+    if node._val:
+      return node._val
+    name = None
+    if isinstance(node, Line):
+      name = 'd(' + node.name + ')'
+    if isinstance(node, Angle):
+      name = 'm(' + node.name + ')'
+    if isinstance(node, Segment):
+      name = 'l(' + node.name + ')'
+    if isinstance(node, Ratio):
+      name = 'r(' + node.name + ')'
+    v = self.new_node(gm.val_type(node), name)
+    self.connect(node, v, deps=deps)
+    return v
+
+  def is_equal(self, x: gm.Node, y: gm.Node, level: int = None) -> bool:
+    return gm.is_equal(x, y, level)
+
+  def add_piece(
+      self, name: str, args: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    """Add a new predicate."""
+    if name in ['coll', 'collx']:
+      return self.add_coll(args, deps)
+    elif name == 'para':
+      return self.add_para(args, deps)
+    elif name == 'perp':
+      return self.add_perp(args, deps)
+    elif name == 'midp':
+      return self.add_midp(args, deps)
+    elif name == 'cong':
+      return self.add_cong(args, deps)
+    elif name == 'circle':
+      return self.add_circle(args, deps)
+    elif name == 'cyclic':
+      return self.add_cyclic(args, deps)
+    elif name in ['eqangle', 'eqangle6']:
+      return self.add_eqangle(args, deps)
+    elif name in ['eqratio', 'eqratio6']:
+      return self.add_eqratio(args, deps)
+    # numerical!
+    elif name == 's_angle':
+      return self.add_s_angle(args, deps)
+    elif name == 'aconst':
+      a, b, c, d, ang = args
+
+      if isinstance(ang, str):
+        name = ang
+      else:
+        name = ang.name
+
+      num, den = name.split('pi/')
+      num, den = int(num), int(den)
+      return self.add_aconst([a, b, c, d, num, den], deps)
+    elif name == 's_angle':
+      b, x, a, b, ang = (  # pylint: disable=redeclared-assigned-name,unused-variable
+          args
+      )
+
+      if isinstance(ang, str):
+        name = ang
+      else:
+        name = ang.name
+
+      n, d = name.split('pi/')
+      ang = int(n) * 180 / int(d)
+      return self.add_s_angle([a, b, x, ang], deps)
+    elif name == 'rconst':
+      a, b, c, d, rat = args
+
+      if isinstance(rat, str):
+        name = rat
+      else:
+        name = rat.name
+
+      num, den = name.split('/')
+      num, den = int(num), int(den)
+      return self.add_eqrat_const([a, b, c, d, num, den], deps)
+
+    # composite pieces:
+    elif name == 'cong2':
+      return self.add_cong2(args, deps)
+    elif name == 'eqratio3':
+      return self.add_eqratio3(args, deps)
+    elif name == 'eqratio4':
+      return self.add_eqratio4(args, deps)
+    elif name == 'simtri':
+      return self.add_simtri(args, deps)
+    elif name == 'contri':
+      return self.add_contri(args, deps)
+    elif name == 'simtri2':
+      return self.add_simtri2(args, deps)
+    elif name == 'contri2':
+      return self.add_contri2(args, deps)
+    elif name == 'simtri*':
+      return self.add_simtri_check(args, deps)
+    elif name == 'contri*':
+      return self.add_contri_check(args, deps)
+    elif name in ['acompute', 'rcompute']:
+      dep = deps.populate(name, args)
+      self.cache_dep(name, args, dep)
+      return [dep]
+    elif name in ['fixl', 'fixc', 'fixb', 'fixt', 'fixp']:
+      dep = deps.populate(name, args)
+      self.cache_dep(name, args, dep)
+      return [dep]
+    elif name in ['ind']:
+      return []
+    raise ValueError(f'Not recognize {name}')
+
+  def check(self, name: str, args: list[Point]) -> bool:
+    """Symbolically check if a predicate is True."""
+    if name == 'ncoll':
+      return self.check_ncoll(args)
+    if name == 'npara':
+      return self.check_npara(args)
+    if name == 'nperp':
+      return self.check_nperp(args)
+    if name == 'midp':
+      return self.check_midp(args)
+    if name == 'cong':
+      return self.check_cong(args)
+    if name == 'perp':
+      return self.check_perp(args)
+    if name == 'para':
+      return self.check_para(args)
+    if name == 'coll':
+      return self.check_coll(args)
+    if name == 'cyclic':
+      return self.check_cyclic(args)
+    if name == 'circle':
+      return self.check_circle(args)
+    if name == 'aconst':
+      return self.check_aconst(args)
+    if name == 'rconst':
+      return self.check_rconst(args)
+    if name == 'acompute':
+      return self.check_acompute(args)
+    if name == 'rcompute':
+      return self.check_rcompute(args)
+    if name in ['eqangle', 'eqangle6']:
+      if len(args) == 5:
+        return self.check_aconst(args)
+      return self.check_eqangle(args)
+    if name in ['eqratio', 'eqratio6']:
+      if len(args) == 5:
+        return self.check_rconst(args)
+      return self.check_eqratio(args)
+    if name in ['simtri', 'simtri2', 'simtri*']:
+      return self.check_simtri(args)
+    if name in ['contri', 'contri2', 'contri*']:
+      return self.check_contri(args)
+    if name == 'sameside':
+      return self.check_sameside(args)
+    if name in 'diff':
+      a, b = args
+      return not a.num.close(b.num)
+    if name in ['fixl', 'fixc', 'fixb', 'fixt', 'fixp']:
+      return self.in_cache(name, args)
+    if name in ['ind']:
+      return True
+    raise ValueError(f'Not recognize {name}')
+
+  def get_lines_thru_all(self, *points: list[gm.Point]) -> list[Line]:
+    line2count = defaultdict(lambda: 0)
+    points = set(points)
+    for p in points:
+      for l in p.neighbors(Line):
+        line2count[l] += 1
+    return [l for l, count in line2count.items() if count == len(points)]
+
+  def _get_line(self, a: Point, b: Point) -> Optional[Line]:
+    linesa = a.neighbors(Line)
+    for l in b.neighbors(Line):
+      if l in linesa:
+        return l
+    return None
+
+  def _get_line_all(self, a: Point, b: Point) -> Generator[Line, None, None]:
+    linesa = a.neighbors(Line, do_rep=False)
+    linesb = b.neighbors(Line, do_rep=False)
+    for l in linesb:
+      if l in linesa:
+        yield l
+
+  def _get_lines(self, *points: list[Point]) -> list[Line]:
+    """Return all lines that connect to >= 2 points."""
+    line2count = defaultdict(lambda: 0)
+    for p in points:
+      for l in p.neighbors(Line):
+        line2count[l] += 1
+    return [l for l, count in line2count.items() if count >= 2]
+
+  def get_circle_thru_triplet(self, p1: Point, p2: Point, p3: Point) -> Circle:
+    p1, p2, p3 = sorted([p1, p2, p3], key=lambda x: x.name)
+    if (p1, p2, p3) in self._triplet2circle:
+      return self._triplet2circle[(p1, p2, p3)]
+    return self.get_new_circle_thru_triplet(p1, p2, p3)
+
+  def get_new_circle_thru_triplet(
+      self, p1: Point, p2: Point, p3: Point
+  ) -> Circle:
+    """Get a new Circle that goes thru three given Points."""
+    p1, p2, p3 = sorted([p1, p2, p3], key=lambda x: x.name)
+    name = p1.name.lower() + p2.name.lower() + p3.name.lower()
+    circle = self.new_node(Circle, f'({name})')
+    circle.num = nm.Circle(p1=p1.num, p2=p2.num, p3=p3.num)
+    circle.points = p1, p2, p3
+
+    self.connect(p1, circle, deps=None)
+    self.connect(p2, circle, deps=None)
+    self.connect(p3, circle, deps=None)
+    self._triplet2circle[(p1, p2, p3)] = circle
+    return circle
+
+  def get_line_thru_pair(self, p1: Point, p2: Point) -> Line:
+    if (p1, p2) in self._pair2line:
+      return self._pair2line[(p1, p2)]
+    if (p2, p1) in self._pair2line:
+      return self._pair2line[(p2, p1)]
+    return self.get_new_line_thru_pair(p1, p2)
+
+  def get_new_line_thru_pair(self, p1: Point, p2: Point) -> Line:
+    if p1.name.lower() > p2.name.lower():
+      p1, p2 = p2, p1
+    name = p1.name.lower() + p2.name.lower()
+    line = self.new_node(Line, name)
+    line.num = nm.Line(p1.num, p2.num)
+    line.points = p1, p2
+
+    self.connect(p1, line, deps=None)
+    self.connect(p2, line, deps=None)
+    self._pair2line[(p1, p2)] = line
+    return line
+
+  def get_line_thru_pair_why(
+      self, p1: Point, p2: Point
+  ) -> tuple[Line, list[Dependency]]:
+    """Get one line thru two given points and the corresponding dependency list."""
+    if p1.name.lower() > p2.name.lower():
+      p1, p2 = p2, p1
+    if (p1, p2) in self._pair2line:
+      return self._pair2line[(p1, p2)].rep_and_why()
+
+    l, why = gm.line_of_and_why([p1, p2])
+    if l is None:
+      l = self.get_new_line_thru_pair(p1, p2)
+      why = []
+    return l, why
+
+  def coll_dep(self, points: list[Point], p: Point) -> list[Dependency]:
+    """Return the dep(.why) explaining why p is coll with points."""
+    for p1, p2 in utils.comb2(points):
+      if self.check_coll([p1, p2, p]):
+        dep = Dependency('coll', [p1, p2, p], None, None)
+        return dep.why_me_or_cache(self, None)
+
+  def add_coll(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    """Add a predicate that `points` are collinear."""
+    points = list(set(points))
+    og_points = list(points)
+
+    all_lines = []
+    for p1, p2 in utils.comb2(points):
+      all_lines.append(self.get_line_thru_pair(p1, p2))
+    points = sum([l.neighbors(Point) for l in all_lines], [])
+    points = list(set(points))
+
+    existed = set()
+    new = set()
+    for p1, p2 in utils.comb2(points):
+      if p1.name > p2.name:
+        p1, p2 = p2, p1
+      if (p1, p2) in self._pair2line:
+        line = self._pair2line[(p1, p2)]
+        existed.add(line)
+      else:
+        line = self.get_new_line_thru_pair(p1, p2)
+        new.add(line)
+
+    existed = sorted(existed, key=lambda l: l.name)
+    new = sorted(new, key=lambda l: l.name)
+
+    existed, new = list(existed), list(new)
+    if not existed:
+      line0, *lines = new
+    else:
+      line0, lines = existed[0], existed[1:] + new
+
+    add = []
+    line0, why0 = line0.rep_and_why()
+    a, b = line0.points
+    for line in lines:
+      c, d = line.points
+      args = list({a, b, c, d})
+      if len(args) < 3:
+        continue
+
+      whys = []
+      for x in args:
+        if x not in og_points:
+          whys.append(self.coll_dep(og_points, x))
+
+      abcd_deps = deps
+      if whys + why0:
+        dep0 = deps.populate('coll', og_points)
+        abcd_deps = EmptyDependency(level=deps.level, rule_name=None)
+        abcd_deps.why = [dep0] + whys
+
+      is_coll = self.check_coll(args)
+      dep = abcd_deps.populate('coll', args)
+      self.cache_dep('coll', args, dep)
+      self.merge_into(line0, [line], dep)
+
+      if not is_coll:
+        add += [dep]
+
+    return add
+
+  def check_coll(self, points: list[Point]) -> bool:
+    points = list(set(points))
+    if len(points) < 3:
+      return True
+    line2count = defaultdict(lambda: 0)
+    for p in points:
+      for l in p.neighbors(Line):
+        line2count[l] += 1
+    return any([count == len(points) for _, count in line2count.items()])
+
+  def why_coll(self, args: tuple[Line, list[Point]]) -> list[Dependency]:
+    line, points = args
+    return line.why_coll(points)
+
+  def check_ncoll(self, points: list[Point]) -> bool:
+    if self.check_coll(points):
+      return False
+    return not nm.check_coll([p.num for p in points])
+
+  def check_sameside(self, points: list[Point]) -> bool:
+    return nm.check_sameside([p.num for p in points])
+
+  def make_equal(self, x: gm.Node, y: gm.Node, deps: Dependency) -> None:
+    """Make that two nodes x and y are equal, i.e. merge their value node."""
+    if x.val is None:
+      x, y = y, x
+
+    self.connect_val(x, deps=None)
+    self.connect_val(y, deps=None)
+    vx = x._val
+    vy = y._val
+
+    if vx == vy:
+      return
+
+    merges = [vx, vy]
+
+    if (
+        isinstance(x, Angle)
+        and x not in self.aconst.values()
+        and y not in self.aconst.values()
+        and x.directions == y.directions[::-1]
+        and x.directions[0] != x.directions[1]
+    ):
+      merges = [self.vhalfpi, vx, vy]
+
+    self.merge(merges, deps)
+
+  def merge_vals(self, vx: gm.Node, vy: gm.Node, deps: Dependency) -> None:
+    if vx == vy:
+      return
+    merges = [vx, vy]
+    self.merge(merges, deps)
+
+  def why_equal(self, x: gm.Node, y: gm.Node, level: int) -> list[Dependency]:
+    return gm.why_equal(x, y, level)
+
+  def _why_coll4(
+      self,
+      a: Point,
+      b: Point,
+      ab: Line,
+      c: Point,
+      d: Point,
+      cd: Line,
+      level: int,
+  ) -> list[Dependency]:
+    return self._why_coll2(a, b, ab, level) + self._why_coll2(c, d, cd, level)
+
+  def _why_coll8(
+      self,
+      a: Point,
+      b: Point,
+      ab: Line,
+      c: Point,
+      d: Point,
+      cd: Line,
+      m: Point,
+      n: Point,
+      mn: Line,
+      p: Point,
+      q: Point,
+      pq: Line,
+      level: int,
+  ) -> list[Dependency]:
+    """Dependency list of why 8 points are collinear."""
+    why8 = self._why_coll4(a, b, ab, c, d, cd, level)
+    why8 += self._why_coll4(m, n, mn, p, q, pq, level)
+    return why8
+
+  def add_para(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    """Add a new predicate that 4 points (2 lines) are parallel."""
+    a, b, c, d = points
+    ab, why1 = self.get_line_thru_pair_why(a, b)
+    cd, why2 = self.get_line_thru_pair_why(c, d)
+
+    is_equal = self.is_equal(ab, cd)
+
+    (a, b), (c, d) = ab.points, cd.points
+
+    dep0 = deps.populate('para', points)
+    deps = EmptyDependency(level=deps.level, rule_name=None)
+
+    deps = deps.populate('para', [a, b, c, d])
+    deps.why = [dep0] + why1 + why2
+
+    self.make_equal(ab, cd, deps)
+    deps.algebra = ab._val, cd._val
+
+    self.cache_dep('para', [a, b, c, d], deps)
+    if not is_equal:
+      return [deps]
+    return []
+
+  def why_para(self, args: list[Point]) -> list[Dependency]:
+    ab, cd, lvl = args
+    return self.why_equal(ab, cd, lvl)
+
+  def check_para_or_coll(self, points: list[Point]) -> bool:
+    return self.check_para(points) or self.check_coll(points)
+
+  def check_para(self, points: list[Point]) -> bool:
+    a, b, c, d = points
+    if (a == b) or (c == d):
+      return False
+    ab = self._get_line(a, b)
+    cd = self._get_line(c, d)
+    if not ab or not cd:
+      return False
+
+    return self.is_equal(ab, cd)
+
+  def check_npara(self, points: list[Point]) -> bool:
+    if self.check_para(points):
+      return False
+    return not nm.check_para([p.num for p in points])
+
+  def _get_angle(
+      self, d1: Direction, d2: Direction
+  ) -> tuple[Angle, Optional[Angle]]:
+    for a in self.type2nodes[Angle]:
+      if a.directions == (d1, d2):
+        return a, a.opposite
+    return None, None
+
+  def get_first_angle(
+      self, l1: Line, l2: Line
+  ) -> tuple[Angle, list[Dependency]]:
+    """Get a first angle between line l1 and line l2."""
+    d1, d2 = l1._val, l2._val
+
+    d1s = d1.all_reps()
+    d2s = d2.all_reps()
+
+    found = d1.first_angle(d2s)
+    if found is None:
+      found = d2.first_angle(d1s)
+      if found is None:
+        return None, []
+      ang, x2, x1 = found
+      found = ang.opposite, x1, x2
+
+    ang, x1, x2 = found
+    return ang, d1.deps_upto(x1) + d2.deps_upto(x2)
+
+  def _get_or_create_angle(
+      self, l1: Line, l2: Line, deps: Dependency
+  ) -> tuple[Angle, Angle, list[Dependency]]:
+    return self.get_or_create_angle_d(l1._val, l2._val, deps)
+
+  def get_or_create_angle_d(
+      self, d1: Direction, d2: Direction, deps: Dependency
+  ) -> tuple[Angle, Angle, list[Dependency]]:
+    """Get or create an angle between two Direction d1 and d2."""
+    for a in self.type2nodes[Angle]:
+      if a.directions == (d1.rep(), d2.rep()):  # directions = _d.rep()
+        d1_, d2_ = a._d
+        why1 = d1.why_equal([d1_], None) + d1_.why_rep()
+        why2 = d2.why_equal([d2_], None) + d2_.why_rep()
+        return a, a.opposite, why1 + why2
+
+    d1, why1 = d1.rep_and_why()
+    d2, why2 = d2.rep_and_why()
+    a12 = self.new_node(Angle, f'{d1.name}-{d2.name}')
+    a21 = self.new_node(Angle, f'{d2.name}-{d1.name}')
+    self.connect(d1, a12, deps)
+    self.connect(d2, a21, deps)
+    self.connect(a12, a21, deps)
+    a12.set_directions(d1, d2)
+    a21.set_directions(d2, d1)
+    a12.opposite = a21
+    a21.opposite = a12
+    return a12, a21, why1 + why2
+
+  def _add_para_or_coll(
+      self,
+      a: Point,
+      b: Point,
+      c: Point,
+      d: Point,
+      x: Point,
+      y: Point,
+      m: Point,
+      n: Point,
+      deps: EmptyDependency,
+  ) -> list[Dependency]:
+    """Add a new parallel or collinear predicate."""
+    extends = [('perp', [x, y, m, n])]
+    if {a, b} == {x, y}:
+      pass
+    elif self.check_para([a, b, x, y]):
+      extends.append(('para', [a, b, x, y]))
+    elif self.check_coll([a, b, x, y]):
+      extends.append(('coll', set(list([a, b, x, y]))))
+    else:
+      return None
+
+    if m in [c, d] or n in [c, d] or c in [m, n] or d in [m, n]:
+      pass
+    elif self.check_coll([c, d, m]):
+      extends.append(('coll', [c, d, m]))
+    elif self.check_coll([c, d, n]):
+      extends.append(('coll', [c, d, n]))
+    elif self.check_coll([c, m, n]):
+      extends.append(('coll', [c, m, n]))
+    elif self.check_coll([d, m, n]):
+      extends.append(('coll', [d, m, n]))
+    else:
+      deps = deps.extend_many(self, 'perp', [a, b, c, d], extends)
+      return self.add_para([c, d, m, n], deps)
+
+    deps = deps.extend_many(self, 'perp', [a, b, c, d], extends)
+    return self.add_coll(list(set([c, d, m, n])), deps)
+
+  def maybe_make_para_from_perp(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> Optional[list[Dependency]]:
+    """Maybe add a new parallel predicate from perp predicate."""
+    a, b, c, d = points
+    halfpi = self.aconst[(1, 2)]
+    for ang in halfpi.val.neighbors(Angle):
+      if ang == halfpi:
+        continue
+      d1, d2 = ang.directions
+      x, y = d1._obj.points
+      m, n = d2._obj.points
+
+      for args in [
+          (a, b, c, d, x, y, m, n),
+          (a, b, c, d, m, n, x, y),
+          (c, d, a, b, x, y, m, n),
+          (c, d, a, b, m, n, x, y),
+      ]:
+        args = args + (deps,)
+        add = self._add_para_or_coll(*args)
+        if add:
+          return add
+
+    return None
+
+  def add_perp(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    """Add a new perpendicular predicate from 4 points (2 lines)."""
+    add = self.maybe_make_para_from_perp(points, deps)
+    if add is not None:
+      return add
+
+    a, b, c, d = points
+    ab, why1 = self.get_line_thru_pair_why(a, b)
+    cd, why2 = self.get_line_thru_pair_why(c, d)
+
+    (a, b), (c, d) = ab.points, cd.points
+
+    if why1 + why2:
+      dep0 = deps.populate('perp', points)
+      deps = EmptyDependency(level=deps.level, rule_name=None)
+      deps.why = [dep0] + why1 + why2
+
+    self.connect_val(ab, deps=None)
+    self.connect_val(cd, deps=None)
+
+    if ab.val == cd.val:
+      raise ValueError(f'{ab.name} and {cd.name} Cannot be perp.')
+
+    args = [a, b, c, d]
+    i = 0
+    for x, y, xy in [(a, b, ab), (c, d, cd)]:
+      i += 1
+      x_, y_ = xy._val._obj.points
+      if {x, y} == {x_, y_}:
+        continue
+      if deps:
+        deps = deps.extend(self, 'perp', list(args), 'para', [x, y, x_, y_])
+      args[2 * i - 2] = x_
+      args[2 * i - 1] = y_
+
+    a12, a21, why = self._get_or_create_angle(ab, cd, deps=None)
+
+    if why:
+      dep0 = deps.populate('perp', [a, b, c, d])
+      deps = EmptyDependency(level=deps.level, rule_name=None)
+      deps.why = [dep0] + why
+
+    dab, dcd = a12._d
+    a, b = dab._obj.points
+    c, d = dcd._obj.points
+
+    is_equal = self.is_equal(a12, a21)
+    deps = deps.populate('perp', [a, b, c, d])
+    deps.algebra = [dab, dcd]
+    self.make_equal(a12, a21, deps=deps)
+
+    self.cache_dep('perp', [a, b, c, d], deps)
+    self.cache_dep('eqangle', [a, b, c, d, c, d, a, b], deps)
+
+    if not is_equal:
+      return [deps]
+    return []
+
+  def why_perp(
+      self, args: list[Union[Point, list[Dependency]]]
+  ) -> list[Dependency]:
+    a, b, deps = args
+    return deps + self.why_equal(a, b, None)
+
+  def check_perpl(self, ab: Line, cd: Line) -> bool:
+    if ab.val is None or cd.val is None:
+      return False
+    if ab.val == cd.val:
+      return False
+    a12, a21 = self._get_angle(ab.val, cd.val)
+    if a12 is None or a21 is None:
+      return False
+    return self.is_equal(a12, a21)
+
+  def check_perp(self, points: list[Point]) -> bool:
+    a, b, c, d = points
+    ab = self._get_line(a, b)
+    cd = self._get_line(c, d)
+    if not ab or not cd:
+      return False
+    return self.check_perpl(ab, cd)
+
+  def check_nperp(self, points: list[Point]) -> bool:
+    if self.check_perp(points):
+      return False
+    return not nm.check_perp([p.num for p in points])
+
+  def _get_segment(self, p1: Point, p2: Point) -> Optional[Segment]:
+    for s in self.type2nodes[Segment]:
+      if s.points == {p1, p2}:
+        return s
+    return None
+
+  def _get_or_create_segment(
+      self, p1: Point, p2: Point, deps: Dependency
+  ) -> Segment:
+    """Get or create a Segment object between two Points p1 and p2."""
+    if p1 == p2:
+      raise ValueError(f'Creating same 0-length segment {p1.name}')
+
+    for s in self.type2nodes[Segment]:
+      if s.points == {p1, p2}:
+        return s
+
+    if p1.name > p2.name:
+      p1, p2 = p2, p1
+    s = self.new_node(Segment, name=f'{p1.name.upper()}{p2.name.upper()}')
+    self.connect(p1, s, deps=deps)
+    self.connect(p2, s, deps=deps)
+    s.points = {p1, p2}
+    return s
+
+  def add_cong(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    """Add that two segments (4 points) are congruent."""
+    a, b, c, d = points
+    ab = self._get_or_create_segment(a, b, deps=None)
+    cd = self._get_or_create_segment(c, d, deps=None)
+
+    is_equal = self.is_equal(ab, cd)
+
+    dep = deps.populate('cong', [a, b, c, d])
+    self.make_equal(ab, cd, deps=dep)
+    dep.algebra = ab._val, cd._val
+
+    self.cache_dep('cong', [a, b, c, d], dep)
+
+    result = []
+
+    if not is_equal:
+      result += [dep]
+
+    if a not in [c, d] and b not in [c, d]:
+      return result
+
+    if b in [c, d]:
+      a, b = b, a
+    if a == d:
+      c, d = d, c  # pylint: disable=unused-variable
+
+    result += self._maybe_add_cyclic_from_cong(a, b, d, dep)
+    return result
+
+  def _maybe_add_cyclic_from_cong(
+      self, a: Point, b: Point, c: Point, cong_ab_ac: Dependency
+  ) -> list[Dependency]:
+    """Maybe add a new cyclic predicate from given congruent segments."""
+    ab = self._get_or_create_segment(a, b, deps=None)
+
+    # all eq segs with one end being a.
+    segs = [s for s in ab.val.neighbors(Segment) if a in s.points]
+
+    # all points on circle (a, b)
+    points = []
+    for s in segs:
+      x, y = list(s.points)
+      points.append(x if y == a else y)
+
+    # for sure both b and c are in points
+    points = [p for p in points if p not in [b, c]]
+
+    if len(points) < 2:
+      return []
+
+    x, y = points[:2]
+
+    if self.check_cyclic([b, c, x, y]):
+      return []
+
+    ax = self._get_or_create_segment(a, x, deps=None)
+    ay = self._get_or_create_segment(a, y, deps=None)
+    why = ab._val.why_equal([ax._val, ay._val], level=None)
+    why += [cong_ab_ac]
+
+    deps = EmptyDependency(cong_ab_ac.level, '')
+    deps.why = why
+
+    return self.add_cyclic([b, c, x, y], deps)
+
+  def check_cong(self, points: list[Point]) -> bool:
+    a, b, c, d = points
+    if {a, b} == {c, d}:
+      return True
+
+    ab = self._get_segment(a, b)
+    cd = self._get_segment(c, d)
+    if ab is None or cd is None:
+      return False
+    return self.is_equal(ab, cd)
+
+  def why_cong(self, args: tuple[Segment, Segment]) -> list[Dependency]:
+    ab, cd = args
+    return self.why_equal(ab, cd, None)
+
+  def add_midp(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    m, a, b = points
+    add = self.add_coll(points, deps=deps)
+    add += self.add_cong([m, a, m, b], deps)
+    return add
+
+  def why_midp(
+      self, args: tuple[Line, list[Point], Segment, Segment]
+  ) -> list[Dependency]:
+    line, points, ma, mb = args
+    return self.why_coll([line, points]) + self.why_cong([ma, mb])
+
+  def check_midp(self, points: list[Point]) -> bool:
+    if not self.check_coll(points):
+      return False
+    m, a, b = points
+    return self.check_cong([m, a, m, b])
+
+  def add_circle(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    o, a, b, c = points
+    add = self.add_cong([o, a, o, b], deps=deps)
+    add += self.add_cong([o, a, o, c], deps=deps)
+    return add
+
+  def why_circle(
+      self, args: tuple[Segment, Segment, Segment]
+  ) -> list[Dependency]:
+    oa, ob, oc = args
+    return self.why_equal(oa, ob, None) and self.why_equal(oa, oc, None)
+
+  def check_circle(self, points: list[Point]) -> bool:
+    o, a, b, c = points
+    return self.check_cong([o, a, o, b]) and self.check_cong([o, a, o, c])
+
+  def get_circles_thru_all(self, *points: list[Point]) -> list[Circle]:
+    circle2count = defaultdict(lambda: 0)
+    points = set(points)
+    for p in points:
+      for c in p.neighbors(Circle):
+        circle2count[c] += 1
+    return [c for c, count in circle2count.items() if count == len(points)]
+
+  def _get_circles(self, *points: list[Point]) -> list[Circle]:
+    circle2count = defaultdict(lambda: 0)
+    for p in points:
+      for c in p.neighbors(Circle):
+        circle2count[c] += 1
+    return [c for c, count in circle2count.items() if count >= 3]
+
+  def cyclic_dep(self, points: list[Point], p: Point) -> list[Dependency]:
+    for p1, p2, p3 in utils.comb3(points):
+      if self.check_cyclic([p1, p2, p3, p]):
+        dep = Dependency('cyclic', [p1, p2, p3, p], None, None)
+        return dep.why_me_or_cache(self, None)
+
+  def add_cyclic(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    """Add a new cyclic predicate that 4 points are concyclic."""
+    points = list(set(points))
+    og_points = list(points)
+
+    all_circles = []
+    for p1, p2, p3 in utils.comb3(points):
+      all_circles.append(self.get_circle_thru_triplet(p1, p2, p3))
+    points = sum([c.neighbors(Point) for c in all_circles], [])
+    points = list(set(points))
+
+    existed = set()
+    new = set()
+    for p1, p2, p3 in utils.comb3(points):
+      p1, p2, p3 = sorted([p1, p2, p3], key=lambda x: x.name)
+
+      if (p1, p2, p3) in self._triplet2circle:
+        circle = self._triplet2circle[(p1, p2, p3)]
+        existed.add(circle)
+      else:
+        circle = self.get_new_circle_thru_triplet(p1, p2, p3)
+        new.add(circle)
+
+    existed = sorted(existed, key=lambda l: l.name)
+    new = sorted(new, key=lambda l: l.name)
+
+    existed, new = list(existed), list(new)
+    if not existed:
+      circle0, *circles = new
+    else:
+      circle0, circles = existed[0], existed[1:] + new
+
+    add = []
+    circle0, why0 = circle0.rep_and_why()
+    a, b, c = circle0.points
+    for circle in circles:
+      d, e, f = circle.points
+      args = list({a, b, c, d, e, f})
+      if len(args) < 4:
+        continue
+      whys = []
+      for x in [a, b, c, d, e, f]:
+        if x not in og_points:
+          whys.append(self.cyclic_dep(og_points, x))
+      abcdef_deps = deps
+      if whys + why0:
+        dep0 = deps.populate('cyclic', og_points)
+        abcdef_deps = EmptyDependency(level=deps.level, rule_name=None)
+        abcdef_deps.why = [dep0] + whys
+
+      is_cyclic = self.check_cyclic(args)
+
+      dep = abcdef_deps.populate('cyclic', args)
+      self.cache_dep('cyclic', args, dep)
+      self.merge_into(circle0, [circle], dep)
+      if not is_cyclic:
+        add += [dep]
+
+    return add
+
+  def check_cyclic(self, points: list[Point]) -> bool:
+    points = list(set(points))
+    if len(points) < 4:
+      return True
+    circle2count = defaultdict(lambda: 0)
+    for p in points:
+      for c in p.neighbors(Circle):
+        circle2count[c] += 1
+    return any([count == len(points) for _, count in circle2count.items()])
+
+  def make_equal_pairs(
+      self,
+      a: Point,
+      b: Point,
+      c: Point,
+      d: Point,
+      m: Point,
+      n: Point,
+      p: Point,
+      q: Point,
+      ab: Line,
+      cd: Line,
+      mn: Line,
+      pq: Line,
+      deps: EmptyDependency,
+  ) -> list[Dependency]:
+    """Add ab/cd = mn/pq in case either two of (ab,cd,mn,pq) are equal."""
+    depname = 'eqratio' if isinstance(ab, Segment) else 'eqangle'
+    eqname = 'cong' if isinstance(ab, Segment) else 'para'
+
+    is_equal = self.is_equal(mn, pq)
+
+    if ab != cd:
+      dep0 = deps.populate(depname, [a, b, c, d, m, n, p, q])
+      deps = EmptyDependency(level=deps.level, rule_name=None)
+
+      dep = Dependency(eqname, [a, b, c, d], None, deps.level)
+      deps.why = [dep0, dep.why_me_or_cache(self, None)]
+
+    elif eqname == 'para':  # ab == cd.
+      colls = [a, b, c, d]
+      if len(set(colls)) > 2:
+        dep0 = deps.populate(depname, [a, b, c, d, m, n, p, q])
+        deps = EmptyDependency(level=deps.level, rule_name=None)
+
+        dep = Dependency('collx', colls, None, deps.level)
+        deps.why = [dep0, dep.why_me_or_cache(self, None)]
+
+    deps = deps.populate(eqname, [m, n, p, q])
+    self.make_equal(mn, pq, deps=deps)
+
+    deps.algebra = mn._val, pq._val
+    self.cache_dep(eqname, [m, n, p, q], deps)
+
+    if is_equal:
+      return []
+    return [deps]
+
+  def maybe_make_equal_pairs(
+      self,
+      a: Point,
+      b: Point,
+      c: Point,
+      d: Point,
+      m: Point,
+      n: Point,
+      p: Point,
+      q: Point,
+      ab: Line,
+      cd: Line,
+      mn: Line,
+      pq: Line,
+      deps: EmptyDependency,
+  ) -> Optional[list[Dependency]]:
+    """Add ab/cd = mn/pq in case maybe either two of (ab,cd,mn,pq) are equal."""
+    level = deps.level
+    if self.is_equal(ab, cd, level):
+      return self.make_equal_pairs(a, b, c, d, m, n, p, q, ab, cd, mn, pq, deps)
+    elif self.is_equal(mn, pq, level):
+      return self.make_equal_pairs(  # pylint: disable=arguments-out-of-order
+          m,
+          n,
+          p,
+          q,
+          a,
+          b,
+          c,
+          d,
+          mn,
+          pq,
+          ab,
+          cd,
+          deps,
+      )
+    elif self.is_equal(ab, mn, level):
+      return self.make_equal_pairs(  # pylint: disable=arguments-out-of-order
+          a,
+          b,
+          m,
+          n,
+          c,
+          d,
+          p,
+          q,
+          ab,
+          mn,
+          cd,
+          pq,
+          deps,
+      )
+    elif self.is_equal(cd, pq, level):
+      return self.make_equal_pairs(  # pylint: disable=arguments-out-of-order
+          c,
+          d,
+          p,
+          q,
+          a,
+          b,
+          m,
+          n,
+          cd,
+          pq,
+          ab,
+          mn,
+          deps,
+      )
+    else:
+      return None
+
+  def _add_eqangle(
+      self,
+      a: Point,
+      b: Point,
+      c: Point,
+      d: Point,
+      m: Point,
+      n: Point,
+      p: Point,
+      q: Point,
+      ab: Line,
+      cd: Line,
+      mn: Line,
+      pq: Line,
+      deps: EmptyDependency,
+  ) -> list[Dependency]:
+    """Add eqangle core."""
+    if deps:
+      deps = deps.copy()
+
+    args = [a, b, c, d, m, n, p, q]
+    i = 0
+    for x, y, xy in [(a, b, ab), (c, d, cd), (m, n, mn), (p, q, pq)]:
+      i += 1
+      x_, y_ = xy._val._obj.points
+      if {x, y} == {x_, y_}:
+        continue
+      if deps:
+        deps = deps.extend(self, 'eqangle', list(args), 'para', [x, y, x_, y_])
+
+        args[2 * i - 2] = x_
+        args[2 * i - 1] = y_
+
+    add = []
+    ab_cd, cd_ab, why1 = self._get_or_create_angle(ab, cd, deps=None)
+    mn_pq, pq_mn, why2 = self._get_or_create_angle(mn, pq, deps=None)
+
+    why = why1 + why2
+    if why:
+      dep0 = deps.populate('eqangle', args)
+      deps = EmptyDependency(level=deps.level, rule_name=None)
+      deps.why = [dep0] + why
+
+    dab, dcd = ab_cd._d
+    dmn, dpq = mn_pq._d
+
+    a, b = dab._obj.points
+    c, d = dcd._obj.points
+    m, n = dmn._obj.points
+    p, q = dpq._obj.points
+
+    is_eq1 = self.is_equal(ab_cd, mn_pq)
+    deps1 = None
+    if deps:
+      deps1 = deps.populate('eqangle', [a, b, c, d, m, n, p, q])
+      deps1.algebra = [dab, dcd, dmn, dpq]
+    if not is_eq1:
+      add += [deps1]
+    self.cache_dep('eqangle', [a, b, c, d, m, n, p, q], deps1)
+    self.make_equal(ab_cd, mn_pq, deps=deps1)
+
+    is_eq2 = self.is_equal(cd_ab, pq_mn)
+    deps2 = None
+    if deps:
+      deps2 = deps.populate('eqangle', [c, d, a, b, p, q, m, n])
+      deps2.algebra = [dcd, dab, dpq, dmn]
+    if not is_eq2:
+      add += [deps2]
+    self.cache_dep('eqangle', [c, d, a, b, p, q, m, n], deps2)
+    self.make_equal(cd_ab, pq_mn, deps=deps2)
+
+    return add
+
+  def add_eqangle(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    """Add eqangle made by 8 points in `points`."""
+    if deps:
+      deps = deps.copy()
+    a, b, c, d, m, n, p, q = points
+    ab, why1 = self.get_line_thru_pair_why(a, b)
+    cd, why2 = self.get_line_thru_pair_why(c, d)
+    mn, why3 = self.get_line_thru_pair_why(m, n)
+    pq, why4 = self.get_line_thru_pair_why(p, q)
+
+    a, b = ab.points
+    c, d = cd.points
+    m, n = mn.points
+    p, q = pq.points
+
+    if deps and why1 + why2 + why3 + why4:
+      dep0 = deps.populate('eqangle', points)
+      deps = EmptyDependency(level=deps.level, rule_name=None)
+      deps.why = [dep0] + why1 + why2 + why3 + why4
+
+    add = self.maybe_make_equal_pairs(
+        a, b, c, d, m, n, p, q, ab, cd, mn, pq, deps
+    )
+
+    if add is not None:
+      return add
+
+    self.connect_val(ab, deps=None)
+    self.connect_val(cd, deps=None)
+    self.connect_val(mn, deps=None)
+    self.connect_val(pq, deps=None)
+
+    add = []
+    if (
+        ab.val != cd.val
+        and mn.val != pq.val
+        and (ab.val != mn.val or cd.val != pq.val)
+    ):
+      add += self._add_eqangle(a, b, c, d, m, n, p, q, ab, cd, mn, pq, deps)
+
+    if (
+        ab.val != mn.val
+        and cd.val != pq.val
+        and (ab.val != cd.val or mn.val != pq.val)
+    ):
+      add += self._add_eqangle(  # pylint: disable=arguments-out-of-order
+          a,
+          b,
+          m,
+          n,
+          c,
+          d,
+          p,
+          q,
+          ab,
+          mn,
+          cd,
+          pq,
+          deps,
+      )
+
+    return add
+
+  def add_aconst(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    """Add that an angle is equal to some constant."""
+    a, b, c, d, num, den = points
+    nd, dn = self.get_or_create_const_ang(num, den)
+
+    if nd == self.halfpi:
+      return self.add_perp([a, b, c, d], deps)
+
+    ab, why1 = self.get_line_thru_pair_why(a, b)
+    cd, why2 = self.get_line_thru_pair_why(c, d)
+
+    (a, b), (c, d) = ab.points, cd.points
+    if why1 + why2:
+      args = points[:-2] + [nd]
+      dep0 = deps.populate('aconst', args)
+      deps = EmptyDependency(level=deps.level, rule_name=None)
+      deps.why = [dep0] + why1 + why2
+
+    self.connect_val(ab, deps=None)
+    self.connect_val(cd, deps=None)
+
+    if ab.val == cd.val:
+      raise ValueError(f'{ab.name} - {cd.name} cannot be {nd.name}')
+
+    args = [a, b, c, d, nd]
+    i = 0
+    for x, y, xy in [(a, b, ab), (c, d, cd)]:
+      i += 1
+      x_, y_ = xy._val._obj.points
+      if {x, y} == {x_, y_}:
+        continue
+      if deps:
+        deps = deps.extend(self, 'aconst', list(args), 'para', [x, y, x_, y_])
+      args[2 * i - 2] = x_
+      args[2 * i - 1] = y_
+
+    ab_cd, cd_ab, why = self._get_or_create_angle(ab, cd, deps=None)
+    if why:
+      dep0 = deps.populate('aconst', [a, b, c, d, nd])
+      deps = EmptyDependency(level=deps.level, rule_name=None)
+      deps.why = [dep0] + why
+
+    dab, dcd = ab_cd._d
+    a, b = dab._obj.points
+    c, d = dcd._obj.points
+
+    ang = int(num) * 180 / int(den)
+    add = []
+    if not self.is_equal(ab_cd, nd):
+      deps1 = deps.populate('aconst', [a, b, c, d, nd])
+      deps1.algebra = dab, dcd, ang % 180
+      self.make_equal(ab_cd, nd, deps=deps1)
+      self.cache_dep('aconst', [a, b, c, d, nd], deps1)
+      add += [deps1]
+
+    if not self.is_equal(cd_ab, dn):
+      deps2 = deps.populate('aconst', [c, d, a, b, dn])
+      deps2.algebra = dcd, dab, 180 - ang % 180
+      self.make_equal(cd_ab, dn, deps=deps2)
+      self.cache_dep('aconst', [c, d, a, b, dn], deps2)
+      add += [deps2]
+    return add
+
+  def add_s_angle(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    """Add that an angle abx is equal to constant y."""
+    a, b, x, y = points
+
+    n, d = ar.simplify(y % 180, 180)
+    nd, dn = self.get_or_create_const_ang(n, d)
+
+    if nd == self.halfpi:
+      return self.add_perp([a, b, b, x], deps)
+
+    ab, why1 = self.get_line_thru_pair_why(a, b)
+    bx, why2 = self.get_line_thru_pair_why(b, x)
+
+    self.connect_val(ab, deps=None)
+    self.connect_val(bx, deps=None)
+    add = []
+
+    if ab.val == bx.val:
+      return add
+
+    deps.why += why1 + why2
+
+    for p, q, pq in [(a, b, ab), (b, x, bx)]:
+      p_, q_ = pq.val._obj.points
+      if {p, q} == {p_, q_}:
+        continue
+      dep = Dependency('para', [p, q, p_, q_], None, deps.level)
+      deps.why += [dep.why_me_or_cache(self, None)]
+
+    xba, abx, why = self._get_or_create_angle(bx, ab, deps=None)
+    if why:
+      dep0 = deps.populate('aconst', [b, x, a, b, nd])
+      deps = EmptyDependency(level=deps.level, rule_name=None)
+      deps.why = [dep0] + why
+
+    dab, dbx = abx._d
+    a, b = dab._obj.points
+    c, x = dbx._obj.points
+
+    if not self.is_equal(xba, nd):
+      deps1 = deps.populate('aconst', [c, x, a, b, nd])
+      deps1.algebra = dbx, dab, y % 180
+
+      self.make_equal(xba, nd, deps=deps1)
+      self.cache_dep('aconst', [c, x, a, b, nd], deps1)
+      add += [deps1]
+
+    if not self.is_equal(abx, dn):
+      deps2 = deps.populate('aconst', [a, b, c, x, dn])
+      deps2.algebra = dab, dbx, 180 - (y % 180)
+
+      self.make_equal(abx, dn, deps=deps2)
+      self.cache_dep('s_angle', [a, b, c, x, dn], deps2)
+      add += [deps2]
+    return add
+
+  def check_aconst(self, points: list[Point], verbose: bool = False) -> bool:
+    """Check if the angle is equal to a certain constant."""
+    a, b, c, d, nd = points
+    _ = verbose
+    if isinstance(nd, str):
+      name = nd
+    else:
+      name = nd.name
+    num, den = name.split('pi/')
+    ang, _ = self.get_or_create_const_ang(int(num), int(den))
+
+    ab = self._get_line(a, b)
+    cd = self._get_line(c, d)
+    if not ab or not cd:
+      return False
+
+    if not (ab.val and cd.val):
+      return False
+
+    for ang1, _, _ in gm.all_angles(ab._val, cd._val):
+      if self.is_equal(ang1, ang):
+        return True
+    return False
+
+  def check_acompute(self, points: list[Point]) -> bool:
+    """Check if an angle has a constant value."""
+    a, b, c, d = points
+    ab = self._get_line(a, b)
+    cd = self._get_line(c, d)
+    if not ab or not cd:
+      return False
+
+    if not (ab.val and cd.val):
+      return False
+
+    for ang0 in self.aconst.values():
+      for ang in ang0.val.neighbors(Angle):
+        d1, d2 = ang.directions
+        if ab.val == d1 and cd.val == d2:
+          return True
+    return False
+
+  def check_eqangle(self, points: list[Point]) -> bool:
+    """Check if two angles are equal."""
+    a, b, c, d, m, n, p, q = points
+
+    if {a, b} == {c, d} and {m, n} == {p, q}:
+      return True
+    if {a, b} == {m, n} and {c, d} == {p, q}:
+      return True
+
+    if (a == b) or (c == d) or (m == n) or (p == q):
+      return False
+    ab = self._get_line(a, b)
+    cd = self._get_line(c, d)
+    mn = self._get_line(m, n)
+    pq = self._get_line(p, q)
+
+    if {a, b} == {c, d} and mn and pq and self.is_equal(mn, pq):
+      return True
+    if {a, b} == {m, n} and cd and pq and self.is_equal(cd, pq):
+      return True
+    if {p, q} == {m, n} and ab and cd and self.is_equal(ab, cd):
+      return True
+    if {p, q} == {c, d} and ab and mn and self.is_equal(ab, mn):
+      return True
+
+    if not ab or not cd or not mn or not pq:
+      return False
+
+    if self.is_equal(ab, cd) and self.is_equal(mn, pq):
+      return True
+    if self.is_equal(ab, mn) and self.is_equal(cd, pq):
+      return True
+
+    if not (ab.val and cd.val and mn.val and pq.val):
+      return False
+
+    if (ab.val, cd.val) == (mn.val, pq.val) or (ab.val, mn.val) == (
+        cd.val,
+        pq.val,
+    ):
+      return True
+
+    for ang1, _, _ in gm.all_angles(ab._val, cd._val):
+      for ang2, _, _ in gm.all_angles(mn._val, pq._val):
+        if self.is_equal(ang1, ang2):
+          return True
+
+    if self.check_perp([a, b, m, n]) and self.check_perp([c, d, p, q]):
+      return True
+    if self.check_perp([a, b, p, q]) and self.check_perp([c, d, m, n]):
+      return True
+
+    return False
+
+  def _get_ratio(self, l1: Length, l2: Length) -> tuple[Ratio, Ratio]:
+    for r in self.type2nodes[Ratio]:
+      if r.lengths == (l1, l2):
+        return r, r.opposite
+    return None, None
+
+  def _get_or_create_ratio(
+      self, s1: Segment, s2: Segment, deps: Dependency
+  ) -> tuple[Ratio, Ratio, list[Dependency]]:
+    return self._get_or_create_ratio_l(s1._val, s2._val, deps)
+
+  def _get_or_create_ratio_l(
+      self, l1: Length, l2: Length, deps: Dependency
+  ) -> tuple[Ratio, Ratio, list[Dependency]]:
+    """Get or create a new Ratio from two Lenghts l1 and l2."""
+    for r in self.type2nodes[Ratio]:
+      if r.lengths == (l1.rep(), l2.rep()):
+        l1_, l2_ = r._l
+        why1 = l1.why_equal([l1_], None) + l1_.why_rep()
+        why2 = l2.why_equal([l2_], None) + l2_.why_rep()
+        return r, r.opposite, why1 + why2
+
+    l1, why1 = l1.rep_and_why()
+    l2, why2 = l2.rep_and_why()
+    r12 = self.new_node(Ratio, f'{l1.name}/{l2.name}')
+    r21 = self.new_node(Ratio, f'{l2.name}/{l1.name}')
+    self.connect(l1, r12, deps)
+    self.connect(l2, r21, deps)
+    self.connect(r12, r21, deps)
+    r12.set_lengths(l1, l2)
+    r21.set_lengths(l2, l1)
+    r12.opposite = r21
+    r21.opposite = r12
+    return r12, r21, why1 + why2
+
+  def add_cong2(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    m, n, a, b = points
+    add = []
+    add += self.add_cong([m, a, n, a], deps)
+    add += self.add_cong([m, b, n, b], deps)
+    return add
+
+  def add_eqratio3(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    """Add three eqratios through a list of 6 points (due to parallel lines)."""
+    a, b, c, d, m, n = points
+    #   a -- b
+    #  m  --  n
+    # c   --   d
+    add = []
+    add += self.add_eqratio([m, a, m, c, n, b, n, d], deps)
+    add += self.add_eqratio([a, m, a, c, b, n, b, d], deps)
+    add += self.add_eqratio([c, m, c, a, d, n, d, b], deps)
+    if m == n:
+      add += self.add_eqratio([m, a, m, c, a, b, c, d], deps)
+    return add
+
+  def add_eqratio4(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    o, a, b, c, d = points
+    #   o
+    #  a b
+    # c   d
+    add = self.add_eqratio3([a, b, c, d, o, o], deps)
+    add += self.add_eqratio([o, a, o, c, a, b, c, d], deps)
+    return add
+
+  def _add_eqratio(
+      self,
+      a: Point,
+      b: Point,
+      c: Point,
+      d: Point,
+      m: Point,
+      n: Point,
+      p: Point,
+      q: Point,
+      ab: Segment,
+      cd: Segment,
+      mn: Segment,
+      pq: Segment,
+      deps: EmptyDependency,
+  ) -> list[Dependency]:
+    """Add a new eqratio from 8 points (core)."""
+    if deps:
+      deps = deps.copy()
+
+    args = [a, b, c, d, m, n, p, q]
+    i = 0
+    for x, y, xy in [(a, b, ab), (c, d, cd), (m, n, mn), (p, q, pq)]:
+      if {x, y} == set(xy.points):
+        continue
+      x_, y_ = list(xy.points)
+      if deps:
+        deps = deps.extend(self, 'eqratio', list(args), 'cong', [x, y, x_, y_])
+      args[2 * i - 2] = x_
+      args[2 * i - 1] = y_
+
+    add = []
+    ab_cd, cd_ab, why1 = self._get_or_create_ratio(ab, cd, deps=None)
+    mn_pq, pq_mn, why2 = self._get_or_create_ratio(mn, pq, deps=None)
+
+    why = why1 + why2
+    if why:
+      dep0 = deps.populate('eqratio', args)
+      deps = EmptyDependency(level=deps.level, rule_name=None)
+      deps.why = [dep0] + why
+
+    lab, lcd = ab_cd._l
+    lmn, lpq = mn_pq._l
+
+    a, b = lab._obj.points
+    c, d = lcd._obj.points
+    m, n = lmn._obj.points
+    p, q = lpq._obj.points
+
+    is_eq1 = self.is_equal(ab_cd, mn_pq)
+    deps1 = None
+    if deps:
+      deps1 = deps.populate('eqratio', [a, b, c, d, m, n, p, q])
+      deps1.algebra = [ab._val, cd._val, mn._val, pq._val]
+    if not is_eq1:
+      add += [deps1]
+    self.cache_dep('eqratio', [a, b, c, d, m, n, p, q], deps1)
+    self.make_equal(ab_cd, mn_pq, deps=deps1)
+
+    is_eq2 = self.is_equal(cd_ab, pq_mn)
+    deps2 = None
+    if deps:
+      deps2 = deps.populate('eqratio', [c, d, a, b, p, q, m, n])
+      deps2.algebra = [cd._val, ab._val, pq._val, mn._val]
+    if not is_eq2:
+      add += [deps2]
+    self.cache_dep('eqratio', [c, d, a, b, p, q, m, n], deps2)
+    self.make_equal(cd_ab, pq_mn, deps=deps2)
+    return add
+
+  def add_eqratio(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    """Add a new eqratio from 8 points."""
+    if deps:
+      deps = deps.copy()
+    a, b, c, d, m, n, p, q = points
+    ab = self._get_or_create_segment(a, b, deps=None)
+    cd = self._get_or_create_segment(c, d, deps=None)
+    mn = self._get_or_create_segment(m, n, deps=None)
+    pq = self._get_or_create_segment(p, q, deps=None)
+
+    add = self.maybe_make_equal_pairs(
+        a, b, c, d, m, n, p, q, ab, cd, mn, pq, deps
+    )
+
+    if add is not None:
+      return add
+
+    self.connect_val(ab, deps=None)
+    self.connect_val(cd, deps=None)
+    self.connect_val(mn, deps=None)
+    self.connect_val(pq, deps=None)
+
+    add = []
+    if (
+        ab.val != cd.val
+        and mn.val != pq.val
+        and (ab.val != mn.val or cd.val != pq.val)
+    ):
+      add += self._add_eqratio(a, b, c, d, m, n, p, q, ab, cd, mn, pq, deps)
+
+    if (
+        ab.val != mn.val
+        and cd.val != pq.val
+        and (ab.val != cd.val or mn.val != pq.val)
+    ):
+      add += self._add_eqratio(  # pylint: disable=arguments-out-of-order
+          a,
+          b,
+          m,
+          n,
+          c,
+          d,
+          p,
+          q,
+          ab,
+          mn,
+          cd,
+          pq,
+          deps,
+      )
+    return add
+
+  def check_rconst(self, points: list[Point], verbose: bool = False) -> bool:
+    """Check whether a ratio is equal to some given constant."""
+    _ = verbose
+    a, b, c, d, nd = points
+    if isinstance(nd, str):
+      name = nd
+    else:
+      name = nd.name
+    num, den = name.split('/')
+    rat, _ = self.get_or_create_const_rat(int(num), int(den))
+
+    ab = self._get_segment(a, b)
+    cd = self._get_segment(c, d)
+
+    if not ab or not cd:
+      return False
+
+    if not (ab.val and cd.val):
+      return False
+
+    for rat1, _, _ in gm.all_ratios(ab._val, cd._val):
+      if self.is_equal(rat1, rat):
+        return True
+    return False
+
+  def check_rcompute(self, points: list[Point]) -> bool:
+    """Check whether a ratio is equal to some constant."""
+    a, b, c, d = points
+    ab = self._get_segment(a, b)
+    cd = self._get_segment(c, d)
+
+    if not ab or not cd:
+      return False
+
+    if not (ab.val and cd.val):
+      return False
+
+    for rat0 in self.rconst.values():
+      for rat in rat0.val.neighbors(Ratio):
+        l1, l2 = rat.lengths
+        if ab.val == l1 and cd.val == l2:
+          return True
+    return False
+
+  def check_eqratio(self, points: list[Point]) -> bool:
+    """Check if 8 points make an eqratio predicate."""
+    a, b, c, d, m, n, p, q = points
+
+    if {a, b} == {c, d} and {m, n} == {p, q}:
+      return True
+    if {a, b} == {m, n} and {c, d} == {p, q}:
+      return True
+
+    ab = self._get_segment(a, b)
+    cd = self._get_segment(c, d)
+    mn = self._get_segment(m, n)
+    pq = self._get_segment(p, q)
+
+    if {a, b} == {c, d} and mn and pq and self.is_equal(mn, pq):
+      return True
+    if {a, b} == {m, n} and cd and pq and self.is_equal(cd, pq):
+      return True
+    if {p, q} == {m, n} and ab and cd and self.is_equal(ab, cd):
+      return True
+    if {p, q} == {c, d} and ab and mn and self.is_equal(ab, mn):
+      return True
+
+    if not ab or not cd or not mn or not pq:
+      return False
+
+    if self.is_equal(ab, cd) and self.is_equal(mn, pq):
+      return True
+    if self.is_equal(ab, mn) and self.is_equal(cd, pq):
+      return True
+
+    if not (ab.val and cd.val and mn.val and pq.val):
+      return False
+
+    if (ab.val, cd.val) == (mn.val, pq.val) or (ab.val, mn.val) == (
+        cd.val,
+        pq.val,
+    ):
+      return True
+
+    for rat1, _, _ in gm.all_ratios(ab._val, cd._val):
+      for rat2, _, _ in gm.all_ratios(mn._val, pq._val):
+        if self.is_equal(rat1, rat2):
+          return True
+    return False
+
+  def add_simtri_check(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    if nm.same_clock(*[p.num for p in points]):
+      return self.add_simtri(points, deps)
+    return self.add_simtri2(points, deps)
+
+  def add_contri_check(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    if nm.same_clock(*[p.num for p in points]):
+      return self.add_contri(points, deps)
+    return self.add_contri2(points, deps)
+
+  def enum_sides(
+      self, points: list[Point]
+  ) -> Generator[list[Point], None, None]:
+    a, b, c, x, y, z = points
+    yield [a, b, x, y]
+    yield [b, c, y, z]
+    yield [c, a, z, x]
+
+  def enum_triangle(
+      self, points: list[Point]
+  ) -> Generator[list[Point], None, None]:
+    a, b, c, x, y, z = points
+    yield [a, b, a, c, x, y, x, z]
+    yield [b, a, b, c, y, x, y, z]
+    yield [c, a, c, b, z, x, z, y]
+
+  def enum_triangle2(
+      self, points: list[Point]
+  ) -> Generator[list[Point], None, None]:
+    a, b, c, x, y, z = points
+    yield [a, b, a, c, x, z, x, y]
+    yield [b, a, b, c, y, z, y, x]
+    yield [c, a, c, b, z, y, z, x]
+
+  def add_simtri(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    """Add two similar triangles."""
+    add = []
+    hashs = [d.hashed() for d in deps.why]
+
+    for args in self.enum_triangle(points):
+      if problem.hashed('eqangle6', args) in hashs:
+        continue
+      add += self.add_eqangle(args, deps=deps)
+
+    for args in self.enum_triangle(points):
+      if problem.hashed('eqratio6', args) in hashs:
+        continue
+      add += self.add_eqratio(args, deps=deps)
+
+    return add
+
+  def check_simtri(self, points: list[Point]) -> bool:
+    a, b, c, x, y, z = points
+    return self.check_eqangle([a, b, a, c, x, y, x, z]) and self.check_eqangle(
+        [b, a, b, c, y, x, y, z]
+    )
+
+  def add_simtri2(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    """Add two similar reflected triangles."""
+    add = []
+    hashs = [d.hashed() for d in deps.why]
+    for args in self.enum_triangle2(points):
+      if problem.hashed('eqangle6', args) in hashs:
+        continue
+      add += self.add_eqangle(args, deps=deps)
+
+    for args in self.enum_triangle(points):
+      if problem.hashed('eqratio6', args) in hashs:
+        continue
+      add += self.add_eqratio(args, deps=deps)
+
+    return add
+
+  def add_contri(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    """Add two congruent triangles."""
+    add = []
+    hashs = [d.hashed() for d in deps.why]
+    for args in self.enum_triangle(points):
+      if problem.hashed('eqangle6', args) in hashs:
+        continue
+      add += self.add_eqangle(args, deps=deps)
+
+    for args in self.enum_sides(points):
+      if problem.hashed('cong', args) in hashs:
+        continue
+      add += self.add_cong(args, deps=deps)
+    return add
+
+  def check_contri(self, points: list[Point]) -> bool:
+    a, b, c, x, y, z = points
+    return (
+        self.check_cong([a, b, x, y])
+        and self.check_cong([b, c, y, z])
+        and self.check_cong([c, a, z, x])
+    )
+
+  def add_contri2(
+      self, points: list[Point], deps: EmptyDependency
+  ) -> list[Dependency]:
+    """Add two congruent reflected triangles."""
+    add = []
+    hashs = [d.hashed() for d in deps.why]
+    for args in self.enum_triangle2(points):
+      if problem.hashed('eqangle6', args) in hashs:
+        continue
+      add += self.add_eqangle(args, deps=deps)
+
+    for args in self.enum_sides(points):
+      if problem.hashed('cong', args) in hashs:
+        continue
+      add += self.add_cong(args, deps=deps)
+
+    return add
+
+  def in_cache(self, name: str, args: list[Point]) -> bool:
+    return problem.hashed(name, args) in self.cache
+
+  def cache_dep(
+      self, name: str, args: list[Point], premises: list[Dependency]
+  ) -> None:
+    hashed = problem.hashed(name, args)
+    if hashed in self.cache:
+      return
+    self.cache[hashed] = premises
+
+  def all_same_line(
+      self, a: Point, b: Point
+  ) -> Generator[tuple[Point, Point], None, None]:
+    ab = self._get_line(a, b)
+    if ab is None:
+      return
+    for p1, p2 in utils.comb2(ab.neighbors(Point)):
+      if {p1, p2} != {a, b}:
+        yield p1, p2
+
+  def all_same_angle(
+      self, a: Point, b: Point, c: Point, d: Point
+  ) -> Generator[tuple[Point, Point, Point, Point], None, None]:
+    for x, y in self.all_same_line(a, b):
+      for m, n in self.all_same_line(c, d):
+        yield x, y, m, n
+
+  def additionally_draw(self, name: str, args: list[Point]) -> None:
+    """Draw some extra line/circles for illustration purpose."""
+
+    if name in ['circle']:
+      center, point = args[:2]
+      circle = self.new_node(Circle, f'({center.name},{point.name})')
+      circle.num = nm.Circle(center.num, p1=point.num)
+      circle.points = center, point
+
+    if name in ['on_circle', 'tangent']:
+      center, point = args[-2:]
+      circle = self.new_node(Circle, f'({center.name},{point.name})')
+      circle.num = nm.Circle(center.num, p1=point.num)
+      circle.points = center, point
+
+    if name in ['incenter', 'excenter', 'incenter2', 'excenter2']:
+      d, a, b, c = [x for x in args[-4:]]
+      a, b, c = sorted([a, b, c], key=lambda x: x.name.lower())
+      circle = self.new_node(Circle, f'({d.name},h.{a.name}{b.name})')
+      p = d.num.foot(nm.Line(a.num, b.num))
+      circle.num = nm.Circle(d.num, p1=p)
+      circle.points = d, a, b, c
+
+    if name in ['cc_tangent']:
+      o, a, w, b = args[-4:]
+      c1 = self.new_node(Circle, f'({o.name},{a.name})')
+      c1.num = nm.Circle(o.num, p1=a.num)
+      c1.points = o, a
+
+      c2 = self.new_node(Circle, f'({w.name},{b.name})')
+      c2.num = nm.Circle(w.num, p1=b.num)
+      c2.points = w, b
+
+    if name in ['ninepoints']:
+      a, b, c = args[-3:]
+      a, b, c = sorted([a, b, c], key=lambda x: x.name.lower())
+      circle = self.new_node(Circle, f'(,m.{a.name}{b.name}{c.name})')
+      p1 = (b.num + c.num) * 0.5
+      p2 = (c.num + a.num) * 0.5
+      p3 = (a.num + b.num) * 0.5
+      circle.num = nm.Circle(p1=p1, p2=p2, p3=p3)
+      circle.points = (None, None, a, b, c)
+
+    if name in ['2l1c']:
+      a, b, c, o = args[:4]
+      a, b, c = sorted([a, b, c], key=lambda x: x.name.lower())
+      circle = self.new_node(Circle, f'({o.name},{a.name}{b.name}{c.name})')
+      circle.num = nm.Circle(p1=a.num, p2=b.num, p3=c.num)
+      circle.points = (a, b, c)
+
+  def add_clause(
+      self,
+      clause: problem.Clause,
+      plevel: int,
+      definitions: dict[str, problem.Definition],
+      verbose: int = False,
+  ) -> tuple[list[Dependency], int]:
+    """Add a new clause of construction, e.g. a new excenter."""
+    existing_points = self.all_points()
+    new_points = [Point(name) for name in clause.points]
+
+    new_points_dep_points = set()
+    new_points_dep = []
+
+    # Step 1: check for all deps.
+    for c in clause.constructions:
+      cdef = definitions[c.name]
+
+      if len(cdef.construction.args) != len(c.args):
+        if len(cdef.construction.args) - len(c.args) == len(clause.points):
+          c.args = clause.points + c.args
+        else:
+          correct_form = ' '.join(cdef.points + ['=', c.name] + cdef.args)
+          raise ValueError('Argument mismatch. ' + correct_form)
+
+      mapping = dict(zip(cdef.construction.args, c.args))
+      c_name = 'midp' if c.name == 'midpoint' else c.name
+      deps = EmptyDependency(level=0, rule_name=problem.CONSTRUCTION_RULE)
+      deps.construction = Dependency(c_name, c.args, rule_name=None, level=0)
+
+      for d in cdef.deps.constructions:
+        args = self.names2points([mapping[a] for a in d.args])
+        new_points_dep_points.update(args)
+        if not self.check(d.name, args):
+          raise DepCheckFailError(
+              d.name + ' ' + ' '.join([x.name for x in args])
+          )
+        deps.why += [
+            Dependency(
+                d.name, args, rule_name=problem.CONSTRUCTION_RULE, level=0
+            )
+        ]
+
+      new_points_dep += [deps]
+
+    # Step 2: draw.
+    def range_fn() -> (
+        list[Union[nm.Point, nm.Line, nm.Circle, nm.HalfLine, nm.HoleCircle]]
+    ):
+      to_be_intersected = []
+      for c in clause.constructions:
+        cdef = definitions[c.name]
+        mapping = dict(zip(cdef.construction.args, c.args))
+        for n in cdef.numerics:
+          args = [mapping[a] for a in n.args]
+          args = list(map(lambda x: self.get(x, lambda: int(x)), args))
+          to_be_intersected += nm.sketch(n.name, args)
+
+      return to_be_intersected
+
+    is_total_free = (
+        len(clause.constructions) == 1 and clause.constructions[0].name in FREE
+    )
+    is_semi_free = (
+        len(clause.constructions) == 1
+        and clause.constructions[0].name in INTERSECT
+    )
+
+    existing_points = [p.num for p in existing_points]
+
+    def draw_fn() -> list[nm.Point]:
+      to_be_intersected = range_fn()
+      return nm.reduce(to_be_intersected, existing_points)
+
+    rely_on = set()
+    for c in clause.constructions:
+      cdef = definitions[c.name]
+      mapping = dict(zip(cdef.construction.args, c.args))
+      for n in cdef.numerics:
+        args = [mapping[a] for a in n.args]
+        args = list(map(lambda x: self.get(x, lambda: int(x)), args))
+        rely_on.update([a for a in args if isinstance(a, Point)])
+
+    for p in rely_on:
+      p.change.update(new_points)
+
+    nums = draw_fn()
+    for p, num, num0 in zip(new_points, nums, clause.nums):
+      p.co_change = new_points
+      if isinstance(num0, nm.Point):
+        num = num0
+      elif isinstance(num0, (tuple, list)):
+        x, y = num0
+        num = nm.Point(x, y)
+
+      p.num = num
+
+    # check two things.
+    if nm.check_too_close(nums, existing_points):
+      raise PointTooCloseError()
+    if nm.check_too_far(nums, existing_points):
+      raise PointTooFarError()
+
+    # Commit: now that all conditions are passed.
+    # add these points to current graph.
+    for p in new_points:
+      self._name2point[p.name] = p
+      self._name2node[p.name] = p
+      self.type2nodes[Point].append(p)
+
+    for p in new_points:
+      p.why = sum([d.why for d in new_points_dep], [])  # to generate txt logs.
+      p.group = new_points
+      p.dep_points = new_points_dep_points
+      p.dep_points.update(new_points)
+      p.plevel = plevel
+
+    # movement dependency:
+    rely_dict_0 = defaultdict(lambda: [])
+
+    for c in clause.constructions:
+      cdef = definitions[c.name]
+      mapping = dict(zip(cdef.construction.args, c.args))
+      for p, ps in cdef.rely.items():
+        p = mapping[p]
+        ps = [mapping[x] for x in ps]
+        rely_dict_0[p].append(ps)
+
+    rely_dict = {}
+    for p, pss in rely_dict_0.items():
+      ps = sum(pss, [])
+      if len(pss) > 1:
+        ps = [x for x in ps if x != p]
+
+      p = self._name2point[p]
+      ps = self.names2nodes(ps)
+      rely_dict[p] = ps
+
+    for p in new_points:
+      p.rely_on = set(rely_dict.get(p, []))
+      for x in p.rely_on:
+        if not hasattr(x, 'base_rely_on'):
+          x.base_rely_on = set()
+      p.base_rely_on = set.union(*[x.base_rely_on for x in p.rely_on] + [set()])
+      if is_total_free or is_semi_free:
+        p.rely_on.add(p)
+        p.base_rely_on.add(p)
+
+    plevel_done = set()
+    added = []
+    basics = []
+    # Step 3: build the basics.
+    for c, deps in zip(clause.constructions, new_points_dep):
+      cdef = definitions[c.name]
+      mapping = dict(zip(cdef.construction.args, c.args))
+
+      # not necessary for proofing, but for visualization.
+      c_args = list(map(lambda x: self.get(x, lambda: int(x)), c.args))
+      self.additionally_draw(c.name, c_args)
+
+      for points, bs in cdef.basics:
+        if points:
+          points = self.names2nodes([mapping[p] for p in points])
+          points = [p for p in points if p not in plevel_done]
+          for p in points:
+            p.plevel = plevel
+          plevel_done.update(points)
+          plevel += 1
+        else:
+          continue
+
+        for b in bs:
+          if b.name != 'rconst':
+            args = [mapping[a] for a in b.args]
+          else:
+            num, den = map(int, b.args[-2:])
+            rat, _ = self.get_or_create_const_rat(num, den)
+            args = [mapping[a] for a in b.args[:-2]] + [rat.name]
+
+          args = list(map(lambda x: self.get(x, lambda: int(x)), args))
+
+          adds = self.add_piece(name=b.name, args=args, deps=deps)
+          basics.append((b.name, args, deps))
+          if adds:
+            added += adds
+            for add in adds:
+              self.cache_dep(add.name, add.args, add)
+
+    assert len(plevel_done) == len(new_points)
+    for p in new_points:
+      p.basics = basics
+
+    return added, plevel
+
+  def all_eqangle_same_lines(self) -> Generator[tuple[Point, ...], None, None]:
+    for l1, l2 in utils.perm2(self.type2nodes[Line]):
+      for a, b, c, d, e, f, g, h in utils.all_8points(l1, l2, l1, l2):
+        if (a, b, c, d) != (e, f, g, h):
+          yield a, b, c, d, e, f, g, h
+
+  def all_eqangles_distinct_linepairss(
+      self,
+  ) -> Generator[tuple[Line, ...], None, None]:
+    """No eqangles betcause para-para, or para-corresponding, or same."""
+
+    for measure in self.type2nodes[Measure]:
+      angs = measure.neighbors(Angle)
+      line_pairss = []
+      for ang in angs:
+        d1, d2 = ang.directions
+        if d1 is None or d2 is None:
+          continue
+        l1s = d1.neighbors(Line)
+        l2s = d2.neighbors(Line)
+        # Any pair in this is para-para.
+        para_para = list(utils.cross(l1s, l2s))
+        line_pairss.append(para_para)
+
+      for pairs1, pairs2 in utils.comb2(line_pairss):
+        for pair1, pair2 in utils.cross(pairs1, pairs2):
+          (l1, l2), (l3, l4) = pair1, pair2
+          yield l1, l2, l3, l4
+
+  def all_eqangles_8points(self) -> Generator[tuple[Point, ...], None, None]:
+    """List all sets of 8 points that make two equal angles."""
+    # Case 1: (l1-l2) = (l3-l4), including because l1//l3, l2//l4 (para-para)
+    angss = []
+    for measure in self.type2nodes[Measure]:
+      angs = measure.neighbors(Angle)
+      angss.append(angs)
+
+    # include the angs that do not have any measure.
+    angss.extend([[ang] for ang in self.type2nodes[Angle] if ang.val is None])
+
+    line_pairss = []
+    for angs in angss:
+      line_pairs = set()
+      for ang in angs:
+        d1, d2 = ang.directions
+        if d1 is None or d2 is None:
+          continue
+        l1s = d1.neighbors(Line)
+        l2s = d2.neighbors(Line)
+        line_pairs.update(set(utils.cross(l1s, l2s)))
+      line_pairss.append(line_pairs)
+
+    # include (d1, d2) in which d1 does not have any angles.
+    noang_ds = [d for d in self.type2nodes[Direction] if not d.neighbors(Angle)]
+
+    for d1 in noang_ds:
+      for d2 in self.type2nodes[Direction]:
+        if d1 == d2:
+          continue
+        l1s = d1.neighbors(Line)
+        l2s = d2.neighbors(Line)
+        if len(l1s) < 2 and len(l2s) < 2:
+          continue
+        line_pairss.append(set(utils.cross(l1s, l2s)))
+        line_pairss.append(set(utils.cross(l2s, l1s)))
+
+    # Case 2: d1 // d2 => (d1-d3) = (d2-d3)
+    # include lines that does not have any direction.
+    nodir_ls = [l for l in self.type2nodes[Line] if l.val is None]
+
+    for line in nodir_ls:
+      for d in self.type2nodes[Direction]:
+        l1s = d.neighbors(Line)
+        if len(l1s) < 2:
+          continue
+        l2s = [line]
+        line_pairss.append(set(utils.cross(l1s, l2s)))
+        line_pairss.append(set(utils.cross(l2s, l1s)))
+
+    record = set()
+    for line_pairs in line_pairss:
+      for pair1, pair2 in utils.perm2(list(line_pairs)):
+        (l1, l2), (l3, l4) = pair1, pair2
+        if l1 == l2 or l3 == l4:
+          continue
+        if (l1, l2) == (l3, l4):
+          continue
+        if (l1, l2, l3, l4) in record:
+          continue
+        record.add((l1, l2, l3, l4))
+        for a, b, c, d, e, f, g, h in utils.all_8points(l1, l2, l3, l4):
+          yield (a, b, c, d, e, f, g, h)
+
+    for a, b, c, d, e, f, g, h in self.all_eqangle_same_lines():
+      yield a, b, c, d, e, f, g, h
+
+  def all_eqangles_6points(self) -> Generator[tuple[Point, ...], None, None]:
+    """List all sets of 6 points that make two equal angles."""
+    record = set()
+    for a, b, c, d, e, f, g, h in self.all_eqangles_8points():
+      if (
+          a not in (c, d)
+          and b not in (c, d)
+          or e not in (g, h)
+          and f not in (g, h)
+      ):
+        continue
+
+      if b in (c, d):
+        a, b = b, a  # now a in c, d
+      if f in (g, h):
+        e, f = f, e  # now e in g, h
+      if a == d:
+        c, d = d, c  # now a == c
+      if e == h:
+        g, h = h, g  # now e == g
+      if (a, b, c, d, e, f, g, h) in record:
+        continue
+      record.add((a, b, c, d, e, f, g, h))
+      yield a, b, c, d, e, f, g, h  # where a==c, e==g
+
+  def all_paras(self) -> Generator[tuple[Point, ...], None, None]:
+    for d in self.type2nodes[Direction]:
+      for l1, l2 in utils.perm2(d.neighbors(Line)):
+        for a, b, c, d in utils.all_4points(l1, l2):
+          yield a, b, c, d
+
+  def all_perps(self) -> Generator[tuple[Point, ...], None, None]:
+    for ang in self.vhalfpi.neighbors(Angle):
+      d1, d2 = ang.directions
+      if d1 is None or d2 is None:
+        continue
+      if d1 == d2:
+        continue
+      for l1, l2 in utils.cross(d1.neighbors(Line), d2.neighbors(Line)):
+        for a, b, c, d in utils.all_4points(l1, l2):
+          yield a, b, c, d
+
+  def all_congs(self) -> Generator[tuple[Point, ...], None, None]:
+    for l in self.type2nodes[Length]:
+      for s1, s2 in utils.perm2(l.neighbors(Segment)):
+        (a, b), (c, d) = s1.points, s2.points
+        for x, y in [(a, b), (b, a)]:
+          for m, n in [(c, d), (d, c)]:
+            yield x, y, m, n
+
+  def all_eqratios_8points(self) -> Generator[tuple[Point, ...], None, None]:
+    """List all sets of 8 points that make two equal ratios."""
+    ratss = []
+    for value in self.type2nodes[Value]:
+      rats = value.neighbors(Ratio)
+      ratss.append(rats)
+
+    # include the rats that do not have any val.
+    ratss.extend([[rat] for rat in self.type2nodes[Ratio] if rat.val is None])
+
+    seg_pairss = []
+    for rats in ratss:
+      seg_pairs = set()
+      for rat in rats:
+        l1, l2 = rat.lengths
+        if l1 is None or l2 is None:
+          continue
+        s1s = l1.neighbors(Segment)
+        s2s = l2.neighbors(Segment)
+        seg_pairs.update(utils.cross(s1s, s2s))
+      seg_pairss.append(seg_pairs)
+
+    # include (l1, l2) in which l1 does not have any ratio.
+    norat_ls = [l for l in self.type2nodes[Length] if not l.neighbors(Ratio)]
+
+    for l1 in norat_ls:
+      for l2 in self.type2nodes[Length]:
+        if l1 == l2:
+          continue
+        s1s = l1.neighbors(Segment)
+        s2s = l2.neighbors(Segment)
+        if len(s1s) < 2 and len(s2s) < 2:
+          continue
+        seg_pairss.append(set(utils.cross(s1s, s2s)))
+        seg_pairss.append(set(utils.cross(s2s, s1s)))
+
+    # include Seg that does not have any Length.
+    nolen_ss = [s for s in self.type2nodes[Segment] if s.val is None]
+
+    for seg in nolen_ss:
+      for l in self.type2nodes[Length]:
+        s1s = l.neighbors(Segment)
+        if len(s1s) == 1:
+          continue
+        s2s = [seg]
+        seg_pairss.append(set(utils.cross(s1s, s2s)))
+        seg_pairss.append(set(utils.cross(s2s, s1s)))
+
+    record = set()
+    for seg_pairs in seg_pairss:
+      for pair1, pair2 in utils.perm2(list(seg_pairs)):
+        (s1, s2), (s3, s4) = pair1, pair2
+        if s1 == s2 or s3 == s4:
+          continue
+        if (s1, s2) == (s3, s4):
+          continue
+        if (s1, s2, s3, s4) in record:
+          continue
+        record.add((s1, s2, s3, s4))
+        a, b = s1.points
+        c, d = s2.points
+        e, f = s3.points
+        g, h = s4.points
+
+        for x, y in [(a, b), (b, a)]:
+          for z, t in [(c, d), (d, c)]:
+            for m, n in [(e, f), (f, e)]:
+              for p, q in [(g, h), (h, g)]:
+                yield (x, y, z, t, m, n, p, q)
+
+    segss = []
+    # finally the list of ratios that is equal to 1.0
+    for length in self.type2nodes[Length]:
+      segs = length.neighbors(Segment)
+      segss.append(segs)
+
+    segs_pair = list(utils.perm2(list(segss)))
+    segs_pair += list(zip(segss, segss))
+    for segs1, segs2 in segs_pair:
+      for s1, s2 in utils.perm2(list(segs1)):
+        for s3, s4 in utils.perm2(list(segs2)):
+          if (s1, s2) == (s3, s4) or (s1, s3) == (s2, s4):
+            continue
+          if (s1, s2, s3, s4) in record:
+            continue
+          record.add((s1, s2, s3, s4))
+          a, b = s1.points
+          c, d = s2.points
+          e, f = s3.points
+          g, h = s4.points
+
+          for x, y in [(a, b), (b, a)]:
+            for z, t in [(c, d), (d, c)]:
+              for m, n in [(e, f), (f, e)]:
+                for p, q in [(g, h), (h, g)]:
+                  yield (x, y, z, t, m, n, p, q)
+
+  def all_eqratios_6points(self) -> Generator[tuple[Point, ...], None, None]:
+    """List all sets of 6 points that make two equal angles."""
+    record = set()
+    for a, b, c, d, e, f, g, h in self.all_eqratios_8points():
+      if (
+          a not in (c, d)
+          and b not in (c, d)
+          or e not in (g, h)
+          and f not in (g, h)
+      ):
+        continue
+      if b in (c, d):
+        a, b = b, a
+      if f in (g, h):
+        e, f = f, e
+      if a == d:
+        c, d = d, c
+      if e == h:
+        g, h = h, g
+      if (a, b, c, d, e, f, g, h) in record:
+        continue
+      record.add((a, b, c, d, e, f, g, h))
+      yield a, b, c, d, e, f, g, h  # now a==c, e==g
+
+  def all_cyclics(self) -> Generator[tuple[Point, ...], None, None]:
+    for c in self.type2nodes[Circle]:
+      for x, y, z, t in utils.perm4(c.neighbors(Point)):
+        yield x, y, z, t
+
+  def all_colls(self) -> Generator[tuple[Point, ...], None, None]:
+    for l in self.type2nodes[Line]:
+      for x, y, z in utils.perm3(l.neighbors(Point)):
+        yield x, y, z
+
+  def all_midps(self) -> Generator[tuple[Point, ...], None, None]:
+    for l in self.type2nodes[Line]:
+      for a, b, c in utils.perm3(l.neighbors(Point)):
+        if self.check_cong([a, b, a, c]):
+          yield a, b, c
+
+  def all_circles(self) -> Generator[tuple[Point, ...], None, None]:
+    for l in self.type2nodes[Length]:
+      p2p = defaultdict(list)
+      for s in l.neighbors(Segment):
+        a, b = s.points
+        p2p[a].append(b)
+        p2p[b].append(a)
+      for p, ps in p2p.items():
+        if len(ps) >= 3:
+          for a, b, c in utils.perm3(ps):
+            yield p, a, b, c
+
+  def two_points_on_direction(self, d: Direction) -> tuple[Point, Point]:
+    l = d.neighbors(Line)[0]
+    p1, p2 = l.neighbors(Point)[:2]
+    return p1, p2
+
+  def two_points_of_length(self, l: Length) -> tuple[Point, Point]:
+    s = l.neighbors(Segment)[0]
+    p1, p2 = s.points
+    return p1, p2
+
+
+def create_consts_str(g: Graph, s: str) -> Union[Ratio, Angle]:
+  if 'pi/' in s:
+    n, d = s.split('pi/')
+    n, d = int(n), int(d)
+    p0, _ = g.get_or_create_const_ang(n, d)
+  else:
+    n, d = s.split('/')
+    n, d = int(n), int(d)
+    p0, _ = g.get_or_create_const_rat(n, d)
+  return p0
+
+
+def create_consts(g: Graph, p: gm.Node) -> Union[Ratio, Angle]:
+  if isinstance(p, Angle):
+    n, d = p.name.split('pi/')
+    n, d = int(n), int(d)
+    p0, _ = g.get_or_create_const_ang(n, d)
+  if isinstance(p, Ratio):
+    n, d = p.name.split('/')
+    n, d = int(n), int(d)
+    p0, _ = g.get_or_create_const_rat(n, d)
+  return p0  # pylint: disable=undefined-variable

ag4masses/alphageometry/graph_test.py

@@ -0,0 +1,164 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Unit tests for graph.py."""
+import unittest
+
+from absl.testing import absltest
+import graph as gh
+import numericals as nm
+import problem as pr
+
+
+MAX_LEVEL = 1000
+
+
+class GraphTest(unittest.TestCase):
+
+  @classmethod
+  def setUpClass(cls):
+    super().setUpClass()
+
+    cls.defs = pr.Definition.from_txt_file('defs.txt', to_dict=True)
+    cls.rules = pr.Theorem.from_txt_file('rules.txt', to_dict=True)
+
+    # load a complex setup:
+    txt = 'a b c = triangle a b c; h = orthocenter a b c; h1 = foot a b c; h2 = foot b c a; h3 = foot c a b; g1 g2 g3 g = centroid g1 g2 g3 g a b c; o = circle a b c ? coll h g o'  # pylint: disable=line-too-long
+    p = pr.Problem.from_txt(txt, translate=False)
+    cls.g, _ = gh.Graph.build_problem(p, GraphTest.defs)
+
+  def test_build_graph_points(self):
+    g = GraphTest.g
+
+    all_points = g.all_points()
+    all_names = [p.name for p in all_points]
+    self.assertCountEqual(
+        all_names,
+        ['a', 'b', 'c', 'g', 'h', 'o', 'g1', 'g2', 'g3', 'h1', 'h2', 'h3'],
+    )
+
+  def test_build_graph_predicates(self):
+    gr = GraphTest.g
+
+    a, b, c, g, h, o, g1, g2, g3, h1, h2, h3 = gr.names2points(
+        ['a', 'b', 'c', 'g', 'h', 'o', 'g1', 'g2', 'g3', 'h1', 'h2', 'h3']
+    )
+
+    # Explicit statements:
+    self.assertTrue(gr.check_cong([b, g1, g1, c]))
+    self.assertTrue(gr.check_cong([c, g2, g2, a]))
+    self.assertTrue(gr.check_cong([a, g3, g3, b]))
+    self.assertTrue(gr.check_perp([a, h1, b, c]))
+    self.assertTrue(gr.check_perp([b, h2, c, a]))
+    self.assertTrue(gr.check_perp([c, h3, a, b]))
+    self.assertTrue(gr.check_cong([o, a, o, b]))
+    self.assertTrue(gr.check_cong([o, b, o, c]))
+    self.assertTrue(gr.check_cong([o, a, o, c]))
+    self.assertTrue(gr.check_coll([a, g, g1]))
+    self.assertTrue(gr.check_coll([b, g, g2]))
+    self.assertTrue(gr.check_coll([g1, b, c]))
+    self.assertTrue(gr.check_coll([g2, c, a]))
+    self.assertTrue(gr.check_coll([g3, a, b]))
+    self.assertTrue(gr.check_perp([a, h, b, c]))
+    self.assertTrue(gr.check_perp([b, h, c, a]))
+
+    # These are NOT part of the premises:
+    self.assertFalse(gr.check_perp([c, h, a, b]))
+    self.assertFalse(gr.check_coll([c, g, g3]))
+
+    # These are automatically inferred by the graph datastructure:
+    self.assertTrue(gr.check_eqangle([a, h1, b, c, b, h2, c, a]))
+    self.assertTrue(gr.check_eqangle([a, h1, b, h2, b, c, c, a]))
+    self.assertTrue(gr.check_eqratio([b, g1, g1, c, c, g2, g2, a]))
+    self.assertTrue(gr.check_eqratio([b, g1, g1, c, o, a, o, b]))
+    self.assertTrue(gr.check_para([a, h, a, h1]))
+    self.assertTrue(gr.check_para([b, h, b, h2]))
+    self.assertTrue(gr.check_coll([a, h, h1]))
+    self.assertTrue(gr.check_coll([b, h, h2]))
+
+  def test_enumerate_colls(self):
+    g = GraphTest.g
+
+    for a, b, c in g.all_colls():
+      self.assertTrue(g.check_coll([a, b, c]))
+      self.assertTrue(nm.check_coll([a.num, b.num, c.num]))
+
+  def test_enumerate_paras(self):
+    g = GraphTest.g
+
+    for a, b, c, d in g.all_paras():
+      self.assertTrue(g.check_para([a, b, c, d]))
+      self.assertTrue(nm.check_para([a.num, b.num, c.num, d.num]))
+
+  def test_enumerate_perps(self):
+    g = GraphTest.g
+
+    for a, b, c, d in g.all_perps():
+      self.assertTrue(g.check_perp([a, b, c, d]))
+      self.assertTrue(nm.check_perp([a.num, b.num, c.num, d.num]))
+
+  def test_enumerate_congs(self):
+    g = GraphTest.g
+
+    for a, b, c, d in g.all_congs():
+      self.assertTrue(g.check_cong([a, b, c, d]))
+      self.assertTrue(nm.check_cong([a.num, b.num, c.num, d.num]))
+
+  def test_enumerate_eqangles(self):
+    g = GraphTest.g
+
+    for a, b, c, d, x, y, z, t in g.all_eqangles_8points():
+      self.assertTrue(g.check_eqangle([a, b, c, d, x, y, z, t]))
+      self.assertTrue(
+          nm.check_eqangle(
+              [a.num, b.num, c.num, d.num, x.num, y.num, z.num, t.num]
+          )
+      )
+
+  def test_enumerate_eqratios(self):
+    g = GraphTest.g
+
+    for a, b, c, d, x, y, z, t in g.all_eqratios_8points():
+      self.assertTrue(g.check_eqratio([a, b, c, d, x, y, z, t]))
+      self.assertTrue(
+          nm.check_eqratio(
+              [a.num, b.num, c.num, d.num, x.num, y.num, z.num, t.num]
+          )
+      )
+
+  def test_enumerate_cyclics(self):
+    g = GraphTest.g
+
+    for a, b, c, d, x, y, z, t in g.all_cyclics():
+      self.assertTrue(g.check_cyclic([a, b, c, d, x, y, z, t]))
+      self.assertTrue(nm.check_cyclic([a.num, b.num, c.num, d.num]))
+
+  def test_enumerate_midps(self):
+    g = GraphTest.g
+
+    for a, b, c in g.all_midps():
+      self.assertTrue(g.check_midp([a, b, c]))
+      self.assertTrue(nm.check_midp([a.num, b.num, c.num]))
+
+  def test_enumerate_circles(self):
+    g = GraphTest.g
+
+    for a, b, c, d in g.all_circles():
+      self.assertTrue(g.check_circle([a, b, c, d]))
+      self.assertTrue(nm.check_circle([a.num, b.num, c.num, d.num]))
+
+
+if __name__ == '__main__':
+  absltest.main()

ag4masses/alphageometry/graph_utils.py

@@ -0,0 +1,132 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Utilizations for graph representation.
+
+Mainly for listing combinations and permutations of elements.
+"""
+
+from geometry import Point
+
+
+def _cross(elems1, elems2):
+  for e1 in elems1:
+    for e2 in elems2:
+      yield e1, e2
+
+
+def cross(elems1, elems2):
+  return list(_cross(elems1, elems2))
+
+
+def _comb2(elems):
+  if len(elems) < 2:
+    return
+  for i, e1 in enumerate(elems[:-1]):
+    for e2 in elems[i + 1 :]:
+      yield e1, e2
+
+
+def comb2(elems):
+  return list(_comb2(elems))
+
+
+def _comb3(elems):
+  if len(elems) < 3:
+    return
+  for i, e1 in enumerate(elems[:-2]):
+    for j, e2 in enumerate(elems[i + 1 : -1]):
+      for e3 in elems[i + j + 2 :]:
+        yield e1, e2, e3
+
+
+def comb3(elems):
+  return list(_comb3(elems))
+
+
+def _comb4(elems):
+  if len(elems) < 4:
+    return
+  for i, e1 in enumerate(elems[:-3]):
+    for j, e2 in enumerate(elems[i + 1 : -2]):
+      for e3, e4 in _comb2(elems[i + j + 2 :]):
+        yield e1, e2, e3, e4
+
+
+def comb4(elems):
+  return list(_comb4(elems))
+
+
+def _perm2(elems):
+  for e1, e2 in comb2(elems):
+    yield e1, e2
+    yield e2, e1
+
+
+def perm2(elems):
+  return list(_perm2(elems))
+
+
+def _all_4points(l1, l2):
+  p1s = l1.neighbors(Point)
+  p2s = l2.neighbors(Point)
+  for a, b in perm2(p1s):
+    for c, d in perm2(p2s):
+      yield a, b, c, d
+
+
+def all_4points(l1, l2):
+  return list(_all_4points(l1, l2))
+
+
+def _all_8points(l1, l2, l3, l4):
+  for a, b, c, d in all_4points(l1, l2):
+    for e, f, g, h in all_4points(l3, l4):
+      yield (a, b, c, d, e, f, g, h)
+
+
+def all_8points(l1, l2, l3, l4):
+  return list(_all_8points(l1, l2, l3, l4))
+
+
+def _perm3(elems):
+  for x in elems:
+    for y in elems:
+      if y == x:
+        continue
+      for z in elems:
+        if z not in (x, y):
+          yield x, y, z
+
+
+def perm3(elems):
+  return list(_perm3(elems))
+
+
+def _perm4(elems):
+  for x in elems:
+    for y in elems:
+      if y == x:
+        continue
+      for z in elems:
+        if z in (x, y):
+          continue
+        for t in elems:
+          if t not in (x, y, z):
+            yield x, y, z, t
+
+
+def perm4(elems):
+  return list(_perm4(elems))

ag4masses/alphageometry/graph_utils_test.py

@@ -0,0 +1,145 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Unit tests for graph_utils.py."""
+import unittest
+
+from absl.testing import absltest
+import graph_utils as gu
+
+
+class GraphUtilsTest(unittest.TestCase):
+
+  def test_cross(self):
+    self.assertEqual(gu.cross([], [1]), [])
+    self.assertEqual(gu.cross([1], []), [])
+    self.assertEqual(gu.cross([1], [2]), [(1, 2)])
+    self.assertEqual(gu.cross([1], [2, 3]), [(1, 2), (1, 3)])
+
+    e1 = [1, 2, 3]
+    e2 = [4, 5]
+    target = [(1, 4), (1, 5), (2, 4), (2, 5), (3, 4), (3, 5)]
+    self.assertEqual(gu.cross(e1, e2), target)
+
+  def test_comb2(self):
+    self.assertEqual(gu.comb2([]), [])
+    self.assertEqual(gu.comb2([1]), [])
+    self.assertEqual(gu.comb2([1, 2]), [(1, 2)])
+    self.assertEqual(gu.comb2([1, 2, 3]), [(1, 2), (1, 3), (2, 3)])
+
+  def test_comb3(self):
+    self.assertEqual(gu.comb3([]), [])
+    self.assertEqual(gu.comb3([1]), [])
+    self.assertEqual(gu.comb3([1, 2]), [])
+    self.assertEqual(gu.comb3([1, 2, 3]), [(1, 2, 3)])
+    self.assertEqual(
+        gu.comb3([1, 2, 3, 4]), [(1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)]
+    )
+
+  def test_comb4(self):
+    self.assertEqual(gu.comb4([]), [])
+    self.assertEqual(gu.comb4([1]), [])
+    self.assertEqual(gu.comb4([1, 2]), [])
+    self.assertEqual(gu.comb4([1, 2, 3]), [])
+    self.assertEqual(gu.comb4([1, 2, 3, 4]), [(1, 2, 3, 4)])
+    self.assertEqual(
+        gu.comb4([1, 2, 3, 4, 5]),
+        [(1, 2, 3, 4), (1, 2, 3, 5), (1, 2, 4, 5), (1, 3, 4, 5), (2, 3, 4, 5)],
+    )
+
+  def test_perm2(self):
+    self.assertEqual(gu.perm2([]), [])
+    self.assertEqual(gu.perm2([1]), [])
+    self.assertEqual(gu.perm2([1, 2]), [(1, 2), (2, 1)])
+    self.assertEqual(
+        gu.perm2([1, 2, 3]), [(1, 2), (2, 1), (1, 3), (3, 1), (2, 3), (3, 2)]
+    )
+
+  def test_perm3(self):
+    self.assertEqual(gu.perm3([]), [])
+    self.assertEqual(gu.perm3([1]), [])
+    self.assertEqual(gu.perm3([1, 2]), [])
+    self.assertEqual(
+        gu.perm3([1, 2, 3]),
+        [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)],
+    )
+    self.assertEqual(
+        gu.perm3([1, 2, 3, 4]),
+        [
+            (1, 2, 3),
+            (1, 2, 4),
+            (1, 3, 2),
+            (1, 3, 4),
+            (1, 4, 2),
+            (1, 4, 3),
+            (2, 1, 3),
+            (2, 1, 4),
+            (2, 3, 1),
+            (2, 3, 4),
+            (2, 4, 1),
+            (2, 4, 3),
+            (3, 1, 2),
+            (3, 1, 4),
+            (3, 2, 1),
+            (3, 2, 4),
+            (3, 4, 1),
+            (3, 4, 2),
+            (4, 1, 2),
+            (4, 1, 3),
+            (4, 2, 1),
+            (4, 2, 3),
+            (4, 3, 1),
+            (4, 3, 2),
+        ],
+    )
+
+  def test_perm4(self):
+    self.assertEqual(gu.perm3([]), [])
+    self.assertEqual(gu.perm3([1]), [])
+    self.assertEqual(gu.perm3([1, 2]), [])
+    self.assertEqual(gu.perm4([1, 2, 3]), [])
+    self.assertEqual(
+        gu.perm4([1, 2, 3, 4]),
+        [
+            (1, 2, 3, 4),
+            (1, 2, 4, 3),
+            (1, 3, 2, 4),
+            (1, 3, 4, 2),
+            (1, 4, 2, 3),
+            (1, 4, 3, 2),  # pylint: disable=line-too-long
+            (2, 1, 3, 4),
+            (2, 1, 4, 3),
+            (2, 3, 1, 4),
+            (2, 3, 4, 1),
+            (2, 4, 1, 3),
+            (2, 4, 3, 1),  # pylint: disable=line-too-long
+            (3, 1, 2, 4),
+            (3, 1, 4, 2),
+            (3, 2, 1, 4),
+            (3, 2, 4, 1),
+            (3, 4, 1, 2),
+            (3, 4, 2, 1),  # pylint: disable=line-too-long
+            (4, 1, 2, 3),
+            (4, 1, 3, 2),
+            (4, 2, 1, 3),
+            (4, 2, 3, 1),
+            (4, 3, 1, 2),
+            (4, 3, 2, 1),
+        ],  # pylint: disable=line-too-long
+    )
+
+
+if __name__ == '__main__':
+  absltest.main()

ag4masses/alphageometry/imo_ag_30.txt

@@ -0,0 +1,60 @@
+translated_imo_2000_p1
+a b = segment a b; g1 = on_tline g1 a a b; g2 = on_tline g2 b b a; m = on_circle m g1 a, on_circle m g2 b; n = on_circle n g1 a, on_circle n g2 b; c = on_pline c m a b, on_circle c g1 a; d = on_pline d m a b, on_circle d g2 b; e = on_line e a c, on_line e b d; p = on_line p a n, on_line p c d; q = on_line q b n, on_line q c d ? cong e p e q
+translated_imo_2000_p6
+a b c = triangle a b c; h = orthocenter h a b c; t1 t2 t3 i = incenter2 t1 t2 t3 i a b c; h1 = foot h1 a b c; h2 = foot h2 b c a; h3 = foot h3 c a b; x1 = reflect x1 h1 t1 t2; x2 = reflect x2 h2 t1 t2; y2 = reflect y2 h2 t2 t3; y3 = reflect y3 h3 t2 t3; z = on_line z x1 x2, on_line z y2 y3 ? cong i z i t1
+translated_imo_2002_p2a
+b c = segment b c; o = midpoint o b c; a = on_circle a o b; d = on_circle d o b, on_bline d a b; e = on_bline e o a, on_circle e o b; f = on_bline f o a, on_circle f o b; j = on_pline j o a d, on_line j a c ? eqangle e c e j e j e f
+translated_imo_2002_p2b
+b c = segment b c; o = midpoint o b c; a = on_circle a o b; d = on_circle d o b, on_bline d a b; e = on_bline e o a, on_circle e o b; f = on_bline f o a, on_circle f o b; j = on_pline j o a d, on_line j a c ? eqangle c e c j c j c f
+translated_imo_2003_p4
+a b c = triangle a b c; o = circle o a b c; b1 = on_circle b1 o a, on_bline b1 c a; d1 = on_circle d1 o a, on_bline d1 c a; x = on_line x b b1, on_line x a c; d = on_line d d1 x, on_circle d o a; p = foot p d b c; q = foot q d c a; r = foot r d a b ? cong p q q r
+translated_imo_2004_p1
+a b c = triangle a b c; o = midpoint o b c; m = on_circle m o b, on_line m a b; n = on_circle n o b, on_line n a c; r = angle_bisector r b a c, angle_bisector r m o n; o1 = circle o1 b m r; o2 = circle o2 c n r; p = on_circle p o1 r, on_circle p o2 r ? coll p b c
+translated_imo_2004_p5
+a b c = triangle a b c; o = circle o a b c; d = on_circle d o a; p = on_aline p b c a b d, on_aline p d c a d b ? cong a p c p
+translated_imo_2005_p5
+a b c = triangle a b c; d = eqdistance d a b c; e = on_line e b c; f = on_line f a d, eqdistance f d e b; p = on_line p a c, on_line p b d; q = on_line q e f, on_line q b d; r = on_line r e f, on_line r a c; o1 = circle o1 a p d; o2 = circle o2 b p c; m = on_circle m o1 p, on_circle m o2 p ? cyclic p q r m
+translated_imo_2007_p4
+a b c = triangle a b c; o = circle o a b c; r = on_circle r o a, on_bline r a b; l = midpoint l c a; k = midpoint k c b; p = on_line p o k, on_line p c r; q = on_line q o l, on_line q c r; l1 = foot l1 l c r; k1 = foot k1 k c r ? eqratio k k1 l l1 r q r p
+translated_imo_2008_p1a
+a b c = triangle a b c; h = orthocenter h a b c; d = midpoint d b c; e = midpoint e a c; f = midpoint f a b; a1 = on_circle a1 d h, on_line a1 b c; a2 = on_circle a2 d h, on_line a2 b c; b1 = on_circle b1 e h, on_line b1 c a; b2 = on_circle b2 e h, on_line b2 c a; c1 = on_circle c1 f h, on_line c1 a b; c2 = on_circle c2 f h, on_line c2 a b ? cyclic c1 c2 b1 b2
+translated_imo_2008_p1b
+a b c = triangle a b c; h = orthocenter h a b c; d = midpoint d b c; e = midpoint e a c; f = midpoint f a b; a1 = on_circle a1 d h, on_line a1 b c; a2 = on_circle a2 d h, on_line a2 b c; b1 = on_circle b1 e h, on_line b1 c a; b2 = on_circle b2 e h, on_line b2 c a; c1 = on_circle c1 f h, on_line c1 a b; c2 = on_circle c2 f h, on_line c2 a b ? cyclic c1 c2 b1 a1
+translated_imo_2008_p6
+x@4.96_-0.13 y@-1.0068968328888160_-1.2534881080682770 z@-2.8402847238575120_-4.9117762734006830 = triangle x y z; o = circle o x y z; w@6.9090049230038776_-1.3884003936987552 = on_circle w o x; a = on_tline a z o z, on_tline a x o x; b = on_tline b z o z, on_tline b w o w; c = on_tline c y o y, on_tline c w o w; d = on_tline d x o x, on_tline d y o y; i1 = incenter i1 a b c; i2 = incenter i2 a c d; f1 = foot f1 i1 a c; f2 = foot f2 i2 a c; q t p s = cc_tangent q t p s i1 f1 i2 f2; k = on_line k q t, on_line k p s ? cong o k o x
+translated_imo_2009_p2
+m l k = triangle m l k; w = circle w m l k; q = on_tline q m w m; p = mirror p q m; b = mirror b p k; c = mirror c q l; a = on_line a b q, on_line a c p; o = circle o a b c ? cong o p o q
+translated_imo_2010_p2
+a b c = triangle a b c; o = circle o a b c; i = incenter i a b c; d = on_line d a i, on_circle d o a; f = on_line f b c; e = on_aline e a c b a f, on_circle e o a; g = midpoint g i f; k = on_line k d g, on_line k e i ? cong o a o k
+translated_imo_2010_p4
+s c p = iso_triangle s c p; o = on_tline o c s c; a = on_circle a o c; b = on_circle b o c, on_line b s a; m = on_line m c p, on_circle m o c; l = on_line l b p, on_circle l o c; k = on_line k a p, on_circle k o c ? cong m k m l
+translated_imo_2011_p6
+a b c = triangle a b c; o = circle o a b c; p = on_circle p o a; q = on_tline q p o p; pa = reflect pa p b c; pb = reflect pb p c a; pc = reflect pc p a b; qa = reflect qa q b c; qb = reflect qb q c a; qc = reflect qc q a b; a1 = on_line a1 pb qb, on_line a1 pc qc; b1 = on_line b1 pa qa, on_line b1 pc qc; c1 = on_line c1 pa qa, on_line c1 pb qb; o1 = circle o1 a1 b1 c1; x = on_circle x o a, on_circle x o1 a1 ? coll x o o1
+translated_imo_2012_p1
+a b c = triangle a b c; m l k j = excenter2 m l k j a b c; f = on_line f m l, on_line f b j; g = on_line g m k, on_line g c j; s = on_line s f a, on_line s b c; t = on_line t g a, on_line t c b ? cong m s m t
+translated_imo_2012_p5
+c a b = r_triangle c a b; d = foot d c a b; x = on_line x c d; k = on_line k a x, on_circle k b c; l = on_line l b x, on_circle l a c; m = on_line m a l, on_line m b k ? cong m k m l
+translated_imo_2013_p4
+a b c = triangle a b c; h = orthocenter h a b c; m = on_line m h b, on_line m a c; n = on_line n h c, on_line n a b; w = on_line w b c; o1 = circle o1 b n w; o2 = circle o2 c m w; x = on_line x o1 w, on_circle x o1 w; y = on_line y o2 w, on_circle y o2 w ? coll x h y
+translated_imo_2014_p4
+a b c = triangle a b c; p = on_line p b c, on_aline p a b b c a; q = on_line q b c, on_aline q a c c b a; m = mirror m a p; n = mirror n a q; x = on_line x b m, on_line x c n; o = circle o a b c ? cong o x o a
+translated_imo_2015_p3
+a b c = triangle a b c; h = orthocenter h a b c; f = on_line f h a, on_line f b c; m = midpoint m b c; o = circle o a b c; q = on_dia q a h, on_circle q o a; k = on_dia k h q, on_circle k o a; o1 = circle o1 k q h; o2 = circle o2 f k m ? coll o1 o2 k
+translated_imo_2015_p4
+a b c = triangle a b c; o = circle o a b c; d = on_line d b c; e = on_line e b c, on_circle e a d; f = on_circle f o a, on_circle f a d; g = on_circle g o a, on_circle g a d; o1 = circle o1 f b d; o2 = circle o2 g c e; k = on_circle k o1 b, on_line k a b; l = on_circle l o2 c, on_line l a c; x = on_line x f k, on_line x l g ? coll x o a
+translated_imo_2016_p1
+a b z = triangle a b z; f = angle_bisector f b a z, on_bline f a b; c = on_tline c b f b, on_line c a f; d = on_line d a z, on_bline d a c; e = angle_mirror e c a d, on_bline e a d; m = midpoint m c f; x = parallelogram e a m x; y = on_line y f x, on_line y e m ? coll y b d
+translated_imo_2017_p4
+r s = segment r s; t = mirror t r s; o = on_bline o r s; j = on_circle j o s; o1 = circle o1 j s t; a = on_tline a r o r, on_circle a o1 s; b = on_tline b r o r, on_circle b o1 s; k = on_line k j a, on_circle k o s ? perp k t o1 t
+translated_imo_2018_p1
+a b c = triangle a b c; o = circle o a b c; d = on_line d a b; e = on_line e a c, on_circle e a d; f = on_bline f b d, on_circle f o a; g = on_bline g e c, on_circle g o a ? para d e f g
+translated_imo_2019_p2
+a b c = triangle; a1 = on_line b c; b1 = on_line a c; p = on_line a a1; q = on_line b b1, on_pline p a b; p1 = on_line p b1, eqangle3 p c a b c; q1 = on_line q a1, eqangle3 c q b c a ? cyclic p q p1 q1
+translated_imo_2019_p6
+a b c = triangle a b c; d e f i = incenter2 d e f i a b c; r = on_tline r d e f, on_circle r i d; p = on_line p r a, on_circle p i d; o1 = circle o1 p c e; o2 = circle o2 p b f; q = on_circle q o1 p, on_circle q o2 p; t = on_line t p q, on_line t i d ? perp a t a i
+translated_imo_2020_p1
+p a b = triangle p a b; x = angle_bisector p b a; y = angle_bisector p a b; z = on_aline z a p a b x; t = on_aline t p a p a z; d = on_aline d p t p b a, on_line a z; u = on_aline u b p b a y; v = on_aline v p b p b u; c = on_aline c p v p a b, on_line b u; o = angle_bisector a d p, angle_bisector p c b ? cong o a o b
+translated_imo_2021_p3
+a b c = triangle; d = angle_bisector b a c; e = on_aline d a d c b, on_line a c; f = on_aline d a d b c, on_line a b; x = on_bline b c, on_line a c; o1 = circle a d c; o2 = circle e x d; y = on_line e f, on_line b c ? coll o1 o2 y
+translated_imo_2022_p4
+b c = segment; d = free; e = eqdistance d b c; t = on_bline b d, on_bline c e; a = eqangle2 b t e; p = on_line a b, on_line c d; q = on_line a b, on_line c t; r = on_line a e, on_line c d; s = on_line a e, on_line d t ? cyclic p q r s

ag4masses/alphageometry/jgex_ag_231.txt

@@ -0,0 +1,462 @@
+examples/complete2/012/complete_004_6_GDD_FULL_81-109_101.gex
+a b c = triangle a b c; o = circle o a b c; h = midpoint h c b; d = on_line d o h, on_line d a b; e = on_tline e c c o, on_tline e a a o ? cyclic a o e d
+examples/complete2/012/complete_002_6_GDD_FULL_41-60_59.gex
+a b c = triangle a b c; m = midpoint m b a; o = circle o a b c; n = on_line n o m, on_circle n o a ? eqangle c a c n c n c b
+examples/complete2/012/complete_002_6_GDD_FULL_01-20_04.gex
+a b c = triangle a b c; o = circle o a b c; d = on_circle d o a; q = midpoint q c b; s = midpoint s a d; j = midpoint j s q; m = mirror m o j; i = on_line i a d, on_line i b c ? perp s m b c
+examples/complete2/012/complete_004_6_GDD_FULL_81-109_90.gex
+a b c = triangle a b c; o = circle o a b c; d = on_circle d o a; g = foot g d a b; f = foot f d a c; c1 = on_circle c1 o d, on_line c1 d g; b1 = on_circle b1 o d, on_line b1 d f ? para c1 c b1 b
+examples/complete2/012/complete_004_6_GDD_FULL_81-109_94.gex
+a b c = triangle a b c; o = circle o a b c; d = on_circle d o a; p = on_circle p o a; f = foot f p a d; g = foot g p a b; h = foot h p b c; e = foot e p c d; i = on_line i f g, on_line i h e ? cyclic p g i h
+examples/complete2/012/complete_003_6_GDD_FULL_21-40_37.gex
+a b c = triangle a b c; h = orthocenter h a b c; o = circle o a b c; c1 = on_circle c1 o c, on_line c1 c h; a1 = on_circle a1 o a, on_line a1 a h ? cong b a1 b c1
+examples/complete2/012/complete_003_6_GDD_FULL_21-40_22.gex
+a b c = triangle a b c; o = circle o a b c; p = foot p o a c; q = foot q o a b; m = on_line m o q, on_circle m o a; n = on_line n o p, on_circle n o a; e = on_line e a c, on_line e n m; d = on_line d a b, on_line d n m ? eqangle d a d e e d e a
+examples/complete2/012/complete_001_6_GDD_FULL_01-20_19.gex
+a b c = triangle a b c; f = free f; p = circle p a b f; o = circle o a b c; e = on_circle e p a, on_line e a c; d = on_circle d o b, on_line d b f ? para c d e f
+examples/complete2/012/complete_001_6_GDD_FULL_61-80_74.gex
+a b c = triangle a b c; g = foot g c a b; o = circle o a b c; d = on_circle d o c, on_line d c g; e = foot e d a c; f = foot f d b c ? cyclic a e f b
+examples/complete2/013/complete_002_6_GDD_FULL_41-60_49.gex
+a b c = triangle a b c; p = midpoint p b a; q = midpoint q c b; d = on_tline d b a c; r = midpoint r d c; s = midpoint s a d; o = on_line o p r, on_line o q s ? cong o s o r
+examples/complete2/013/complete_006_Other_ndgTest_70.gex
+p a b = triangle p a b; o = midpoint o b a; a1 = on_line a1 p a, on_circle a1 o a; b1 = on_line b1 p b, on_circle b1 o a; o1 = circle o1 p a1 b1 ? perp o a1 a1 o1
+examples/complete2/013/complete_001_6_GDD_FULL_01-20_16.gex
+a b o = triangle a b o; m = on_line m a b; p = foot p m a o; q = foot q m b o; d = foot d b a o; c = foot c a b o; t = foot t q a o; k = foot k p b o; s = on_line s q t, on_line s p k ? perp o s p q
+examples/complete2/013/complete_001_6_GDD_FULL_61-80_67.gex
+m b c = triangle m b c; i = incenter i m b c; i_b = on_tline i_b c c i, on_line i_b b i; i_c = on_tline i_c b b i, on_line i_c c i; a = midpoint a i_b i_c; o = circumcenter o b i c ? perp a b b o
+examples/complete2/013/complete_000_2_PWW_A018.gex
+o a = segment o a; p = on_circle p a o; q = intersection_cc q a o p; r = lc_tangent r p a, on_circle r o p ? cong p q p r
+examples/complete2/013/complete_004_6_GDD_FULL_81-109_88.gex
+o x l = triangle o x l; a = foot a l o x; y = free y; b = foot b l o y; p = mirror p l a; q = mirror q l b; q1 = on_line q1 l a, on_line q1 o y; p1 = on_line p1 o x, on_line p1 l b ? cyclic o p q p1
+examples/complete2/013/complete_003_6_GDD_FULL_21-40_24.gex
+q r p = triangle q r p; o1 = circle o1 q r p; s = on_circle s o1 q; y = on_line y q s; o = circle o y p q; x = on_circle x o q; i = on_line i r s, on_line i y x ? eqangle i r i x p r p x
+examples/complete2/013/complete_003_6_GDD_FULL_21-40_32.gex
+b c r = triangle b c r; o = circle o b c r; s = on_circle s o b; a = on_line a b r, on_line a c s; m = foot m a r s; n = foot n a b c ? eqangle a b a m a n a c
+examples/complete2/013/complete_002_6_GDD_FULL_41-60_54.gex
+a b c = r_triangle a b c; d = foot d a b c; o = midpoint o c b; m = foot m b a o; g = on_line g b m, on_circle g o a; f = on_line f c a, on_line f b m; e = on_line e a d, on_line e b m ? cong e a e b
+examples/complete2/013/complete_005_Other_ndg1_53.gex
+a o = segment a o; b = on_circle b o a; c = on_line c a b; e = intersection_tt e b b o c c o; d = intersection_lt d c e a a o ? cong o e o d
+examples/complete2/013/complete_002_6_GDD_FULL_41-60_56.gex
+m a b = iso_triangle m a b; o = circle o a b m; d = on_line d m o, on_line d a b; e = on_tline e a a o, on_pline e m a o ? cong m e m d
+examples/complete2/013/complete_002_6_GDD_FULL_41-60_52.gex
+e c d = r_triangle e c d; o = midpoint o d c; a = on_tline a c c d, on_tline a e e o; f = on_line f c a, on_line f d e ? cong a e a f
+examples/complete2/014/complete_008_7_Book_LLL_L053-1.gex
+b c d = triangle b c d; e = foot e b c d; a = free a; f = foot f a c d; g = midpoint g b a ? cong f g g e
+examples/complete2/014/complete_007_7_Book_LLL_L058-9.gex
+a b = segment a b; c = on_bline c a b; d = on_tline d b a b; e = intersection_lt e c d a a b ? cong e c c d
+examples/complete2/007/complete_003_6_GDD_FULL_more_E015-6.gex
+a b c = triangle a b c; d = midpoint d a c; e = midpoint e b a; f = midpoint f c b; g = on_pline g d a f, on_pline g f a c ? para c e g b
+examples/complete2/007/complete_003_6_GDD_FULL_more_E022-9.gex
+a b c = triangle a b c; d = circumcenter d b a c; e = on_line e a c, angle_bisector e c b a; f = intersection_lc f e d b; g = on_tline g f d f ? para f g a c
+examples/complete2/007/complete_012_7_Book_00EE_02_E028-2.gex
+a b c = triangle a b c; d e = square a c d e; g f = square c b g f ? perp d b f a
+examples/complete2/007/complete_012_7_Book_00EE_05_E051-22.gex
+a b = segment a b; c = midpoint c b a; d = on_tline d b a b; e = on_line e a d, on_circle e c a; f = on_pline f e a b, on_circle f c e; g = foot g d a f ? cong a f f g
+examples/complete2/007/complete_005_Other_other_E075-25-sss.gex
+a b c = triangle a b c; d = midpoint d c b; e = midpoint e a c; f = midpoint f b a; g = foot g a b c ? eqangle d f d e g f g e
+examples/complete2/007/complete_001_6_GDD_FULL_01-20_01.gex
+a b c = triangle a b c; d = foot d c a b; e = foot e b a c; f = midpoint f c b; g = midpoint g d e ? perp f g d e
+examples/complete2/007/complete_000_2_PWW_B016x.gex
+a b c = triangle a b c; d = midpoint d b c; e = midpoint e c a; f = midpoint f b a; g = parallelogram d a e g ? cong c f g b
+examples/complete2/007/complete_001_6_GDD_FULL_61-80_66.gex
+a b c = triangle a b c; d = foot d c a b; e = on_tline e a b c, on_line e c d; f = midpoint f a e; g = midpoint g c b ? perp d g d f
+examples/complete2/007/complete_016_7_Book_00EE_06_E051-30.gex
+a b = segment a b; c = midpoint c b a; d = on_circle d c a; e = lc_tangent e d c, on_line e a b; f = angle_bisector f d e a, on_line f a d; g = on_line g e f, on_line g b d ? cong d f d g
+examples/complete2/007/complete_016_7_Book_00EE_06_E051-24.gex
+a b = segment a b; c = midpoint c b a; d = on_circle d c a; e = on_line e b d; f = circle f d c e; g = on_pline g e a b, on_circle g f c ? cong g e c b
+examples/complete2/007/complete_013_7_Book_00EE_11_E077-37.gex
+a b = segment a b; c = midpoint c b a; d = on_circle d c b; e = foot e d a b; f = lc_tangent f d c; g = on_line g d f ? eqangle d f d a d a d e
+examples/complete2/007/complete_013_7_Book_00EE_07_E059-54-1.gex
+a b = segment a b; c = midpoint c b a; d = mirror d c b; e = on_circle e c a, on_circle e b c; f = on_tline f b a b, on_line f a e; g = on_line g b f, on_line g d e ? cong e g g f
+examples/complete2/007/complete_008_ex-gao_ex160_e201f.gex
+a b c = triangle a b c; d e = square a b d e; f = foot f a b c; g = on_line g a f, eqdistance g a b c ? perp g b c d
+examples/complete2/000/complete_016_ex-gao_gao_M_M020-52.gex
+a b = segment a b; c = on_circle c a b; d = on_circle d a b; e = on_circle e a b, on_pline e d b c ? cong d c e b
+examples/complete2/000/complete_010_Other_gao_L_L190-7.gex
+a b = segment a b; c = nsquare c b a; d = psquare d a b; e = on_line e b d; f = foot f e b c; g = foot g e d c ? cong e a g f
+examples/complete2/000/complete_007_7_Book_LLL_L017-11.gex
+c a = segment c a; b = on_tline b c c a; d = foot d c a b ? eqangle a c a d c b c d
+examples/complete2/000/complete_016_ex-gao_gao_M_M024-94.gex
+a b c = triangle a b c; d = on_circle d a b, on_circle d c b; e = on_line e d a, on_circle e a d; f = on_line f d c, on_circle f c d ? coll e b f
+examples/complete2/000/complete_007_7_Book_LLL_L054-2-1.gex
+a b = segment a b; c = on_bline c a b; d = on_line d a c; e = eqdistance e b a d, on_line e b c; f = on_line f a b, on_line f d e; g = on_line g b c, on_pline g d a b ? cong d f f e
+examples/complete2/000/complete_007_7_Book_LLL_L057-1-1.gex
+a b = segment a b; m = midpoint m a b; c = on_circle c m a; d = angle_mirror d a b c; e = midpoint e a d; f = on_line f b d, on_line f a c ? para c e b d
+examples/complete2/000/complete_016_ex-gao_gao_M_M021-64.gex
+a b = segment a b; d = midpoint d b a; c = on_circle c b a, on_circle c a b; e = on_line e a c, on_circle e d a; f = on_circle f d a, on_line f b c ? cong a e e f
+examples/complete2/000/complete_007_7_Book_LLL_L057-3-2.gex
+a b = segment a b; c = on_bline c a b; e = midpoint e a c; d = on_circle d a c, on_line d a c; f = midpoint f b d ? cong b e b f
+examples/complete2/000/complete_004_6_GDD_FULL_81-109_95.gex
+a b c = triangle a b c; a1 = midpoint a1 c b; f = circle f a b c; s = on_aline s a b c a a1, on_line s b c; p = on_circle p f a, on_line p a a1; q = on_circle q f a, on_line q a s ? para b c p q
+examples/complete2/000/complete_001_6_GDD_FULL_01-20_02.gex
+a b c = triangle a b c; a1 = midpoint a1 c b; b1 = midpoint b1 c a; c1 = midpoint c1 b a; o = circle o a b c ? perp o a1 b1 c1
+examples/complete2/000/complete_004_6_GDD_FULL_81-109_96.gex
+a b c = triangle a b c; a1 = midpoint a1 c b; n = on_line n a a1; g = foot g n a b; h = foot h n a c; s = on_aline s a b c a a1, on_line s b c ? perp g h a s
+examples/complete2/000/complete_007_7_Book_LLL_L194-2.gex
+a b = segment a b; c = on_bline c a b; d = on_bline d a b; e = on_line e c d, on_line e a b ? cong a e e b
+examples/complete2/000/complete_017_ex-gao_gao_L_L022-1.gex
+a b = segment a b; c = on_bline c a b; d = on_line d a c; e = on_circle e c d, on_line e b c ? cong a e b d
+examples/complete2/000/complete_016_ex-gao_gao_M_M09-14.gex
+c b = segment c b; d = midpoint d c b; a = free a; e = midpoint e b a; f = midpoint f c a; g = on_line g a d, on_line g e f ? cong e g g f
+examples/complete2/009/complete_014_7_Book_00EE_09_E071-4.gex
+a b = segment a b; c = midpoint c b a; d = on_circle d c a; e = lc_tangent e d c, on_line e a b; f = foot f a d e ? eqangle a f a d a d a b
+examples/complete2/009/complete_013_7_Book_00EE_10_E072-13.gex
+a b c = triangle a b c; d = foot d b a c; e = foot e a b c; f = foot f b d e ? eqangle b a b d b c b f
+examples/complete2/009/complete_014_7_Book_00EE_09_E071-2.gex
+a b c = triangle a b c; d = midpoint d c b; e = foot e b a c; f = foot f c a b ? eqangle a b a c e f e d
+examples/complete2/009/complete_014_7_Book_00EE_09_E071-1.gex
+a b c = triangle a b c; e = on_line e a b, on_circle e a c; d = angle_bisector d b a c, on_line d b c; f = on_pline f e b c, on_line f a c ? eqangle e d e c e c e f
+examples/complete2/009/complete_017_ex-gao_ex160_4_e10.gex
+a b c d = isquare a b c d; e = on_line e b d, on_circle e b c; f = on_tline f e b d, on_line f d c ? cong e d c f
+examples/complete2/009/complete_003_6_GDD_FULL_more_E022-12.gex
+a b c = triangle a b c; e = circumcenter e a b c; d = on_line d a b, angle_bisector d a c b; f = on_tline f c c e, on_pline f d a c ? cong c f d b
+examples/complete2/009/complete_001_6_GDD_FULL_61-80_69.gex
+d a b = r_triangle d a b; c = midpoint c b a; e = circle e a c d; f = circle f b d c ? perp e d d f
+examples/complete2/009/complete_012_7_Book_00EE_05_E051-19.gex
+a b c = triangle a b c; d = circumcenter d a c b; e = on_line e b c; f = on_circle f d a, angle_bisector f a c e ? cong a f f b
+examples/complete2/009/complete_016_7_Book_00EE_06_E051-32.gex
+a b c = triangle a b c; d = eq_triangle d a b; e = eq_triangle e a c; f = eq_triangle f c b ? para e d c f
+examples/complete2/009/complete_013_7_Book_00EE_10_E074-23.gex
+a b c = triangle a b c; d = foot d a b c; e = circumcenter e b a c; f = angle_bisector f b a c, on_circle f e a ? eqangle e a a f f a a d
+examples/complete2/009/complete_011_Other_Auxiliary_aux2_trapezoid.gex
+a b c d = trapezoid a b c d; e = midpoint e d a; f = on_pline f e a b, on_line f b c ? midp f b c
+examples/complete2/009/complete_016_7_Book_00EE_06_E057-37.gex
+a b c = triangle a b c; d = eq_triangle d a b; e = eq_triangle e a c; f = parallelogram c e d f ? cong b f f c
+examples/complete2/008/complete_004_6_GDD_FULL_81-109_100.gex
+a c = segment a c; b = eq_triangle b c a; e = mirror e c b; d = mirror d b e; f = foot f d a b ? perp a c c f
+examples/complete2/008/complete_005_Other_ndgs_02.gex
+b a c = triangle b a c; d = foot d b a c; e = foot e c a b; f = intersection_ll f b d c e ? perp b c a f
+examples/complete2/008/complete_008_ex-gao_ex160_205.gex
+c a b = r_triangle c a b; d = midpoint d c a; f = midpoint f c b; e = on_line e a b, on_circle e d c ? perp d e e f
+examples/complete2/008/complete_015_7_Book_00EE_08_E061-62.gex
+a b = segment a b; c = on_circle c a b; e = on_circle e a b; d = on_circle d a b, on_circle d b c; f = on_circle f b c, on_line f c e ? cong e d e f
+examples/complete2/008/complete_015_7_Book_00EE_06_E051-31.gex
+a b c = triangle a b c; d = parallelogram a b c d; e = eq_triangle e a b; f = eq_triangle f b c ? cong d e d f
+examples/complete2/008/complete_011_7_Book_00EE_03_E037-22.gex
+c a b = risos c a b; e = midpoint e b a; d = on_line d a b, on_circle d b c; f = on_line f a c, on_circle f c e ? perp a c f d
+examples/complete2/008/complete_011_7_Book_00EE_03_E037-21.gex
+a b = segment a b; c = on_circle c a b; d = lc_tangent d c a, on_line d a b; e = on_line e a b, on_circle e a b; f = on_pline f a c e, on_line f c d ? perp f b a b
+examples/complete2/008/complete_011_7_Book_00EE_04_E051-5.gex
+c a = segment c a; b = eq_triangle b c a; d = circumcenter d c a b; e = on_pline e d a c, on_line e a b; f = on_pline f d b c, on_line f a b ? cong a e e f
+examples/complete2/008/complete_003_6_GDD_FULL_more_E009-1.gex
+a c = segment a c; b = on_tline b c a c; d = on_dia d b a, on_circle d a c; e = on_line e b c, on_circle e a b; f = on_line f b d, on_circle f a b ? para c d e f
+examples/complete2/008/complete_011_7_Book_00EE_03_E039-28.gex
+a b = segment a b; c = on_circle c a b; d = on_circle d a b, on_circle d c b; e = mirror e d c; f = on_circle f a b, on_line f b e ? coll d a f
+examples/complete2/008/complete_011_7_Book_00EE_03_E040-28-1.gex
+c a b = iso_triangle c a b; d = on_line d b c; e = circle e a b d; f = on_circle f e a, on_line f a c ? para a b f d
+examples/complete2/008/complete_018_ex-gao_ex160_4_004.gex
+b a c = triangle b a c; d = on_line d b c, on_circle d a b; e = on_tline e c a c, on_tline e b a b; f = on_tline f d a d, on_line f c e ? cong e c c f
+examples/complete2/008/complete_014_7_Book_00EE_07_E059-50.gex
+a b = segment a b; c = on_circle c a b; d = on_circle d a b; e = circle e c a d; f = on_line f b c, on_circle f e a ? cong d f f b
+examples/complete2/008/complete_013_7_Book_00EE_07_E057-44.gex
+c a b = iso_triangle c a b; d = foot d a b c; e = foot e b a c; f = on_line f a d, on_line f b e ? cong f a f b
+examples/complete2/001/complete_006_7_Book_LLL_L046-16.gex
+a b = segment a b; c = on_line c a b; d = on_circle d c a, on_circle d a c; e = on_aline e b a d c a, on_aline e c a d a b; f = on_line f c d, on_line f a e; g = on_line g b d, on_line g c e ? cong c f c g
+examples/complete2/001/complete_016_ex-gao_gao_M_M010-32.gex
+b c a = triangle b c a; d = on_pline d a b c, on_pline d c a b; e = on_line e b c; f = on_line f a d, on_pline f e a b; g = on_line g a e, on_line g b f; h = on_line h c f, on_line h d e ? para h g d a
+examples/complete2/001/complete_016_ex-gao_gao_M_M010-26.gex
+b d = segment b d; e = midpoint e b d; c = free c; a = on_pline a d b c, on_pline a b d c; f = on_line f c d; g = on_line g a b, on_line g e f; h = on_line h e f, on_line h a d; i = on_line i b c, on_line i e f ? cong f h g i
+examples/complete2/001/complete_016_ex-gao_gao_C_C101.gex
+a b c = triangle a b c; e = foot e a b c; f = foot f c a b; d = on_bline d a c, on_bline d a b; g = on_line g c f, on_line g a e; h = on_line h c f, on_circle h d c ? cong g f f h
+examples/complete2/001/complete_016_ex-gao_gao_C_C100.gex
+a c = segment a c; b = on_tline b c c a; e = on_circle e b c; d = on_circle d a c, on_circle d b c; f = on_line f c e, on_circle f a c; g = on_line g e b, on_circle g b e ? coll d f g
+examples/complete2/001/complete_016_ex-gao_gao_L_L182-6.gex
+a b c = triangle a b c; e = midpoint e b c; d = on_line d a b; f = midpoint f d c; g = midpoint g b a; h = midpoint h g f; i = on_line i a b, on_line i e h ? cong a i i d
+examples/complete2/001/complete_016_ex-gao_gao_C_C111.gex
+a d c = triangle a d c; b = on_pline b a d c; e = on_line e a d; f = on_line f a c, on_pline f e a b; g = on_line g b d, on_line g e f; h = on_line h b c, on_line h e f ? cong e f g h
+examples/complete2/001/complete_016_ex-gao_gao_L_L025-5.gex
+a b = segment a b; c = on_bline c a b; d = on_line d a c; e = on_circle e c d, on_line e b c; f = on_line f b d, on_line f a e ? eqangle a c c f f c c b
+examples/complete2/001/complete_017_ex-gao_gao_L_L189-2.gex
+a b = segment a b; c = on_bline c a b; e = midpoint e c a; f = midpoint f b c; d = on_pline d b a c, on_pline d a b c; g = midpoint g d b; h = midpoint h a d ? perp h e e f
+examples/complete2/001/complete_016_ex-gao_gao_L_L182-5.gex
+c d a = triangle c d a; b = on_pline b c d a, on_pline b a d c; e = on_line e c d; f = on_line f a b, on_pline f c a e; g = on_line g b e, on_line g c f; h = on_line h d f, on_line h a e ? cong g e f h
+examples/complete2/001/complete_017_ex-gao_gao_L_L189-1.gex
+a b = segment a b; c = on_tline c b a b; d = on_tline d c b c, on_tline d a a b; e = midpoint e c d; f = midpoint f b c; g = midpoint g a b; h = midpoint h a d ? cong h g h e
+examples/complete2/001/complete_016_ex-gao_gao_C_C109.gex
+b d a = triangle b d a; c = on_pline c d a b; e = on_line e b d, on_line e a c; f = on_line f a d, on_pline f e a b; g = on_line g b c, on_line g e f ? cong f e e g
+examples/complete2/001/complete_016_ex-gao_gao_L_LL153-1.gex
+c a d = triangle c a d; e = foot e c a d; b = free b; f = foot f b a d; g = midpoint g c b; h = midpoint h e f ? cong g e g f
+examples/complete2/001/complete_010_Other_gao_Y_yL182-4.gex
+c d = segment c d; e = midpoint e c d; a = free a; b = on_pline b c d a, on_pline b a d c; f = midpoint f a b; g = on_line g a c, on_line g b e; h = on_line h d f, on_line h a c ? cong a h h g
+examples/complete2/006/complete_012_7_Book_00EE_02_E028-3.gex
+c a b = risos c a b; d = midpoint d b a; e = on_line e b c; f = circle f d b e; g = on_line g a e, on_circle g f b ? perp c g a e
+examples/complete2/006/complete_003_6_GDD_FULL_more_E022-11.gex
+a b c = triangle a b c; d = circumcenter d a b c; f = foot f d a b; e = on_tline e c c d, on_tline e b b d; g = on_line g d f, on_line g a c ? para g e a b
+examples/complete2/006/complete_010_Other_Auxiliary_aux2_e04f.gex
+a b c d = trapezoid a b c d; e = midpoint e c a; f = midpoint f d b; g = on_line g e f, on_line g a d ? midp g a d
+examples/complete2/006/complete_004_6_GDD_FULL_81-109_98.gex
+a b c = triangle a b c; e = on_line e a b; d = circle d a b c; f = on_circle f d a, on_aline f c b a c e; g = on_circle g d c, on_line g c e ? para a b g f
+examples/complete2/006/complete_001_6_GDD_FULL_61-80_72.gex
+a b c = triangle a b c; d = circle d a b c; e = on_circle e d a; f = foot f e a c; g = foot g e a b ? simtri e f g e c b
+examples/complete2/006/complete_013_7_Book_00EE_11_E075-26.gex
+a b = segment a b; c = mirror c a b; d = mirror d b c; e = midpoint e c b; f = on_circle f e c, on_dia f a e; g = on_line g a f ? eqangle b f a f c f e f
+examples/complete2/006/complete_015_7_Book_00EE_06_E057-38.gex
+c a b = r_triangle c a b; d = foot d c a b; e = angle_bisector e c a b, on_line e b c; g = foot g e a b; f = on_line f c d, on_line f a e ? cong c e c f
+examples/complete2/006/complete_014_7_Book_00EE_07_E059-47.gex
+a b c d = rectangle a b c d; e = on_line e b d, on_line e a c; f = midpoint f e d; g = midpoint g e a ? cong f c g b
+examples/complete2/006/complete_014_7_Book_00EE_07_E059-53.gex
+a b c = triangle a b c; d = circle d c a b; e = circle e c d b; f = on_line f a b, on_circle f e b; g = on_line g a c, on_circle g e b ? cong g b g a
+examples/complete2/006/complete_003_6_GDD_FULL_more_E023-15.gex
+a b c d = quadrangle a b c d; e = on_line e a c; g = on_pline g e a b, on_line g b c; f = on_pline f e a d, on_line f c d ? para b d g f
+examples/complete2/011/complete_002_6_GDD_FULL_01-20_12.gex
+a b c = triangle a b c; o = circle o a b c; d = on_tline d b a c, on_circle d o a; f = midpoint f b a; e = on_line e a c, on_line e b d ? perp f e c d
+examples/complete2/011/complete_002_6_GDD_FULL_01-20_05.gex
+a b c = triangle a b c; h = orthocenter h a b c; o = circumcenter o a b c; c1 = circumcenter c1 a b h; b1 = circumcenter b1 a h c; a1 = circumcenter a1 b h c ? perp a1 o b1 c1
+examples/complete2/011/complete_003_6_GDD_FULL_21-40_34.gex
+a b c = triangle a b c; h = orthocenter h a b c; o = circle o h b c; p = on_tline p h c h, on_circle p o b ? para a h b p
+examples/complete2/011/complete_004_6_GDD_FULL_81-109_99.gex
+a b c = triangle a b c; m = free m; n = on_aline n a c b a m; q = foot q m a b; p = foot p m a c ? perp a n p q
+examples/complete2/011/complete_003_6_GDD_FULL_21-40_35.gex
+a b c = triangle a b c; d = foot d c a b; e = foot e b a c; o = circle o a b c; k = on_circle k o c, on_line k c d; h = on_line h c d, on_line h b e ? cong a k a h
+examples/complete2/011/complete_003_6_GDD_FULL_21-40_31.gex
+a b c = triangle a b c; c1 = midpoint c1 b a; b1 = midpoint b1 c a; o = circle o a b c; p = on_line p o c1, on_line p a c; q = on_line q o b1, on_line q a b ? cyclic q b c p
+examples/complete2/011/complete_002_6_GDD_FULL_41-60_41.gex
+a b c = triangle a b c; i = incenter i a b c; y = foot y i a c; l = foot l i b c; x = foot x b a i ? coll x y l
+examples/complete2/011/complete_002_6_GDD_FULL_41-60_43.gex
+c a b = r_triangle c a b; f e = square a b f e; p = on_line p b e, on_line p a f ? eqangle c a c p c p c b
+examples/complete2/011/complete_002_6_GDD_FULL_41-60_51.gex
+a b c = triangle a b c; o = circle o a b c; d = on_tline d b a c, on_circle d o a; e = on_circle e o d, on_line e d o ? para b e a c
+examples/complete2/011/complete_002_6_GDD_FULL_41-60_44.gex
+a b c = triangle a b c; o = circle o a b c; d = on_circle d o a; a1 = on_tline a1 a a b, on_line a1 c d; c1 = on_tline c1 c c d, on_line c1 a b ? para d b a1 c1
+examples/complete2/010/complete_004_6_GDD_FULL_21-40_29.gex
+a b c = triangle a b c; d = foot d a b c; q = foot q d a b; p = foot p d a c ? cyclic b q p c
+examples/complete2/010/complete_002_6_GDD_FULL_01-20_10.gex
+a b c d = quadrangle a b c d; e = on_line e b c, on_line e a d; o1 = circle o1 c d e; o = circle o e b a; p = on_line p c d, on_line p a b; q = on_circle q o1 c, on_circle q o a ? cyclic p d q a
+examples/complete2/010/complete_013_7_Book_00EE_10_E072-15.gex
+b c a = triangle b c a; d = lc_tangent d c a, lc_tangent d b a; e = on_circle e a c, on_dia e a d ? eqangle b e b a b a b c
+examples/complete2/010/complete_011_7_Book_00EE_04_E051-6.gex
+a b c = triangle a b c; d = eq_triangle d c a; e = eq_triangle e b a ? cong d e c b
+examples/complete2/010/complete_012_7_Book_00EE_05_E051-20.gex
+a b = segment a b; d = midpoint d a b; c = on_tline c b a b; e = on_line e a c, on_circle e d b; f = lc_tangent f e d, on_line f b c ? cong f c f b
+examples/complete2/010/complete_011_7_Book_00EE_03_E037-20.gex
+a b = segment a b; c = midpoint c a b; d = on_circle d c a; e = lc_tangent e d c, angle_mirror e b a d ? perp a e e d
+examples/complete2/010/complete_012_7_Book_00EE_11_E076-32.gex
+c a b = r_triangle c a b; d = midpoint d b c; e = foot e c a d ? eqangle a b b c d e e b
+examples/complete2/010/complete_000_3_JAR_JAR02-new_fig214.gex
+a b c = triangle a b c; d = intersection_pp d a b c c a b; e = intersection_ll e a c b d ? cong a e e c
+examples/complete2/010/complete_003_6_GDD_FULL_more_E021-3.gex
+a b = segment a b; c = on_circle c a b; e = intersection_lc e a a c; d = on_tline d c a c, on_tline d b a b ? para a d b e
+examples/complete2/010/complete_013_7_Book_00EE_10_E074-22.gex
+a b = segment a b; c = on_circle c a b; d = on_line d a c; e = on_line e a b, on_circle e a d; f = on_line f b d, on_line f c e ? eqangle a b a f a f a c
+examples/complete2/010/complete_001_6_GDD_FULL_01-20_20.gex
+a b c = triangle a b c; d = foot d a b c; e = foot e b a c; h = on_line h a d, on_line h b e; g = foot g h a b ? eqangle g e g h g h g d
+examples/complete2/010/complete_002_6_GDD_FULL_41-60_57.gex
+a b c = triangle a b c; d = foot d a b c; o = midpoint o a d; e = on_line e a b, on_circle e o d; f = on_line f a c, on_circle f o d ? cyclic b c e f
+examples/complete2/010/complete_010_Other_Auxiliary_ye_aux_ppara.gex
+a b c d = eq_trapezoid a b c d; e = on_pline e b a d, on_line e c d ? eqangle a d a b b a b c
+examples/complete2/003/complete_003_6_GDD_FULL_more_E013-3.gex
+a b = segment a b; d = on_tline d b a b; e = on_circle e a b; f = on_line f d e, on_circle f a b; g = midpoint g e f; c = on_circle c a b, on_dia c d a; h = intersection_lc h g a c ? para e f b h
+examples/complete2/003/complete_005_Other_ndgs_01.gex
+b c a = triangle b c a; d = intersection_cc d b a c; e = on_circle e b c; g = intersection_lc g e a d; f = on_circle f b c; h = intersection_lc h f a c ? para g h e f
+examples/complete2/003/complete_013_7_Book_00EE_10_E072-12.gex
+b a c = triangle b a c; d = on_circle d a b, on_circle d c b; e = on_tline e d b d, on_circle e a b; f = on_circle f c d, on_line f d e; h = on_circle h a b, on_line h b f; g = on_circle g c b, on_line g b e ? eqangle d h d b d b d g
+examples/complete2/003/complete_010_Other_Auxiliary_ye_aux_wang3.gex
+a b c d = isquare a b c d; f = angle_bisector f a d b, on_line f a c; g = foot g c d f; e = on_line e b d, on_line e a c; h = on_line h c g, on_line h a d; i = on_line i b d, on_line i c g; x = midpoint x a h ? cong a x e i
+examples/complete2/003/complete_003_6_GDD_FULL_more_E022-8.gex
+b a c = triangle b a c; d = on_circle d a b, on_circle d c b; e = on_circle e c b; f = intersection_lc f e a d; g = intersection_lc g e a b; h = on_tline h e c e ? para h e g f
+examples/complete2/003/complete_008_ex-gao_ex160_206.gex
+a b c = triangle a b c; e d = square b a e d; f g = square a c f g; h = on_line h b e, on_line h a d; i = on_pline i e a g, on_pline i g a e ? perp c h h i
+examples/complete2/003/complete_013_7_Book_00EE_11_E077-38.gex
+a b c = triangle a b c; d = circumcenter d a b c; e = lc_tangent e b d; f = angle_bisector f e b c, on_circle f d a; g = foot g f b c; h = foot h f b e ? eqangle b a a f f a a c
+examples/complete2/003/complete_004_6_GDD_FULL_81-109_84.gex
+a b c = triangle a b c; d = midpoint d b a; e = midpoint e c b; f = midpoint f a c; g = circle g d e f; h = on_tline h e e g, on_line h a b; i = on_line i e h, on_line i a c ? cyclic b h c i
+examples/complete2/003/complete_003_6_GDD_FULL_more_E022-10.gex
+a b = segment a b; c = on_circle c a b; e = on_circle e a b; d = on_circle d a b; f = on_line f c e, on_line f b d; g = circumcenter g e f b; h = on_tline h f f g ? para h f c d
+examples/complete2/003/complete_011_7_Book_00EE_03_E037-25.gex
+a b = segment a b; c = midpoint c b a; d = on_tline d c a b, on_circle d c a; e = on_circle e c d, on_line e d c; f = on_line f a b; g = on_line g c d, on_circle g c f; h = on_circle h c e, on_line h e f; i = on_line i b g, on_circle i c a ? perp e h b i
+examples/complete2/003/complete_016_7_Book_00EE_06_E051-25.gex
+a b c = triangle a b c; d = foot d b a c; e = foot e c a b; g = circumcenter g b c a; h = intersection_lc h g g a; f = on_line f b d, on_line f c e; i = on_line i b c, on_line i f h ? cong f i i h
+examples/complete2/003/complete_013_7_Book_00EE_10_E074-20.gex
+a b c = triangle a b c; d = on_line d a b; e = foot e d b c; f = foot f e a b; g = on_line g b c; h = foot h g a b; i = foot i h b c ? eqangle d g d h f i f d
+examples/complete2/003/complete_017_ex-gao_ex160_4_003.gex
+a b = segment a b; c = on_circle c a b; e = on_line e b c; d = on_tline d c a c, on_tline d b a b; f = on_tline f e a e, on_line f c d; g = on_line g e f, on_circle g a b; h = on_line h e f, on_line h b d ? cong c f h b
+examples/complete2/003/complete_015_7_Book_00EE_08_E059-56.gex
+a b c = triangle a b c; d = foot d b a c; e = foot e a b c; f = on_line f b d, on_line f a e; g = circle g b f a; h = on_line h b c, on_circle h g a; i = on_line i a c, on_circle i g a ? cong f c f i
+examples/complete2/003/complete_014_7_Book_00EE_07_E059-52.gex
+a b = segment a b; d = on_circle d a b; c = on_tline c a a b, on_circle c a b; e = on_tline e c a c, on_tline e b a b; f = lc_tangent f d a, on_line f c e; g = on_line g b e, on_line g d f; h = on_line h c e, on_line h b d ? cong h e d g
+examples/complete2/004/complete_002_6_GDD_FULL_01-20_13.gex
+a b c = triangle a b c; d = parallelogram a b c d; e = foot e b a c; f = foot f a b d; g = foot g d a c; h = foot h c b d ? para e f g h
+examples/complete2/004/complete_006_Other_Auxiliary_E092-5.gex
+a b c = triangle a b c; d = parallelogram a b c d; e = angle_bisector e d a b, on_dia e a d; f = foot f b a e; g = foot g c b f; h = on_line h d e, on_line h c g ? para e g a b
+examples/complete2/004/complete_004_6_GDD_FULL_81-109_86.gex
+a b c = triangle a b c; d = midpoint d c a; e = midpoint e b c; f = midpoint f a b; g = angle_bisector g a b c, on_line g d f; h = on_line h b g, on_line h d e ? cong d g d h
+examples/complete2/004/complete_011_7_Book_00EE_03_E037-26.gex
+a b c d = isquare a b c d; e = on_line e b c; g = on_line g d c, on_line g a e; f = on_line f b d, on_line f a e; h = circle h g e c ? perp f c c h
+examples/complete2/004/complete_016_7_Book_00EE_06_E051-27.gex
+a b = segment a b; c = midpoint c b a; d = on_circle d c a; e = angle_bisector e d c a, on_circle e c a; f = foot f e a b; g = intersection_ll g a d e f; h = intersection_ll h a d b e ? cong a g g e
+examples/complete2/004/complete_001_6_GDD_FULL_61-80_73.gex
+a b c = triangle a b c; d = circle d a b c; e = on_circle e d a; f = foot f e a c; g = foot g e a b; h = on_circle h d e, on_line h e g ? para g f h c
+examples/complete2/004/complete_014_7_Book_00EE_07_E057-42.gex
+a b c = triangle a b c; d = midpoint d a c; e = midpoint e b a; f = midpoint f c b; g = on_line g a b; h = on_pline h d f g, on_line h a b ? cong h a g e
+examples/complete2/005/complete_005_Other_ndgs_03.gex
+b a c = triangle b a c; d = foot d b a c; e = foot e c a b; f = midpoint f c b; g = foot g f d e ? cong g e g d
+examples/complete2/005/complete_000_rebuilt_example_9point.gex
+a b c = triangle a b c; d = foot d a b c; e = midpoint e b a; f = midpoint f c b; g = midpoint g a c; o = circumcenter o e f g ? cyclic d g e f
+examples/complete2/005/complete_013_7_Book_00EE_11_E081-2.gex
+a b = segment a b; d = on_circle d a b; c = on_circle c a b, on_circle c b d; e = foot e d b c; f = intersection_lc f e a d; g = on_line g d e, on_circle g e f ? cong f c g d
+examples/complete2/005/complete_002_6_GDD_FULL_41-60_58.gex
+a b c = triangle a b c; d = circle d a b c; e = on_circle e d a; f = on_line f a b, on_line f c e; g = on_pline g f a e, on_line g b c ? eqangle f g f b c f c b
+examples/complete2/005/complete_016_7_Book_00EE_06_E051-26.gex
+a b = segment a b; c = on_circle c a b; e = on_line e b c; d = lc_tangent d b a, lc_tangent d c a; f = on_tline f e a e, on_line f c d; g = on_line g e f, on_line g b d ? cong g e e f
+examples/complete2/005/complete_001_6_GDD_FULL_61-80_61.gex
+a b c = triangle a b c; e = midpoint e b a; d = circle d a b c; f = on_line f d e; g = on_line g b c, on_circle g f a ? simtri a d f a c g
+examples/complete2/005/complete_017_ex-gao_ex160_4_e03a_lratio.gex
+c a b = iso_triangle c a b; e = midpoint e b c; f = on_line f a b, on_circle f e b; d x = trisegment d x c b; g = on_line g c f, on_line g a d ? cong c g g f
+examples/complete2/005/complete_008_ex-gao_ex160_e122.gex
+a b = segment a b; c = on_circle c a b; d = on_circle d a b; e = on_circle e a b, on_pline e d b c; f = on_circle f a b; g = on_circle g a b, on_pline g d c f ? para g b e f
+examples/complete2/002/complete_007_7_Book_LLL_yL251-1.gex
+a d b = triangle a d b; c = free c; e = on_line e a d; f = on_line f a b; g = on_line g a c; h = on_line h a d; i = on_line i a c, on_pline i h e g; j = on_line j a b, on_pline j i f g ? para e f h j
+examples/complete2/002/complete_017_ex-gao_ex160_4_e12.gex
+a b c d = quadrangle a b c d; e = midpoint e c b; f = midpoint f d c; g = midpoint g a d; h = midpoint h b a; i = on_line i e g, on_line i f h ? midp i h f
+examples/complete2/002/complete_013_7_Book_00EE_10_E073-18.gex
+a b c = triangle a b c; d = parallelogram a b c d; e = on_line e b d; f = foot f e a b; g = foot g e b c; h = on_line h e f, on_line h c d; i = on_line i e g, on_line i a d ? para h i g f
+examples/complete2/002/complete_011_7_Book_00EE_03_E043-3.gex
+a b = segment a b; c = on_circle c a b; f = on_circle f a b; e = on_line e b c, on_dia e f a; g = intersection_lc g e a f; d = lc_tangent d b a, lc_tangent d c a; h = on_line h c d, on_line h e f; i = on_line i e f, on_line i b d ? cong c h b i
+examples/complete2/002/complete_012_7_Book_00EE_02_E028-2-1.gex
+a b c = triangle a b c; e d = square a c e d; f g = square c b f g; h = midpoint h a e; i = midpoint i b g; j = midpoint j a b ? perp h j j i
+examples/complete2/002/complete_008_ex-gao_ex160_e124.gex
+b a c = triangle b a c; e = on_circle e a b; d = on_circle d a b, on_circle d c b; h = on_tline h e a e, on_circle h c b; g = on_circle g c d, on_line g d e; f = on_circle f c b, on_line f b e; i = on_circle i c h, on_line i h e ? para g f h i
+examples/complete2/000/complete_004_6_GDD_FULL_81-109_106.gex
+q4 q1 q3 q0 q2 = pentagon q4 q1 q3 q0 q2; p0 = on_line p0 q4 q1, on_line p0 q0 q2; p4 = on_line p4 q4 q1, on_line p4 q3 q0; p3 = on_line p3 q3 q0, on_line p3 q4 q2; p2 = on_line p2 q1 q3, on_line p2 q4 q2; p1 = on_line p1 q1 q3, on_line p1 q0 q2; o0 = circle o0 q0 p0 p4; o1 = circle o1 p1 q1 p0; o4 = circle o4 p4 p3 q4; o3 = circle o3 p3 p2 q3; o2 = circle o2 p1 p2 q2; m0 = on_circle m0 o0 q0, on_circle m0 o1 q1; m4 = on_circle m4 o0 q0, on_circle m4 o4 q4; m3 = on_circle m3 o4 q4, on_circle m3 o3 q3; m2 = on_circle m2 o3 q3, on_circle m2 o2 q2; m1 = on_circle m1 o2 q2, on_circle m1 o1 q1 ? cyclic m4 m3 m2 m1
+examples/complete2/unsolved2/complete_010_Other_Auxiliary_ye_aux_think2.gex
+c a b = iso_triangle c a b; d = on_line d a c; e = on_line e b c, eqdistance e b d a; f = on_line f a b, on_line f d e; g = on_pline g f a c, on_line g b c ? midp f d e
+examples/complete2/unsolved2/complete_012_7_Book_00EE_02_E023-21.gex
+a b = segment a b; c = on_tline c b a b; d = on_circle d a b; f = midpoint f c b; g = on_line g d f, on_circle g a b; h = intersection_lc h c a g; e = on_line e c d, on_circle e a b ? para b c h e
+examples/complete2/unsolved2/complete_006_7_Book_LLL_yL252-6.gex
+a c d = triangle a c d; b = on_pline b c d a, on_pline b a d c; e = on_line e a c; g = on_line g a b, on_pline g e a d; f = on_line f a d, on_pline f e c d; h = on_line h e g, on_line h c d; i = on_line i b c, on_line i e f ? para f g h i
+examples/complete2/unsolved2/complete_015_7_Book_00EE_08_E059-59.gex
+a b c = triangle a b c; d = angle_bisector d b a c; e = on_pline e c b d, on_pline e b c d; f = on_line f b e, on_line f a c; g = on_line g c e, on_line g a b ? cong b g c f
+examples/complete2/unsolved2/complete_013_7_Book_00EE_10_E072-16.gex
+a b c = triangle a b c; d = parallelogram a b c d; e = on_line e c d; f = on_line f a d, eqdistance f c a e; g = on_line g a e, on_line g c f ? eqangle g a g b g b g c
+examples/complete2/unsolved2/complete_003_6_GDD_FULL_more_E023-19.gex
+c a b = r_triangle c a b; d = foot d c a b; e = on_line e c d, angle_bisector e b a c; f = on_line f a b, angle_bisector f d c b; g = on_line g b c, on_line g a e ? para e f c b
+examples/complete2/unsolved2/complete_010_Other_Auxiliary_ye_aux_ll43.gex
+a b = segment a b; c = on_dia c a b, on_bline c a b; d = midpoint d a c; e = foot e c b d; f = on_line f c e, on_line f a b ? eqangle d c d b d f d a
+examples/complete2/unsolved2/complete_010_Other_Auxiliary_aux2_22.gex
+c a b = iso_triangle c a b; d = on_line d a c; e = on_line e b c, eqdistance e b a d; f = on_line f a b, on_line f d e ? cong d f e f
+examples/complete2/unsolved2/complete_014_7_Book_00EE_09_E066-04.gex
+a b = segment a b; c = lc_tangent c b a; d = midpoint d b c; e = on_circle e a b; f = on_line f d e, on_circle f a b ? eqangle e c c d d f f c
+examples/complete2/unsolved2/complete_014_7_Book_00EE_08_E061-66.gex
+a b = segment a b; c = s_angle b a c 60; d = foot d a b c; e = foot e b a c; g = circumcenter g b c a; f = on_line f a d, on_line f b e ? cong a f a g
+examples/complete2/unsolved2/complete_011_7_Book_00EE_03_E037-24.gex
+a b c = triangle a b c; d = circle d b a c; e = lc_tangent e a d, on_line e b c; f = angle_bisector f b e a, on_line f a b; g = on_line g a c, on_line g e f; h = angle_bisector h b a c, on_line h b c ? perp f e a h
+examples/complete2/unsolved2/complete_014_7_Book_00EE_08_E061-65.gex
+a b c d = isquare a b c d; e = s_angle c d e 15, s_angle d c e -15; f = reflect f e a c ? contri e a b a b e
+examples/complete2/unsolved2/complete_012_7_Book_00EE_11_E076-31.gex
+a b c = triangle a b c; d = angle_bisector d c b a, on_line d a c; e = angle_bisector e a c b, on_line e a b; f = on_line f d e, on_line f b c; g = on_line g a b ? eqangle a g a f a f a c
+examples/complete2/unsolved2/complete_010_Other_Auxiliary_ye_aux_y1.gex
+a b c = triangle a b c; d = angle_bisector d a b c, on_dia d b c; e = angle_bisector e b a c, on_dia e a c ? para d e a b
+examples/complete2/unsolved2/complete_004_6_GDD_FULL_21-40_40.gex
+a b c = triangle a b c; i = incenter i a b c; e = on_pline e i a b, on_line e a c ? cong e i e a
+examples/complete2/unsolved2/complete_014_7_Book_00EE_09_E069-8.gex
+a b c = triangle a b c; d = parallelogram a b c d; e = eqangle2 e d a b ? eqangle d a a e e c c d
+examples/complete2/unsolved2/complete_011_7_Book_00EE_04_E051-9.gex
+a b = segment a b; c = s_angle b a c 30; d = mirror d b c; e = foot e d a b ? cong d e a c
+examples/complete2/unsolved2/complete_003_6_GDD_FULL_21-40_27.gex
+a b c = triangle a b c; h = orthocenter h a b c; o = circumcenter o a b c; o3 = circumcenter o3 a h b; o1 = circumcenter o1 b h c; o2 = circumcenter o2 c h a ? cong h o1 h o2
+examples/complete2/unsolved2/complete_017_ex-gao_ex160_4_e08.gex
+a b c = triangle a b c; d = on_line d b c, angle_bisector d b a c; e = on_pline e d a c, on_line e a b; f = on_pline f e b c, on_line f a c ? cong e a f c
+examples/complete2/unsolved2/complete_015_7_Book_00EE_06_E051-29.gex
+a b = segment a b; c = on_circle c a b; d = on_circle d a b; e = on_circle e a b; f = on_line f b e, on_line f c d; g = on_line g d e, on_pline g f b c; h = on_circle h a b, on_dia h g a ? cong f g g h
+examples/complete2/unsolved2/complete_002_6_GDD_FULL_41-60_42.gex
+a b c = triangle a b c; d = incenter d a b c; e = foot e a b c; f = foot f b a d; g = foot g c a d; h = midpoint h c b ? cyclic e f g h
+examples/complete2/unsolved2/complete_014_7_Book_00EE_08_E061-63f.gex
+a b = segment a b; c = midpoint c b a; d = s_angle b a d 30, on_circle d c a; e = lc_tangent e d c, on_line e a b ? cong d a d e
+examples/complete2/unsolved2/complete_007_7_Book_LLL_yL198-1.gex
+c d = segment c d; e = midpoint e c d; b = free b; f = midpoint f b c; a = eqdistance a d c b, on_pline a b d c; g = midpoint g a b; h = midpoint h d a ? cong h e e f
+examples/complete2/unsolved/complete_015_7_Book_00EE_08_E061-61.gex
+a b = segment a b; c = on_circle c a b; d = on_circle d a b; e = lc_tangent e c a, lc_tangent e d a; f = lc_tangent f b a, on_line f c e; h = on_pline h c b f, on_line h b d; g = on_line g d e, on_line g b f; i = on_line i b e, on_line i c h ? cong c i i h
+examples/complete2/unsolved/complete_008_ex-gao_ex160_204.gex
+a b c = triangle a b c; d = circumcenter d a b c; e = on_circle e d a; f = on_line f a b, on_line f c e; h = on_line h b c, angle_bisector h a f c; g = on_line g a e, on_line g b c; i = on_line i a b, angle_bisector i a g b; j = on_line j f h, on_line j g i; k = on_line k a e, on_line k f h ? perp g i f h
+examples/complete2/unsolved/complete_005_Other_unsolved_65.gex
+a b c = triangle a b c; e = on_line e a b; f = on_pline f e b c, on_line f a c; d = circle d a b c; g = circle g a e f ? coll a g d
+examples/complete2/unsolved/complete_008_ex-gao_ex160_005.gex
+a b c = triangle a b c; d = on_line d b c, angle_bisector d b a c; e = on_line e a b; f = on_line f a c, eqdistance f c b e; g = midpoint g f e; h = midpoint h c b ? para g h a d
+examples/complete2/unsolved/complete_006_Other_ndgTest_65.gex
+a b c = triangle a b c; e = on_line e a b; f = intersection_lp f a c e c b; d = circle d a b c; g = circle g a e f ? coll a g d
+examples/complete2/unsolved/complete_005_Other_unsolved_E051-7.gex
+a b c = triangle a b c; d = on_line d a b; e = angle_bisector e c b a, on_line e a c; f = on_pline f e a b, on_line f b c; g = angle_bisector g c b d, on_line g e f ? cong e f f g
+examples/complete2/unsolved/complete_005_Other_unsolved_E046-10.gex
+a b c d = isquare a b c d; e = midpoint e b a; f = on_line f a b; g = on_tline g e d e, angle_bisector g c b f ? cong d e e g
+examples/complete2/unsolved/ex-gao_ex160_103.gex
+c b y = triangle c b y; a = foot a c b y; x = angle_bisector x c b y; d = foot d a b c; e = on_line e b x, on_line e c a; f = foot f e b c; g = on_line g b x, on_line g a d ? cong f g f e
+examples/complete2/unsolved/ex-gao_ex160_104.gex
+c a y = triangle c a y; b = foot b c a y; x = angle_bisector x c a y; e = foot e b a c; d = on_line d a x, on_line d c b; f = on_line f a x, on_line f b e; g = on_line g c b, on_pline g f a c ? cong b d c g
+examples/complete2/unsolved/complete_005_Other_unsolved_109f.gex
+a b d = triangle a b d; e = on_line e a d; c = on_line c a b; f = on_line f b e, on_line f c d; g = circle g d e f; h = circle h a c d; i = circle i b c f; j = circle j b a e ? cyclic i j h g
+examples/complete2/unsolved/complete_005_Other_unsolved_E046-7.gex
+a b c = triangle a b c; d = midpoint d c a; e = angle_bisector e b a d, on_line e b d; f = on_pline f b c e, on_line f a c ? cong b a c f
+examples/complete2/unsolved/complete_008_ex-gao_ex160_e121.gex
+a b = segment a b; d = midpoint d b a; c = on_tline c a a b; e = on_circle e c a; f = on_line f d e, on_circle f c a; g = on_circle g c f, on_line g f b; h = on_line h b e, on_circle h c a ? para a b g h
+examples/complete2/unsolved/complete_018_ex-gao_ex160_4_010.gex
+a b c d = isquare a b c d; e = mirror e a b; f = midpoint f b a; g = on_tline g f d f, angle_bisector g c b e; h = foot h g a b ? cong d f g f
+examples/complete2/unsolved/complete_005_Other_unsolved_82.gex
+a b c = triangle a b c; o = incenter o a b c; i = foot i c a o; e = on_tline e a a o; j = foot j c a e; l = foot l c b o ? coll i l j
+examples/complete2/unsolved/complete_014_7_Book_00EE_07_E057-41.gex
+a b c = triangle a b c; d = foot d c a b; e = free e; f = on_circle f c e; g = on_line g d f, on_circle g c e; h = on_line h d e, on_circle h c e; i = on_line i f h, on_line i a b; j = on_line j e g, on_line j a b ? cong j d d i
+examples/complete2/unsolved/complete_015_7_Book_00EE_08_E059-55.gex
+a b = segment a b; c = on_circle c a b; d = lc_tangent d b a, lc_tangent d c a; e = on_circle e a b; f = on_line f d e, on_circle f a b; g = angle_bisector g f b e, on_line g d e ? cong d b d g
+examples/complete2/unsolved/complete_005_Other_unsolved_E073-17.gex
+a b c = triangle a b c; o = circumcenter o a b c; p = lc_tangent p a o, on_line p b c; d = on_circle d p a; e = intersection_lc e d o b; f = intersection_lc f d o c ? para e f p d
+examples/complete2/unsolved/complete_015_7_Book_00EE_06_E056-33.gex
+a b = segment a b; c = on_tline c a a b, on_circle c a b; e = s_angle b a e 60, on_circle e a b; d = s_angle b a d 30, on_circle d a b; f = on_line f a e, on_line f b c; g = on_line g a d, on_line g b c ? cong c f g b
+examples/complete2/unsolved/complete_005_Other_unsolved_E074-24.gex
+a b = segment a b; c = on_tline c a a b; d = foot d a b c; e = midpoint e d a; f = on_line f b e, on_line f a c; g = foot g f b c; h = midpoint h c a; i = on_tline i f a c, on_circle i h a ? cong f i f g
+examples/complete2/unsolved1/complete_008_7_Book_LLL_L057-3.gex
+a b = segment a b; c = on_bline c a b; e = midpoint e a c; d = mirror d c a; f = midpoint f b d ? cong e b f b
+examples/complete2/unsolved1/complete_006_7_Book_LLL_L046-17.gex
+c a b = risos c a b; d = midpoint d b a; e = on_line e a b; f = foot f e a c; g = foot g e b c ? cong d f d g
+examples/complete2/unsolved1/complete_008_7_Book_LLL_L057-2.gex
+c a b = triangle a b c; d = angle_bisector d b a c; e = foot e c a d; f = intersection_lp f a c e a b ? cong f e f c
+examples/complete2/unsolved1/complete_008_ex-gao_ex160_e102.gex
+a b c = triangle a b c; d = on_line d a c, angle_bisector d c b a; e = on_line e a b, angle_bisector e b c a; f = foot f a c e; g = foot g a b d ? para g f b c
+examples/complete2/unsolved1/complete_012_7_Book_00EE_11_E075-27f.gex
+a b c = triangle a b c; d = foot d c a b; e = on_line e c d; f = on_line f b e, on_line f a c; g = on_line g a e, on_line g b c ? eqangle d f d c d c d g
+examples/complete2/unsolved1/complete_006_7_Book_LLL_L091-13.gex
+b c d = triangle b c d; e = midpoint e c d; a = eqdistance a d c b, on_pline a b d c; f = midpoint f b a ? perp a b e f
+examples/complete2/unsolved1/complete_010_Other_gao_Y_yL157-1.gex
+a b d = triangle a b d; e = midpoint e d a; c = angle_bisector c a b d, on_dia c a b ? para c e b d
+examples/complete2/unsolved1/complete_008_7_Book_LLL_L055-5.gex
+d b a = triangle d b a; c = angle_bisector c d a b, angle_bisector c d b a; e = on_line e b c, on_tline e d b c; f = on_line f a c, on_tline f d a c ? para e f a b
+examples/complete2/unsolved1/complete_013_7_Book_00EE_11_E075-29.gex
+a b = segment a b; d = midpoint d b a; f = on_circle f d a; c = intersection_lt c a b f d f; e = midpoint e c a; g = on_tline g b a b, on_circle g e a ? eqangle f c f g g f g c
+examples/complete2/unsolved1/complete_012_7_Book_00EE_05_E051-14-1.gex
+a b c d = quadrangle a b c d; e = midpoint e b a; f = foot f a c d; g = foot g b c d ? cong e f e g
+examples/complete2/unsolved1/complete_007_7_Book_LLL_L057-3-1.gex
+a b = segment a b; c = on_bline c a b; e = midpoint e a c; f = mirror f b e; d = on_circle d a c, on_line d a c ? cong f b b d
+examples/complete2/unsolved1/complete_001_6_GDD_FULL_61-80_80.gex
+a b c = triangle a b c; o = circle o a b c; u = angle_bisector u b a c, on_line u b c; t = on_tline t a a o, on_line t b c ? cong t a t u
+examples/complete2/unsolved1/complete_008_ex-gao_ex160_e213.gex
+a b c = triangle a b c; d = midpoint d a b; e = midpoint e c a; f = on_line f d e, angle_bisector f c b a ? perp a f b f
+examples/complete2/unsolved1/complete_011_7_Book_00EE_04_E051-2.gex
+a b c = triangle a b c; d = on_line d a b; e = on_pline e d b c, on_line e a c; f = on_line f c d, on_line f b e; g = on_line g a f, on_line g b c ? midp g b c
+examples/complete2/unsolved1/complete_007_7_Book_LLL_L043-5.gex
+a b = segment a b; c = on_circle c a b; d = on_circle d a b; e = on_circle e a b; f = intersection_ll f b c d e; g = intersection_ll g c d b e; h = angle_bisector h d f b; i = angle_bisector i c g b; j = intersection_ll j f h g i ? perp g i f h
+examples/complete2/unsolved1/complete_001_6_GDD_FULL_61-80_71.gex
+a b c = triangle a b c; o = circle o a b c; e = on_pline e a b c, on_circle e o a; f = foot f e a b; g = foot g e a c ? para f g a o
+examples/complete2/unsolved1/complete_007_7_Book_LLL_L043-5-1.gex
+a b = segment a b; c = on_circle c a b; d = on_circle d a b; e = on_circle e a b; f = intersection_ll f b c d e; g = intersection_ll g c d b e; h = angle_bisector h d f b; i = angle_bisector i c g b; j = intersection_ll j f h g i; k = intersection_ll k d e g i; l = intersection_ll l g i b c ? perp g i f h
+examples/complete2/unsolved1/complete_011_7_Book_00EE_04_E051-8.gex
+a b c = triangle a b c; d = angle_bisector d a c b, on_line d a b; e = on_pline e d b c, on_line e a c; f = on_pline f e a b, on_line f b c ? cong c e f b
+examples/complete2/unsolved1/complete_013_7_Book_00EE_10_E072-8.gex
+a b c = triangle a b c; d = angle_bisector d b a c, on_line d b c; f = on_line f b c, on_bline f a d; e = on_bline e a d, on_line e a d ? eqangle a b a f c f c a
+examples/complete2/unsolved1/complete_003_6_GDD_FULL_more_E023-14.gex
+a b c = triangle a b c; d = midpoint d b a; e = angle_bisector e c d a, on_line e a c; f = angle_bisector f c d b, on_line f c b ? para e f a b
+examples/complete2/unsolved1/complete_010_Other_gao_Y_yL182-1.gex
+a c d = triangle a c d; b = on_pline b c d a, on_pline b a d c; e = on_line e a c; f = shift f c a e ? para d e f b
+examples/complete2/unsolved1/complete_008_ex-gao_ex160_e120.gex
+a b = segment a b; c = midpoint c b a; d = on_circle d c a; e = on_tline e a a b, on_tline e d c d; f = on_tline f b a b, on_line f d e; g = on_line g b e, on_line g a f ? para d g a e
+new_unsolved/0.gex
+c d b = triangle c d b; e = midpoint e c d; a = eqdistance a d c b, on_pline a b d c; f = midpoint f b a ? perp a b e f
+new_unsolved/1.gex
+a b c d = eq_trapezoid a b c d ? eqangle a d a b b a b c
+examples/complete2/unsolved1/complete_009_Other_paper_Thebault_t5.gex
+a b c = triangle a b c; d = circle d a b c; e = on_line e b c; f g h i = 2l1c f g h i a b e d; j k l m = 2l1c j k l m a c e d; n = incenter n a b c ? coll m n i
+examples/complete2/unsolved/complete_013_7_Book_00EE_10_E072-11.gex
+a b = segment b a; c = on_line c a b; d = on_circle d a b; e = on_circle e a b; g = on_line g d e, on_circle g c b; f = on_line f d e, on_circle f c b ? eqangle b e b f b g b d
+examples/complete2/unsolved2/complete_015_7_Book_00EE_06_E051-28.gex
+b c = segment b c; a = on_tline a b b c; d = on_circle d c b; e g = e5128 e g a b c d ? cong a g g b
+examples/complete2/unsolved2/complete_010_Other_Auxiliary_ye_aux_think.gex
+c a b = iso_triangle c a b; d e f = 3peq d e f c a b ? cong d a b e
+examples/complete2/unsolved/morley.gex
+a b c = triangle a b c; d e = trisect d e b a c; f g = trisect f g c b a; h i = trisect h i a c b; j = intersection_ll j b f c i; k = intersection_ll k a e c h; l = intersection_ll l a d b g ? cong j l j k

ag4masses/alphageometry/lm_inference.py

@@ -0,0 +1,189 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Wrapper for language modeling inference implemented in Meliad."""
+from typing import Any, Dict
+
+import jax
+import models  # pylint: disable=unused-import
+import t5.data
+from transformer import inference_utils
+
+
+np = jax.numpy
+
+
+Trainer = inference_utils.Trainer
+
+MetricsOutput = Dict[str, Any]  # Metrics output by model.
+
+
+parse_gin_configuration = inference_utils.parse_gin_configuration
+
+
+class LanguageModelInference:
+  """Meliad wrapper for LM inference."""
+
+  def __init__(self, vocab_path: str, load_dir: str, mode='beam_search'):
+    self.vocab = t5.data.SentencePieceVocabulary(vocab_path)
+
+    # This task won't be pulling from a dataset.
+    def null_iter_fn() -> None:
+      return None
+
+    process_summaries_f = inference_utils.models.process_summaries_function(
+        self.vocab
+    )
+
+    trainer = inference_utils.training_loop.Trainer(
+        get_training_dataset_iterator=null_iter_fn,
+        get_test_dataset_iterator=None,
+        pretty_print_input_function=None,
+        process_summaries_function=process_summaries_f,
+        load_dir=load_dir,
+        workdir='',  # Don't log or save checkpoints.
+        replicate_mode=False,
+    )  # Run on a single device at batch size 1.
+    self.trainer = trainer
+
+    # Create and initialize the model.
+    (tstate, _, imodel, prngs) = trainer.initialize_model()
+    self.imodel = imodel
+    self.batch_size = imodel.task_config.batch_size
+
+    self.n = imodel.num_heads
+    self.h = imodel.head_size
+
+    # Create an inference task.
+    writers = {}
+    self.task = trainer.create_training_task(mode, imodel, prngs, writers)  # pylint: disable=too-many-function-args
+
+    # Register any additional actions.
+    # Actions are cleared first for use with colab.
+    inference_utils.training_loop.clear_interstep_callbacks()
+    inference_utils.training_loop.register_interstep_callbacks()
+    self.tstate = tstate
+
+    # some default parameters.
+    eos = [0] * 1024
+    for idx in self.encode_list(['.', ';']):
+      eos[idx] = 1
+
+    self.eos = np.array(eos, dtype=np.bfloat16)
+    self.mask = jax.numpy.ones([1024], dtype=np.bfloat16)
+
+  def decode(self, ids: list[int]) -> str:
+    return self.vocab.decode(ids)
+
+  def decode_list(self, tokens: list[int]) -> list[str]:
+    return [self.decode([tok]) for tok in tokens]
+
+  def encode(self, inputs_str: str) -> list[int]:
+    return self.vocab.encode(inputs_str)
+
+  def encode_list(self, inputs_strs: list[str]) -> list[int]:
+    result = [self.vocab.encode(x) for x in inputs_strs]
+    assert all([len(x) == 1 for x in result]), [
+        self.decode(x) for x in result if len(x) != 1
+    ]
+    return [x[0] for x in result]
+
+  def call(
+      self,
+      inputs: np.ndarray,
+      dstate: tuple[dict[str, np.ndarray], ...] = None,
+      eos: np.ndarray = None,
+      mask: np.ndarray = None,
+  ) -> MetricsOutput:
+    """Call the meliad model."""
+    batch_size, length = inputs.shape
+    inputs = jax.numpy.pad(inputs, [(0, 0), (0, 1024 - length)])
+
+    if eos is None:
+      eos = self.eos
+    if mask is None:
+      mask = self.mask
+
+    x = {'targets': inputs, 'length': length, 'eos': eos, 'mask': mask}
+
+    if dstate is not None:
+      x['start_of_sequence'] = jax.numpy.array([False] * batch_size)
+    else:
+      dstate = tuple(
+          [{  # this dummy value will never be used.
+              'current_index': np.array([0] * batch_size, dtype=np.int32),
+              'keys': np.zeros(
+                  (batch_size, 2048, self.n, self.h), dtype=np.bfloat16
+              ),
+              'values': np.zeros(
+                  (batch_size, 2048, self.n, self.h), dtype=np.bfloat16
+              ),
+              'recurrent_kvq': None,
+              'relative_position_bias': np.zeros(
+                  (batch_size, self.n, 1, 1024), dtype=np.bfloat16
+              ),
+          }]
+          * 12
+      )
+      x['start_of_sequence'] = jax.numpy.array([True] * batch_size)
+
+    x['dstate'] = dstate
+    _, metrics_np = self.task.run_step(self.tstate, x, 0)
+    return metrics_np
+
+  def beam_decode(
+      self,
+      inputs: str,
+      eos_tokens: np.ndarray = None,
+      mask_tokens: np.ndarray = None,
+      dstate: dict[str, np.ndarray] = None,
+  ) -> MetricsOutput:
+    """Beam search."""
+    inputs = jax.numpy.array([self.vocab.encode(inputs)] * self.batch_size)
+
+    eos = self.eos
+    if eos_tokens is not None:
+      eos_ids = self.encode_list(eos_tokens)
+      eos = np.array(
+          [1 if idx in eos_ids else 0 for idx in range(1024)], dtype=np.bfloat16
+      ).reshape((1, 1, 1024))
+
+    mask = self.mask
+    if mask_tokens is not None:
+      mask_ids = self.encode_list(mask_tokens)
+      mask = np.array(
+          [0 if idx in mask_ids else 1 for idx in range(1024)],
+          dtype=np.bfloat16,
+      ).reshape((1, 1, 1024))
+
+    metrics_np = self.call(inputs, dstate=dstate, eos=eos, mask=mask)
+
+    finished_seqs = metrics_np['finished_seqs']
+    finished_scores = metrics_np['finished_scores']
+
+    seqs = []
+    scores = []
+    for seq, score in zip(finished_seqs, finished_scores):
+      seq = self.decode(seq[1:])
+      seqs.append(seq)
+      scores.append(score)
+
+    return {
+        'finished_seqs': finished_seqs,
+        'finished_scores': finished_scores,
+        'seqs_str': seqs,
+        'scores': scores,
+        'dstate': metrics_np['dstate'],
+    }

ag4masses/alphageometry/lm_inference_test.py

@@ -0,0 +1,89 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Unit tests for lm_inference.py."""
+import os
+import unittest
+
+from absl import flags
+from absl.testing import absltest
+import lm_inference as lm
+
+
+_DATA_PATH = flags.DEFINE_string('data_path', '', 'path to ckpt and vocab.')
+_MELIAD_PATH = flags.DEFINE_string(
+    'meliad_path', '', 'path to meliad repository.'
+)  # pylint: disable=line-too-long
+
+
+class LmInferenceTest(unittest.TestCase):
+
+  @classmethod
+  def setUpClass(cls):
+    super().setUpClass()
+    gin_file = [
+        'base_htrans.gin',
+        'size/medium_150M.gin',
+        'options/positions_t5.gin',
+        'options/lr_cosine_decay.gin',
+        'options/seq_1024_nocache.gin',
+        'geometry_150M_generate.gin',
+    ]
+
+    gin_param = [
+        'DecoderOnlyLanguageModelGenerate.output_token_losses=True',
+        'TransformerTaskConfig.batch_size=2',
+        'TransformerTaskConfig.sequence_length=128',
+        'Trainer.restore_state_variables=False',
+    ]
+
+    gin_search_paths = [
+        os.path.join(_MELIAD_PATH.value, 'transformer/configs'),
+        os.getcwd(),
+    ]
+
+    vocab_path = os.path.join(_DATA_PATH.value, 'geometry.757.model')
+
+    lm.parse_gin_configuration(gin_file, gin_param, gin_paths=gin_search_paths)
+
+    cls.loaded_lm = lm.LanguageModelInference(
+        vocab_path, _DATA_PATH.value, mode='beam_search'
+    )
+
+  def test_lm_decode(self):
+    outputs = LmInferenceTest.loaded_lm.beam_decode(
+        '{S} a : ; b : ; c : ; d : T a b c d 00 T a c b d 01 ? T a d b c'
+        ' {F1} x00',
+        eos_tokens=[';'],
+    )
+    self.assertEqual(
+        outputs['seqs_str'],
+        ['e : D a b c e 02 D a c b e 03 ;', 'e : C a c e 02 C b d e 03 ;'],
+    )
+
+  def test_lm_score_may_fail_numerically_for_external_meliad(self):
+    outputs = LmInferenceTest.loaded_lm.beam_decode(
+        '{S} a : ; b : ; c : ; d : T a b c d 00 T a c b d 01 ? T a d b c'
+        ' {F1} x00',
+        eos_tokens=[';'],
+    )
+    self.assertEqual(
+        outputs['scores'],
+        [-1.18607294559478759765625, -1.10228693485260009765625],
+    )
+
+
+if __name__ == '__main__':
+  absltest.main()

ag4masses/alphageometry/models.py

@@ -0,0 +1,178 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Transformer language model generate mode."""
+
+from typing import Any, Tuple
+import beam_search
+import decoder_stack
+import gin
+import jax
+import jax.numpy as jnp
+from transformer import models
+
+
+@gin.configurable
+class DecoderOnlyLanguageModelGenerate(models.DecoderOnlyLanguageModel):
+  """Decoder only language modeling in inference mode."""
+
+  decoder_factory = decoder_stack.DecoderStackGenerate
+
+  num_heads: int = gin.REQUIRED
+  head_size: int = gin.REQUIRED
+
+  def get_fake_input(self) -> dict[str, Any]:
+    fake_input_dict = super().get_fake_input()
+    b = self.task_config.batch_size
+    n = self.num_heads
+    h = self.head_size
+    fake_input_dict.update({
+        'dstate': tuple(
+            [{
+                'current_index': jnp.array([0] * b, dtype=jnp.int32),
+                'keys': jnp.zeros((b, 2048, n, h), dtype=jnp.bfloat16),
+                'values': jnp.zeros((b, 2048, n, h), dtype=jnp.bfloat16),
+                'recurrent_kvq': None,
+                'relative_position_bias': jnp.zeros(
+                    (b, n, 1, 1024), dtype=jnp.bfloat16
+                ),
+            }]
+            * 12
+        ),
+        'eos': jnp.zeros([1024], dtype=jnp.bfloat16),
+        'mask': jnp.ones([1024], dtype=jnp.bfloat16),
+        'length': 1,
+        'temperature': 1.0,
+    })
+    return fake_input_dict
+
+  def __call__(self, inputs: ...) -> tuple[Any, dict[str, Any]]:
+    # Make sure this code is not used on untested cases.
+    if self.mode not in ['init', 'beam_search']:
+      raise ValueError(f'{type(self)} cannot do mode {self.mode}')
+    if self.decoder.supports_generate():
+      raise ValueError(f'{type(self)}.decoder cannot supports_generate()')
+
+    self.decoder(
+        input_tokens=inputs['targets'][:, 0:1],
+        target_tokens=None,
+        start_of_sequence=inputs['start_of_sequence'],
+    )
+
+    b = inputs['targets'].shape[0]
+    no_start_of_seq = jnp.array([False] * b, dtype=jnp.bool_)
+
+    # This fn is used in both beam_search or topk_sampling.
+    def tokens_to_logits_fn(
+        input_token: jnp.ndarray, dstate: tuple[dict[str, jnp.ndarray], ...]
+    ) -> tuple[jnp.ndarray, tuple[dict[str, jnp.ndarray], ...]]:
+      (logits, dstate, _) = self.decoder(
+          input_tokens=input_token,
+          target_tokens=None,
+          start_of_sequence=no_start_of_seq,
+          decoder_state=dstate,
+      )
+      return logits[:, -1, :], dstate
+
+    last_token = jax.lax.dynamic_slice_in_dim(
+        inputs['targets'], inputs['length'] - 1, 1, axis=1
+    )
+
+    # last token is used to seed beam_search
+    inputs['targets'] = inputs['targets'][:, 0:-1]
+    dstate = jax.lax.cond(
+        inputs['start_of_sequence'][0],
+        lambda: self.generate(inputs)[0],
+        lambda: inputs['dstate'],
+    )
+
+    # Then we run beam search, init with last_token & dstate.
+    finished_seqs, finished_scores, dstate = beam_search.beam_search_flat(
+        last_token,
+        dstate,
+        tokens_to_logits_fn,
+        max_decode_len=512,
+        eos=inputs['eos'].reshape((1, 1, -1)),
+        mask=inputs['mask'].reshape((1, 1, -1)),
+    )
+
+    return 0.0, {
+        'finished_seqs': finished_seqs,
+        'finished_scores': finished_scores,
+        'dstate': dstate,
+    }
+
+  def generate(
+      self, inputs: ...
+  ) -> tuple[tuple[dict[str, jnp.ndarray, ...], ...], jnp.ndarray]:
+    """Generate an output sequence.
+
+    Args:
+      inputs: the same as argument to _call_.
+
+    Returns:
+      An array of generated tokens of shape (batch_size, sequence_length).
+    """
+    input_tokens = inputs['targets']  # [b,seq_len]
+    start_of_sequence = inputs['start_of_sequence']  # [b]
+    target_tokens = jnp.pad(input_tokens[:, 1:], [(0, 0), (0, 1)])
+    batch_size = target_tokens.shape[0]
+
+    # Assuming all sequences start at the same time.
+    start0 = inputs['start_of_sequence'][0]
+    dstate = jax.lax.cond(
+        start0,
+        lambda: self.decoder.init_decoder_state_vanilla(  # pylint: disable=g-long-lambda
+            1024, start_of_sequence
+        ),
+        lambda: inputs['dstate'],
+    )
+
+    first_token = input_tokens[:, 0:1]
+    no_start_of_seq = jnp.array([False] * batch_size, dtype=jnp.bool_)
+    temperature = 1
+    if 'temperature' in inputs:
+      temperature = inputs['temperature']
+
+    num_steps = inputs['length']
+    if self.mode == 'beam_search':
+      num_steps -= 1
+
+    def cond_fn(scan_state) -> jnp.bool_:
+      _, _, i, _ = scan_state
+      return i < num_steps
+
+    def loop_fn(scan_state: Any) -> Tuple[Any, Any, Any, Any]:
+      (dstate, input_token, i, _) = scan_state
+
+      (logits, dstate, _) = self.decoder(
+          input_tokens=input_token,
+          target_tokens=None,
+          start_of_sequence=no_start_of_seq,
+          decoder_state=dstate,
+      )
+
+      logits = logits / temperature
+      output_token = jax.lax.dynamic_slice_in_dim(target_tokens, i, 1, axis=1)
+
+      return (dstate, output_token, i + 1, logits)
+
+    # Scan over the sequence length.
+    dummy_logits = jnp.zeros((batch_size, 1, 1024))
+    initial_scan_state = (dstate, first_token, 0, dummy_logits)
+    dstate, _, _, logits = jax.lax.while_loop(
+        cond_fn, loop_fn, initial_scan_state
+    )
+    return dstate, logits

ag4masses/alphageometry/numericals.py

@@ -0,0 +1,1923 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Numerical representation of geometry."""
+from __future__ import annotations
+
+import math
+from typing import Any, Optional, Union
+
+import geometry as gm
+import matplotlib
+from matplotlib import pyplot as plt
+import matplotlib.colors as mcolors
+import numpy as np
+from numpy.random import uniform as unif  # pylint: disable=g-importing-member
+
+
+matplotlib.use('TkAgg')
+
+
+ATOM = 1e-12
+
+
+# Some variables are there for better code reading.
+# pylint: disable=unused-assignment
+# pylint: disable=unused-argument
+# pylint: disable=unused-variable
+
+# Naming in geometry is a little different
+# we stick to geometry naming to better read the code.
+# pylint: disable=invalid-name
+
+
+class Point:
+  """Numerical point."""
+
+  def __init__(self, x, y):
+    self.x = x
+    self.y = y
+
+  def __lt__(self, other: Point) -> bool:
+    return (self.x, self.y) < (other.x, other.y)
+
+  def __gt__(self, other: Point) -> bool:
+    return (self.x, self.y) > (other.x, other.y)
+
+  def __add__(self, p: Point) -> Point:
+    return Point(self.x + p.x, self.y + p.y)
+
+  def __sub__(self, p: Point) -> Point:
+    return Point(self.x - p.x, self.y - p.y)
+
+  def __mul__(self, f: float) -> Point:
+    return Point(self.x * f, self.y * f)
+
+  def __rmul__(self, f: float) -> Point:
+    return self * f
+
+  def __truediv__(self, f: float) -> Point:
+    return Point(self.x / f, self.y / f)
+
+  def __floordiv__(self, f: float) -> Point:
+    div = self / f  # true div
+    return Point(int(div.x), int(div.y))
+
+  def __str__(self) -> str:
+    return 'P({},{})'.format(self.x, self.y)
+
+  def close(self, point: Point, tol: float = 1e-12) -> bool:
+    return abs(self.x - point.x) < tol and abs(self.y - point.y) < tol
+
+  def midpoint(self, p: Point) -> Point:
+    return Point(0.5 * (self.x + p.x), 0.5 * (self.y + p.y))
+
+  def distance(self, p: Union[Point, Line, Circle]) -> float:
+    if isinstance(p, Line):
+      return p.distance(self)
+    if isinstance(p, Circle):
+      return abs(p.radius - self.distance(p.center))
+    dx = self.x - p.x
+    dy = self.y - p.y
+    return np.sqrt(dx * dx + dy * dy)
+
+  def distance2(self, p: Point) -> float:
+    if isinstance(p, Line):
+      return p.distance(self)
+    dx = self.x - p.x
+    dy = self.y - p.y
+    return dx * dx + dy * dy
+
+  def rotatea(self, ang: float) -> Point:
+    sinb, cosb = np.sin(ang), np.cos(ang)
+    return self.rotate(sinb, cosb)
+
+  def rotate(self, sinb: float, cosb: float) -> Point:
+    x, y = self.x, self.y
+    return Point(x * cosb - y * sinb, x * sinb + y * cosb)
+
+  def flip(self) -> Point:
+    return Point(-self.x, self.y)
+
+  def perpendicular_line(self, line: Line) -> Line:
+    return line.perpendicular_line(self)
+
+  def foot(self, line: Line) -> Point:
+    if isinstance(line, Line):
+      l = line.perpendicular_line(self)
+      return line_line_intersection(l, line)
+    elif isinstance(line, Circle):
+      c, r = line.center, line.radius
+      return c + (self - c) * r / self.distance(c)
+    raise ValueError('Dropping foot to weird type {}'.format(type(line)))
+
+  def parallel_line(self, line: Line) -> Line:
+    return line.parallel_line(self)
+
+  def norm(self) -> float:
+    return np.sqrt(self.x**2 + self.y**2)
+
+  def cos(self, other: Point) -> float:
+    x, y = self.x, self.y
+    a, b = other.x, other.y
+    return (x * a + y * b) / self.norm() / other.norm()
+
+  def dot(self, other: Point) -> float:
+    return self.x * other.x + self.y * other.y
+
+  def sign(self, line: Line) -> int:
+    return line.sign(self)
+
+  def is_same(self, other: Point) -> bool:
+    return self.distance(other) <= ATOM
+
+
+class Line:
+  """Numerical line."""
+
+  def __init__(
+      self,
+      p1: Point = None,
+      p2: Point = None,
+      coefficients: tuple[int, int, int] = None,
+  ):
+    if p1 is None and p2 is None and coefficients is None:
+      self.coefficients = None, None, None
+      return
+
+    a, b, c = coefficients or (
+        p1.y - p2.y,
+        p2.x - p1.x,
+        p1.x * p2.y - p2.x * p1.y,
+    )
+
+    # Make sure a is always positive (or always negative for that matter)
+    # With a == 0, Assuming a = +epsilon > 0
+    # Then b such that ax + by = 0 with y>0 should be negative.
+    if a < 0.0 or a == 0.0 and b > 0.0:
+      a, b, c = -a, -b, -c
+
+    self.coefficients = a, b, c
+
+  def parallel_line(self, p: Point) -> Line:
+    a, b, _ = self.coefficients
+    return Line(coefficients=(a, b, -a * p.x - b * p.y))  # pylint: disable=invalid-unary-operand-type
+
+  def perpendicular_line(self, p: Point) -> Line:
+    a, b, _ = self.coefficients
+    return Line(p, p + Point(a, b))
+
+  def greater_than(self, other: Line) -> bool:
+    a, b, _ = self.coefficients
+    x, y, _ = other.coefficients
+    # b/a > y/x
+    return b * x > a * y
+
+  def __gt__(self, other: Line) -> bool:
+    return self.greater_than(other)
+
+  def __lt__(self, other: Line) -> bool:
+    return other.greater_than(self)
+
+  def same(self, other: Line) -> bool:
+    a, b, c = self.coefficients
+    x, y, z = other.coefficients
+    return close_enough(a * y, b * x) and close_enough(b * z, c * y)
+
+  def equal(self, other: Line) -> bool:
+    a, b, _ = self.coefficients
+    x, y, _ = other.coefficients
+    # b/a == y/x
+    return b * x == a * y
+
+  def less_than(self, other: Line) -> bool:
+    a, b, _ = self.coefficients
+    x, y, _ = other.coefficients
+    # b/a > y/x
+    return b * x < a * y
+
+  def intersect(self, obj: Union[Line, Circle]) -> tuple[Point, ...]:
+    if isinstance(obj, Line):
+      return line_line_intersection(self, obj)
+    if isinstance(obj, Circle):
+      return line_circle_intersection(self, obj)
+
+  def distance(self, p: Point) -> float:
+    a, b, c = self.coefficients
+    return abs(self(p.x, p.y)) / math.sqrt(a * a + b * b)
+
+  def __call__(self, x: Point, y: Point = None) -> float:
+    if isinstance(x, Point) and y is None:
+      return self(x.x, x.y)
+    a, b, c = self.coefficients
+    return x * a + y * b + c
+
+  def is_parallel(self, other: Line) -> bool:
+    a, b, _ = self.coefficients
+    x, y, _ = other.coefficients
+    return abs(a * y - b * x) < ATOM
+
+  def is_perp(self, other: Line) -> bool:
+    a, b, _ = self.coefficients
+    x, y, _ = other.coefficients
+    return abs(a * x + b * y) < ATOM
+
+  def cross(self, other: Line) -> float:
+    a, b, _ = self.coefficients
+    x, y, _ = other.coefficients
+    return a * y - b * x
+
+  def dot(self, other: Line) -> float:
+    a, b, _ = self.coefficients
+    x, y, _ = other.coefficients
+    return a * x + b * y
+
+  def point_at(self, x: float = None, y: float = None) -> Optional[Point]:
+    """Get a point on line closest to (x, y)."""
+    a, b, c = self.coefficients
+    # ax + by + c = 0
+    if x is None and y is not None:
+      if a != 0:
+        return Point((-c - b * y) / a, y)  # pylint: disable=invalid-unary-operand-type
+      else:
+        return None
+    elif x is not None and y is None:
+      if b != 0:
+        return Point(x, (-c - a * x) / b)  # pylint: disable=invalid-unary-operand-type
+      else:
+        return None
+    elif x is not None and y is not None:
+      if a * x + b * y + c == 0.0:
+        return Point(x, y)
+    return None
+
+  def diff_side(self, p1: Point, p2: Point) -> Optional[bool]:
+    d1 = self(p1.x, p1.y)
+    d2 = self(p2.x, p2.y)
+    if d1 == 0 or d2 == 0:
+      return None
+    return d1 * d2 < 0
+
+  def same_side(self, p1: Point, p2: Point) -> Optional[bool]:
+    d1 = self(p1.x, p1.y)
+    d2 = self(p2.x, p2.y)
+    if d1 == 0 or d2 == 0:
+      return None
+    return d1 * d2 > 0
+
+  def sign(self, point: Point) -> int:
+    s = self(point.x, point.y)
+    if s > 0:
+      return 1
+    elif s < 0:
+      return -1
+    return 0
+
+  def is_same(self, other: Line) -> bool:
+    a, b, c = self.coefficients
+    x, y, z = other.coefficients
+    return abs(a * y - b * x) <= ATOM and abs(b * z - c * y) <= ATOM
+
+  def sample_within(self, points: list[Point], n: int = 5) -> list[Point]:
+    """Sample a point within the boundary of points."""
+    center = sum(points, Point(0.0, 0.0)) * (1.0 / len(points))
+    radius = max([p.distance(center) for p in points])
+    if close_enough(center.distance(self), radius):
+      center = center.foot(self)
+    a, b = line_circle_intersection(self, Circle(center.foot(self), radius))
+
+    result = None
+    best = -1.0
+    for _ in range(n):
+      rand = unif(0.0, 1.0)
+      x = a + (b - a) * rand
+      mind = min([x.distance(p) for p in points])
+      if mind > best:
+        best = mind
+        result = x
+
+    return [result]
+
+
+class InvalidLineIntersectError(Exception):
+  pass
+
+
+class HalfLine(Line):
+  """Numerical ray."""
+
+  def __init__(self, tail: Point, head: Point):  # pylint: disable=super-init-not-called
+    self.line = Line(tail, head)
+    self.coefficients = self.line.coefficients
+    self.tail = tail
+    self.head = head
+
+  def intersect(self, obj: Union[Line, HalfLine, Circle, HoleCircle]) -> Point:
+    if isinstance(obj, (HalfLine, Line)):
+      return line_line_intersection(self.line, obj)
+
+    exclude = [self.tail]
+    if isinstance(obj, HoleCircle):
+      exclude += [obj.hole]
+
+    a, b = line_circle_intersection(self.line, obj)
+    if any([a.close(x) for x in exclude]):
+      return b
+    if any([b.close(x) for x in exclude]):
+      return a
+
+    v = self.head - self.tail
+    va = a - self.tail
+    vb = b - self.tail
+    if v.dot(va) > 0:
+      return a
+    if v.dot(vb) > 0:
+      return b
+    raise InvalidLineIntersectError()
+
+  def sample_within(self, points: list[Point], n: int = 5) -> list[Point]:
+    center = sum(points, Point(0.0, 0.0)) * (1.0 / len(points))
+    radius = max([p.distance(center) for p in points])
+    if close_enough(center.distance(self.line), radius):
+      center = center.foot(self)
+    a, b = line_circle_intersection(self, Circle(center.foot(self), radius))
+
+    if (a - self.tail).dot(self.head - self.tail) > 0:
+      a, b = self.tail, a
+    else:
+      a, b = self.tail, b  # pylint: disable=self-assigning-variable
+
+    result = None
+    best = -1.0
+    for _ in range(n):
+      x = a + (b - a) * unif(0.0, 1.0)
+      mind = min([x.distance(p) for p in points])
+      if mind > best:
+        best = mind
+        result = x
+
+    return [result]
+
+
+def _perpendicular_bisector(p1: Point, p2: Point) -> Line:
+  midpoint = (p1 + p2) * 0.5
+  return Line(midpoint, midpoint + Point(p2.y - p1.y, p1.x - p2.x))
+
+
+def same_sign(
+    a: Point, b: Point, c: Point, d: Point, e: Point, f: Point
+) -> bool:
+  a, b, c, d, e, f = map(lambda p: p.sym, [a, b, c, d, e, f])
+  ab, cb = a - b, c - b
+  de, fe = d - e, f - e
+  return (ab.x * cb.y - ab.y * cb.x) * (de.x * fe.y - de.y * fe.x) > 0
+
+
+class Circle:
+  """Numerical circle."""
+
+  def __init__(
+      self,
+      center: Optional[Point] = None,
+      radius: Optional[float] = None,
+      p1: Optional[Point] = None,
+      p2: Optional[Point] = None,
+      p3: Optional[Point] = None,
+  ):
+    if not center:
+      if not (p1 and p2 and p3):
+        self.center = self.radius = self.r2 = None
+        return
+        # raise ValueError('Circle without center need p1 p2 p3')
+
+      l12 = _perpendicular_bisector(p1, p2)
+      l23 = _perpendicular_bisector(p2, p3)
+      center = line_line_intersection(l12, l23)
+
+    self.center = center
+    self.a, self.b = center.x, center.y
+
+    if not radius:
+      if not (p1 or p2 or p3):
+        raise ValueError('Circle needs radius or p1 or p2 or p3')
+      p = p1 or p2 or p3
+      self.r2 = (self.a - p.x) ** 2 + (self.b - p.y) ** 2
+      self.radius = math.sqrt(self.r2)
+    else:
+      self.radius = radius
+      self.r2 = radius * radius
+
+  def intersect(self, obj: Union[Line, Circle]) -> tuple[Point, ...]:
+    if isinstance(obj, Line):
+      return obj.intersect(self)
+    if isinstance(obj, Circle):
+      return circle_circle_intersection(self, obj)
+
+  def sample_within(self, points: list[Point], n: int = 5) -> list[Point]:
+    """Sample a point within the boundary of points."""
+    result = None
+    best = -1.0
+    for _ in range(n):
+      ang = unif(0.0, 2.0) * np.pi
+      x = self.center + Point(np.cos(ang), np.sin(ang)) * self.radius
+      mind = min([x.distance(p) for p in points])
+      if mind > best:
+        best = mind
+        result = x
+
+    return [result]
+
+
+class HoleCircle(Circle):
+  """Numerical circle with a missing point."""
+
+  def __init__(self, center: Point, radius: float, hole: Point):
+    super().__init__(center, radius)
+    self.hole = hole
+
+  def intersect(self, obj: Union[Line, HalfLine, Circle, HoleCircle]) -> Point:
+    if isinstance(obj, Line):
+      a, b = line_circle_intersection(obj, self)
+      if a.close(self.hole):
+        return b
+      return a
+    if isinstance(obj, HalfLine):
+      return obj.intersect(self)
+    if isinstance(obj, Circle):
+      a, b = circle_circle_intersection(obj, self)
+      if a.close(self.hole):
+        return b
+      return a
+    if isinstance(obj, HoleCircle):
+      a, b = circle_circle_intersection(obj, self)
+      if a.close(self.hole) or a.close(obj.hole):
+        return b
+      return a
+
+
+def solve_quad(a: float, b: float, c: float) -> tuple[float, float]:
+  """Solve a x^2 + bx + c = 0."""
+  a = 2 * a
+  d = b * b - 2 * a * c
+  if d < 0:
+    return None  # the caller should expect this result.
+
+  y = math.sqrt(d)
+  return (-b - y) / a, (-b + y) / a
+
+
+def circle_circle_intersection(c1: Circle, c2: Circle) -> tuple[Point, Point]:
+  """Returns a pair of Points as intersections of c1 and c2."""
+  # circle 1: (x0, y0), radius r0
+  # circle 2: (x1, y1), radius r1
+  x0, y0, r0 = c1.a, c1.b, c1.radius
+  x1, y1, r1 = c2.a, c2.b, c2.radius
+
+  d = math.sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2)
+  if d == 0:
+    raise InvalidQuadSolveError()
+
+  a = (r0**2 - r1**2 + d**2) / (2 * d)
+  h = r0**2 - a**2
+  if h < 0:
+    raise InvalidQuadSolveError()
+  h = np.sqrt(h)
+  x2 = x0 + a * (x1 - x0) / d
+  y2 = y0 + a * (y1 - y0) / d
+  x3 = x2 + h * (y1 - y0) / d
+  y3 = y2 - h * (x1 - x0) / d
+  x4 = x2 - h * (y1 - y0) / d
+  y4 = y2 + h * (x1 - x0) / d
+
+  return Point(x3, y3), Point(x4, y4)
+
+
+class InvalidQuadSolveError(Exception):
+  pass
+
+
+def line_circle_intersection(line: Line, circle: Circle) -> tuple[Point, Point]:
+  """Returns a pair of points as intersections of line and circle."""
+  a, b, c = line.coefficients
+  r = float(circle.radius)
+  center = circle.center
+  p, q = center.x, center.y
+
+  if b == 0:
+    x = -c / a
+    x_p = x - p
+    x_p2 = x_p * x_p
+    y = solve_quad(1, -2 * q, q * q + x_p2 - r * r)
+    if y is None:
+      raise InvalidQuadSolveError()
+    y1, y2 = y
+    return (Point(x, y1), Point(x, y2))
+
+  if a == 0:
+    y = -c / b
+    y_q = y - q
+    y_q2 = y_q * y_q
+    x = solve_quad(1, -2 * p, p * p + y_q2 - r * r)
+    if x is None:
+      raise InvalidQuadSolveError()
+    x1, x2 = x
+    return (Point(x1, y), Point(x2, y))
+
+  c_ap = c + a * p
+  a2 = a * a
+  y = solve_quad(
+      a2 + b * b, 2 * (b * c_ap - a2 * q), c_ap * c_ap + a2 * (q * q - r * r)
+  )
+  if y is None:
+    raise InvalidQuadSolveError()
+  y1, y2 = y
+
+  return Point(-(b * y1 + c) / a, y1), Point(-(b * y2 + c) / a, y2)
+
+
+def _check_between(a: Point, b: Point, c: Point) -> bool:
+  """Whether a is between b & c."""
+  return (a - b).dot(c - b) > 0 and (a - c).dot(b - c) > 0
+
+
+def circle_segment_intersect(
+    circle: Circle, p1: Point, p2: Point
+) -> list[Point]:
+  l = Line(p1, p2)
+  px, py = line_circle_intersection(l, circle)
+
+  result = []
+  if _check_between(px, p1, p2):
+    result.append(px)
+  if _check_between(py, p1, p2):
+    result.append(py)
+  return result
+
+
+def line_segment_intersection(l: Line, A: Point, B: Point) -> Point:  # pylint: disable=invalid-name
+  a, b, c = l.coefficients
+  x1, y1, x2, y2 = A.x, A.y, B.x, B.y
+  dx, dy = x2 - x1, y2 - y1
+  alpha = (-c - a * x1 - b * y1) / (a * dx + b * dy)
+  return Point(x1 + alpha * dx, y1 + alpha * dy)
+
+
+def line_line_intersection(l1: Line, l2: Line) -> Point:
+  a1, b1, c1 = l1.coefficients
+  a2, b2, c2 = l2.coefficients
+  # a1x + b1y + c1 = 0
+  # a2x + b2y + c2 = 0
+  d = a1 * b2 - a2 * b1
+  if d == 0:
+    raise InvalidLineIntersectError
+  return Point((c2 * b1 - c1 * b2) / d, (c1 * a2 - c2 * a1) / d)
+
+
+def check_too_close(
+    newpoints: list[Point], points: list[Point], tol: int = 0.1
+) -> bool:
+  if not points:
+    return False
+  avg = sum(points, Point(0.0, 0.0)) * 1.0 / len(points)
+  mindist = min([p.distance(avg) for p in points])
+  for p0 in newpoints:
+    for p1 in points:
+      if p0.distance(p1) < tol * mindist:
+        return True
+  return False
+
+
+def check_too_far(
+    newpoints: list[Point], points: list[Point], tol: int = 4
+) -> bool:
+  if len(points) < 2:
+    return False
+  avg = sum(points, Point(0.0, 0.0)) * 1.0 / len(points)
+  maxdist = max([p.distance(avg) for p in points])
+  for p in newpoints:
+    if p.distance(avg) > maxdist * tol:
+      return True
+  return False
+
+
+def check_aconst(args: list[Point]) -> bool:
+  a, b, c, d, num, den = args
+  d = d + a - c
+  ang = ang_between(a, b, d)
+  if ang < 0:
+    ang += np.pi
+  return close_enough(ang, num * np.pi / den)
+
+
+def check(name: str, args: list[Union[gm.Point, Point]]) -> bool:
+  """Numerical check."""
+  if name == 'eqangle6':
+    name = 'eqangle'
+  elif name == 'eqratio6':
+    name = 'eqratio'
+  elif name in ['simtri2', 'simtri*']:
+    name = 'simtri'
+  elif name in ['contri2', 'contri*']:
+    name = 'contri'
+  elif name == 'para':
+    name = 'para_or_coll'
+  elif name == 'on_line':
+    name = 'coll'
+  elif name in ['rcompute', 'acompute']:
+    return True
+  elif name in ['fixl', 'fixc', 'fixb', 'fixt', 'fixp']:
+    return True
+
+  fn_name = 'check_' + name
+  if fn_name not in globals():
+    return None
+
+  fun = globals()['check_' + name]
+  args = [p.num if isinstance(p, gm.Point) else p for p in args]
+  return fun(args)
+
+
+def check_circle(points: list[Point]) -> bool:
+  if len(points) != 4:
+    return False
+  o, a, b, c = points
+  oa, ob, oc = o.distance(a), o.distance(b), o.distance(c)
+  return close_enough(oa, ob) and close_enough(ob, oc)
+
+
+def check_coll(points: list[Point]) -> bool:
+  a, b = points[:2]
+  l = Line(a, b)
+  for p in points[2:]:
+    if abs(l(p.x, p.y)) > ATOM:
+      return False
+  return True
+
+
+def check_ncoll(points: list[Point]) -> bool:
+  return not check_coll(points)
+
+
+def check_sameside(points: list[Point]) -> bool:
+  b, a, c, y, x, z = points
+  # whether b is to the same side of a & c as y is to x & z
+  ba = b - a
+  bc = b - c
+  yx = y - x
+  yz = y - z
+  return ba.dot(bc) * yx.dot(yz) > 0
+
+
+def check_para_or_coll(points: list[Point]) -> bool:
+  return check_para(points) or check_coll(points)
+
+
+def check_para(points: list[Point]) -> bool:
+  a, b, c, d = points
+  ab = Line(a, b)
+  cd = Line(c, d)
+  if ab.same(cd):
+    return False
+  return ab.is_parallel(cd)
+
+
+def check_perp(points: list[Point]) -> bool:
+  a, b, c, d = points
+  ab = Line(a, b)
+  cd = Line(c, d)
+  return ab.is_perp(cd)
+
+
+def check_cyclic(points: list[Point]) -> bool:
+  points = list(set(points))
+  (a, b, c, *ps) = points
+  circle = Circle(p1=a, p2=b, p3=c)
+  for d in ps:
+    if not close_enough(d.distance(circle.center), circle.radius):
+      return False
+  return True
+
+
+def bring_together(
+    a: Point, b: Point, c: Point, d: Point
+) -> tuple[Point, Point, Point, Point]:
+  ab = Line(a, b)
+  cd = Line(c, d)
+  x = line_line_intersection(ab, cd)
+  unit = Circle(center=x, radius=1.0)
+  y, _ = line_circle_intersection(ab, unit)
+  z, _ = line_circle_intersection(cd, unit)
+  return x, y, x, z
+
+
+def same_clock(
+    a: Point, b: Point, c: Point, d: Point, e: Point, f: Point
+) -> bool:
+  ba = b - a
+  cb = c - b
+  ed = e - d
+  fe = f - e
+  return (ba.x * cb.y - ba.y * cb.x) * (ed.x * fe.y - ed.y * fe.x) > 0
+
+
+def check_const_angle(points: list[Point]) -> bool:
+  """Check if the angle is equal to the given constant."""
+  a, b, c, d, m, n = points
+  a, b, c, d = bring_together(a, b, c, d)
+  ba = b - a
+  dc = d - c
+
+  a3 = np.arctan2(ba.y, ba.x)
+  a4 = np.arctan2(dc.y, dc.x)
+  y = a3 - a4
+
+  return close_enough(m / n % 1, y / np.pi % 1)
+
+
+def check_eqangle(points: list[Point]) -> bool:
+  """Check if 8 points make 2 equal angles."""
+  a, b, c, d, e, f, g, h = points
+
+  ab = Line(a, b)
+  cd = Line(c, d)
+  ef = Line(e, f)
+  gh = Line(g, h)
+
+  if ab.is_parallel(cd):
+    return ef.is_parallel(gh)
+  if ef.is_parallel(gh):
+    return ab.is_parallel(cd)
+
+  a, b, c, d = bring_together(a, b, c, d)
+  e, f, g, h = bring_together(e, f, g, h)
+
+  ba = b - a
+  dc = d - c
+  fe = f - e
+  hg = h - g
+
+  sameclock = (ba.x * dc.y - ba.y * dc.x) * (fe.x * hg.y - fe.y * hg.x) > 0
+  if not sameclock:
+    ba = ba * -1.0
+
+  a1 = np.arctan2(fe.y, fe.x)
+  a2 = np.arctan2(hg.y, hg.x)
+  x = a1 - a2
+
+  a3 = np.arctan2(ba.y, ba.x)
+  a4 = np.arctan2(dc.y, dc.x)
+  y = a3 - a4
+
+  xy = (x - y) % (2 * np.pi)
+  return close_enough(xy, 0, tol=1e-11) or close_enough(
+      xy, 2 * np.pi, tol=1e-11
+  )
+
+
+def check_eqratio(points: list[Point]) -> bool:
+  a, b, c, d, e, f, g, h = points
+  ab = a.distance(b)
+  cd = c.distance(d)
+  ef = e.distance(f)
+  gh = g.distance(h)
+  return close_enough(ab * gh, cd * ef)
+
+
+def check_cong(points: list[Point]) -> bool:
+  a, b, c, d = points
+  return close_enough(a.distance(b), c.distance(d))
+
+
+def check_midp(points: list[Point]) -> bool:
+  a, b, c = points
+  return check_coll(points) and close_enough(a.distance(b), a.distance(c))
+
+
+def check_simtri(points: list[Point]) -> bool:
+  """Check if 6 points make a pair of similar triangles."""
+  a, b, c, x, y, z = points
+  ab = a.distance(b)
+  bc = b.distance(c)
+  ca = c.distance(a)
+  xy = x.distance(y)
+  yz = y.distance(z)
+  zx = z.distance(x)
+  tol = 1e-9
+  return close_enough(ab * yz, bc * xy, tol) and close_enough(
+      bc * zx, ca * yz, tol
+  )
+
+
+def check_contri(points: list[Point]) -> bool:
+  a, b, c, x, y, z = points
+  ab = a.distance(b)
+  bc = b.distance(c)
+  ca = c.distance(a)
+  xy = x.distance(y)
+  yz = y.distance(z)
+  zx = z.distance(x)
+  tol = 1e-9
+  return (
+      close_enough(ab, xy, tol)
+      and close_enough(bc, yz, tol)
+      and close_enough(ca, zx, tol)
+  )
+
+
+def check_ratio(points: list[Point]) -> bool:
+  a, b, c, d, m, n = points
+  ab = a.distance(b)
+  cd = c.distance(d)
+  return close_enough(ab * n, cd * m)
+
+
+def draw_angle(
+    ax: matplotlib.axes.Axes,
+    head: Point,
+    p1: Point,
+    p2: Point,
+    color: Any = 'red',
+    alpha: float = 0.5,
+    frac: float = 1.0,
+) -> None:
+  """Draw an angle on plt ax."""
+  d1 = p1 - head
+  d2 = p2 - head
+
+  a1 = np.arctan2(float(d1.y), float(d1.x))
+  a2 = np.arctan2(float(d2.y), float(d2.x))
+  a1, a2 = a1 * 180 / np.pi, a2 * 180 / np.pi
+  a1, a2 = a1 % 360, a2 % 360
+
+  if a1 > a2:
+    a1, a2 = a2, a1
+
+  if a2 - a1 > 180:
+    a1, a2 = a2, a1
+
+  b1, b2 = a1, a2
+  if b1 > b2:
+    b2 += 360
+  d = b2 - b1
+  # if d >= 90:
+  #   return
+
+  scale = min(2.0, 90 / d)
+  scale = max(scale, 0.4)
+  fov = matplotlib.patches.Wedge(
+      (float(head.x), float(head.y)),
+      unif(0.075, 0.125) * scale * frac,
+      a1,
+      a2,
+      color=color,
+      alpha=alpha,
+  )
+  ax.add_artist(fov)
+
+
+def naming_position(
+    ax: matplotlib.axes.Axes, p: Point, lines: list[Line], circles: list[Circle]
+) -> tuple[float, float]:
+  """Figure out a good naming position on the drawing."""
+  _ = ax
+  r = 0.08
+  c = Circle(center=p, radius=r)
+  avoid = []
+  for p1, p2 in lines:
+    try:
+      avoid.extend(circle_segment_intersect(c, p1, p2))
+    except InvalidQuadSolveError:
+      continue
+  for x in circles:
+    try:
+      avoid.extend(circle_circle_intersection(c, x))
+    except InvalidQuadSolveError:
+      continue
+
+  if not avoid:
+    return [p.x + 0.01, p.y + 0.01]
+
+  angs = sorted([ang_of(p, a) for a in avoid])
+  angs += [angs[0] + 2 * np.pi]
+  angs = [(angs[i + 1] - a, a) for i, a in enumerate(angs[:-1])]
+
+  d, a = max(angs)
+  ang = a + d / 2
+
+  name_pos = p + Point(np.cos(ang), np.sin(ang)) * r
+
+  x, y = (name_pos.x - r / 1.5, name_pos.y - r / 1.5)
+  return x, y
+
+
+def draw_point(
+    ax: matplotlib.axes.Axes,
+    p: Point,
+    name: str,
+    lines: list[Line],
+    circles: list[Circle],
+    color: Any = 'white',
+    size: float = 15,
+) -> None:
+  """draw a point."""
+  ax.scatter(p.x, p.y, color=color, s=size)
+
+  if color == 'white':
+    color = 'lightgreen'
+  else:
+    color = 'grey'
+
+  name = name.upper()
+  if len(name) > 1:
+    name = name[0] + '_' + name[1:]
+
+  ax.annotate(
+      name, naming_position(ax, p, lines, circles), color=color, fontsize=15
+  )
+
+
+def _draw_line(
+    ax: matplotlib.axes.Axes,
+    p1: Point,
+    p2: Point,
+    color: Any = 'white',
+    lw: float = 1.2,
+    alpha: float = 0.8,
+) -> None:
+  """Draw a line in matplotlib."""
+  ls = '-'
+  if color == '--':
+    color = 'black'
+    ls = '--'
+
+  lx, ly = (p1.x, p2.x), (p1.y, p2.y)
+  ax.plot(lx, ly, color=color, lw=lw, alpha=alpha, ls=ls)
+
+
+def draw_line(
+    ax: matplotlib.axes.Axes, line: Line, color: Any = 'white'
+) -> tuple[Point, Point]:
+  """Draw a line."""
+  points = line.neighbors(gm.Point)
+  if len(points) <= 1:
+    return
+
+  points = [p.num for p in points]
+  p1, p2 = points[:2]
+
+  pmin, pmax = (p1, 0.0), (p2, (p2 - p1).dot(p2 - p1))
+
+  for p in points[2:]:
+    v = (p - p1).dot(p2 - p1)
+    if v < pmin[1]:
+      pmin = p, v
+    if v > pmax[1]:
+      pmax = p, v
+
+  p1, p2 = pmin[0], pmax[0]
+  _draw_line(ax, p1, p2, color=color)
+  return p1, p2
+
+
+def _draw_circle(
+    ax: matplotlib.axes.Axes, c: Circle, color: Any = 'cyan', lw: float = 1.2
+) -> None:
+  ls = '-'
+  if color == '--':
+    color = 'black'
+    ls = '--'
+
+  ax.add_patch(
+      plt.Circle(
+          (c.center.x, c.center.y),
+          c.radius,
+          color=color,
+          alpha=0.8,
+          fill=False,
+          lw=lw,
+          ls=ls,
+      )
+  )
+
+
+def draw_circle(
+    ax: matplotlib.axes.Axes, circle: Circle, color: Any = 'cyan'
+) -> Circle:
+  """Draw a circle."""
+  if circle.num is not None:
+    circle = circle.num
+  else:
+    points = circle.neighbors(gm.Point)
+    if len(points) <= 2:
+      return
+    points = [p.num for p in points]
+    p1, p2, p3 = points[:3]
+    circle = Circle(p1=p1, p2=p2, p3=p3)
+
+  _draw_circle(ax, circle, color)
+  return circle
+
+
+def mark_segment(
+    ax: matplotlib.axes.Axes, p1: Point, p2: Point, color: Any, alpha: float
+) -> None:
+  _ = alpha
+  x, y = (p1.x + p2.x) / 2, (p1.y + p2.y) / 2
+  ax.scatter(x, y, color=color, alpha=1.0, marker='o', s=50)
+
+
+def highlight_angle(
+    ax: matplotlib.axes.Axes,
+    a: Point,
+    b: Point,
+    c: Point,
+    d: Point,
+    color: Any,
+    alpha: float,
+) -> None:
+  """Highlight an angle between ab and cd with (color, alpha)."""
+  try:
+    a, b, c, d = bring_together(a, b, c, d)
+  except:  # pylint: disable=bare-except
+    return
+  draw_angle(ax, a, b, d, color=color, alpha=alpha, frac=1.0)
+
+
+def highlight(
+    ax: matplotlib.axes.Axes,
+    name: str,
+    args: list[gm.Point],
+    lcolor: Any,
+    color1: Any,
+    color2: Any,
+) -> None:
+  """Draw highlights."""
+  args = list(map(lambda x: x.num if isinstance(x, gm.Point) else x, args))
+
+  if name == 'cyclic':
+    a, b, c, d = args
+    _draw_circle(ax, Circle(p1=a, p2=b, p3=c), color=color1, lw=2.0)
+  if name == 'coll':
+    a, b, c = args
+    a, b = max(a, b, c), min(a, b, c)
+    _draw_line(ax, a, b, color=color1, lw=2.0)
+  if name == 'para':
+    a, b, c, d = args
+    _draw_line(ax, a, b, color=color1, lw=2.0)
+    _draw_line(ax, c, d, color=color2, lw=2.0)
+  if name == 'eqangle':
+    a, b, c, d, e, f, g, h = args
+
+    x = line_line_intersection(Line(a, b), Line(c, d))
+    if b.distance(x) > a.distance(x):
+      a, b = b, a
+    if d.distance(x) > c.distance(x):
+      c, d = d, c
+    a, b, d = x, a, c
+
+    y = line_line_intersection(Line(e, f), Line(g, h))
+    if f.distance(y) > e.distance(y):
+      e, f = f, e
+    if h.distance(y) > g.distance(y):
+      g, h = h, g
+    e, f, h = y, e, g
+
+    _draw_line(ax, a, b, color=lcolor, lw=2.0)
+    _draw_line(ax, a, d, color=lcolor, lw=2.0)
+    _draw_line(ax, e, f, color=lcolor, lw=2.0)
+    _draw_line(ax, e, h, color=lcolor, lw=2.0)
+    if color1 == '--':
+      color1 = 'red'
+    draw_angle(ax, a, b, d, color=color1, alpha=0.5)
+    if color2 == '--':
+      color2 = 'red'
+    draw_angle(ax, e, f, h, color=color2, alpha=0.5)
+  if name == 'perp':
+    a, b, c, d = args
+    _draw_line(ax, a, b, color=color1, lw=2.0)
+    _draw_line(ax, c, d, color=color1, lw=2.0)
+  if name == 'ratio':
+    a, b, c, d, m, n = args
+    _draw_line(ax, a, b, color=color1, lw=2.0)
+    _draw_line(ax, c, d, color=color2, lw=2.0)
+  if name == 'cong':
+    a, b, c, d = args
+    _draw_line(ax, a, b, color=color1, lw=2.0)
+    _draw_line(ax, c, d, color=color2, lw=2.0)
+  if name == 'midp':
+    m, a, b = args
+    _draw_line(ax, a, m, color=color1, lw=2.0, alpha=0.5)
+    _draw_line(ax, b, m, color=color2, lw=2.0, alpha=0.5)
+  if name == 'eqratio':
+    a, b, c, d, m, n, p, q = args
+    _draw_line(ax, a, b, color=color1, lw=2.0, alpha=0.5)
+    _draw_line(ax, c, d, color=color2, lw=2.0, alpha=0.5)
+    _draw_line(ax, m, n, color=color1, lw=2.0, alpha=0.5)
+    _draw_line(ax, p, q, color=color2, lw=2.0, alpha=0.5)
+
+
+HCOLORS = None
+
+
+def _draw(
+    ax: matplotlib.axes.Axes,
+    points: list[gm.Point],
+    lines: list[gm.Line],
+    circles: list[gm.Circle],
+    goal: Any,
+    equals: list[tuple[Any, Any]],
+    highlights: list[tuple[str, list[gm.Point]]],
+):
+  """Draw everything."""
+  colors = ['red', 'green', 'blue', 'orange', 'magenta', 'purple']
+  pcolor = 'black'
+  lcolor = 'black'
+  ccolor = 'grey'
+  if get_theme() == 'dark':
+    pcolor, lcolor, ccolor = 'white', 'white', 'cyan'
+  elif get_theme() == 'light':
+    pcolor, lcolor, ccolor = 'black', 'black', 'blue'
+  elif get_theme() == 'grey':
+    pcolor, lcolor, ccolor = 'black', 'black', 'grey'
+    colors = ['grey']
+
+  line_boundaries = []
+  for l in lines:
+    p1, p2 = draw_line(ax, l, color=lcolor)
+    line_boundaries.append((p1, p2))
+  circles = [draw_circle(ax, c, color=ccolor) for c in circles]
+
+  for p in points:
+    draw_point(ax, p.num, p.name, line_boundaries, circles, color=pcolor)
+
+  if equals:
+    for i, segs in enumerate(equals['segments']):
+      color = colors[i % len(colors)]
+      for a, b in segs:
+        mark_segment(ax, a, b, color, 0.5)
+
+    for i, angs in enumerate(equals['angles']):
+      color = colors[i % len(colors)]
+      for a, b, c, d in angs:
+        highlight_angle(ax, a, b, c, d, color, 0.5)
+
+  if highlights:
+    global HCOLORS
+    if HCOLORS is None:
+      HCOLORS = [k for k in mcolors.TABLEAU_COLORS.keys() if 'red' not in k]
+
+    for i, (name, args) in enumerate(highlights):
+      color_i = HCOLORS[i % len(HCOLORS)]
+      highlight(ax, name, args, 'black', color_i, color_i)
+
+  if goal:
+    name, args = goal
+    lcolor = color1 = color2 = 'red'
+    highlight(ax, name, args, lcolor, color1, color2)
+
+
+THEME = 'dark'
+
+
+def set_theme(theme) -> None:
+  global THEME
+  THEME = theme
+
+
+def get_theme() -> str:
+  return THEME
+
+
+def draw(
+    points: list[gm.Point],
+    lines: list[gm.Line],
+    circles: list[gm.Circle],
+    segments: list[gm.Segment],
+    goal: Any = None,
+    highlights: list[tuple[str, list[gm.Point]]] = None,
+    equals: list[tuple[Any, Any]] = None,
+    block: bool = True,
+    save_to: str = None,
+    theme: str = 'light',
+) -> None:
+  """Draw everything on the same canvas."""
+  plt.close()
+  imsize = 512 / 100
+  fig, ax = plt.subplots(figsize=(imsize, imsize), dpi=100)
+
+  set_theme(theme)
+
+  if get_theme() == 'dark':
+    ax.set_facecolor((0.0, 0.0, 0.0))
+  else:
+    ax.set_facecolor((1.0, 1.0, 1.0))
+
+  _draw(ax, points, lines, circles, goal, equals, highlights)
+
+  plt.axis('equal')
+  fig.subplots_adjust(left=0, right=1, top=1, bottom=0, wspace=0, hspace=0)
+  if points:
+    xmin = min([p.num.x for p in points])
+    xmax = max([p.num.x for p in points])
+    ymin = min([p.num.y for p in points])
+    ymax = max([p.num.y for p in points])
+    plt.margins((xmax - xmin) * 0.1, (ymax - ymin) * 0.1)
+  if save_to:
+    plt.savefig(save_to)
+  # plt.show(block=block)
+  
+
+
+def close_enough(a: float, b: float, tol: float = 1e-12) -> bool:
+  return abs(a - b) < tol
+
+
+def assert_close_enough(a: float, b: float, tol: float = 1e-12) -> None:
+  assert close_enough(a, b, tol), f'|{a}-{b}| = {abs(a-b)} >= {tol}'
+
+
+def ang_of(tail: Point, head: Point) -> float:
+  vector = head - tail
+  arctan = np.arctan2(vector.y, vector.x) % (2 * np.pi)
+  return arctan
+
+
+def ang_between(tail: Point, head1: Point, head2: Point) -> float:
+  ang1 = ang_of(tail, head1)
+  ang2 = ang_of(tail, head2)
+  diff = ang1 - ang2
+  # return diff % (2*np.pi)
+  if diff > np.pi:
+    return diff - 2 * np.pi
+  if diff < -np.pi:
+    return 2 * np.pi + diff
+  return diff
+
+
+def head_from(tail: Point, ang: float, length: float = 1) -> Point:
+  vector = Point(np.cos(ang) * length, np.sin(ang) * length)
+  return tail + vector
+
+
+def random_points(n: int = 3) -> list[Point]:
+  return [Point(unif(-1, 1), unif(-1, 1)) for _ in range(n)]
+
+
+def random_rfss(*points: list[Point]) -> list[Point]:
+  """Random rotate-flip-scale-shift a point cloud."""
+  # center point cloud.
+  average = sum(points, Point(0.0, 0.0)) * (1.0 / len(points))
+  points = [p - average for p in points]
+
+  # rotate
+  ang = unif(0.0, 2 * np.pi)
+  sin, cos = np.sin(ang), np.cos(ang)
+  # scale and shift
+  scale = unif(0.5, 2.0)
+  shift = Point(unif(-1, 1), unif(-1, 1))
+  points = [p.rotate(sin, cos) * scale + shift for p in points]
+
+  # randomly flip
+  if np.random.rand() < 0.5:
+    points = [p.flip() for p in points]
+
+  return points
+
+
+def reduce(
+    objs: list[Union[Point, Line, Circle, HalfLine, HoleCircle]],
+    existing_points: list[Point],
+) -> list[Point]:
+  """Reduce intersecting objects into one point of intersections."""
+  if all(isinstance(o, Point) for o in objs):
+    return objs
+
+  elif len(objs) == 1:
+    return objs[0].sample_within(existing_points)
+
+  elif len(objs) == 2:
+    a, b = objs
+    result = a.intersect(b)
+    if isinstance(result, Point):
+      return [result]
+    a, b = result
+    a_close = any([a.close(x) for x in existing_points])
+    if a_close:
+      return [b]
+    b_close = any([b.close(x) for x in existing_points])
+    if b_close:
+      return [a]
+    return [np.random.choice([a, b])]
+
+  else:
+    raise ValueError(f'Cannot reduce {objs}')
+
+
+def sketch(
+    name: str, args: list[Union[Point, gm.Point]]
+) -> list[Union[Point, Line, Circle, HalfLine, HoleCircle]]:
+  fun = globals()['sketch_' + name]
+  args = [p.num if isinstance(p, gm.Point) else p for p in args]
+  out = fun(args)
+
+  # out can be one or multiple {Point/Line/HalfLine}
+  if isinstance(out, (tuple, list)):
+    return list(out)
+  return [out]
+
+
+def sketch_on_opline(args: tuple[gm.Point, ...]) -> HalfLine:
+  a, b = args
+  return HalfLine(a, a + a - b)
+
+
+def sketch_on_hline(args: tuple[gm.Point, ...]) -> HalfLine:
+  a, b = args
+  return HalfLine(a, b)
+
+
+def sketch_ieq_triangle(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  a = Point(0.0, 0.0)
+  b = Point(1.0, 0.0)
+
+  c, _ = Circle(a, p1=b).intersect(Circle(b, p1=a))
+  return a, b, c
+
+
+def sketch_incenter2(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  a, b, c = args
+  l1 = sketch_bisect([b, a, c])
+  l2 = sketch_bisect([a, b, c])
+  i = line_line_intersection(l1, l2)
+  x = i.foot(Line(b, c))
+  y = i.foot(Line(c, a))
+  z = i.foot(Line(a, b))
+  return x, y, z, i
+
+
+def sketch_excenter2(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  a, b, c = args
+  l1 = sketch_bisect([b, a, c])
+  l2 = sketch_exbisect([a, b, c])
+  i = line_line_intersection(l1, l2)
+  x = i.foot(Line(b, c))
+  y = i.foot(Line(c, a))
+  z = i.foot(Line(a, b))
+  return x, y, z, i
+
+
+def sketch_centroid(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  a, b, c = args
+  x = (b + c) * 0.5
+  y = (c + a) * 0.5
+  z = (a + b) * 0.5
+  i = line_line_intersection(Line(a, x), Line(b, y))
+  return x, y, z, i
+
+
+def sketch_ninepoints(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  a, b, c = args
+  x = (b + c) * 0.5
+  y = (c + a) * 0.5
+  z = (a + b) * 0.5
+  c = Circle(p1=x, p2=y, p3=z)
+  return x, y, z, c.center
+
+
+def sketch_2l1c(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  """Sketch a circle touching two lines and another circle."""
+  a, b, c, p = args
+  bc, ac = Line(b, c), Line(a, c)
+  circle = Circle(p, p1=a)
+
+  d, d_ = line_circle_intersection(p.perpendicular_line(bc), circle)
+  if bc.diff_side(d_, a):
+    d = d_
+
+  e, e_ = line_circle_intersection(p.perpendicular_line(ac), circle)
+  if ac.diff_side(e_, b):
+    e = e_
+
+  df = d.perpendicular_line(Line(p, d))
+  ef = e.perpendicular_line(Line(p, e))
+  f = line_line_intersection(df, ef)
+
+  g, g_ = line_circle_intersection(Line(c, f), circle)
+  if bc.same_side(g_, a):
+    g = g_
+
+  b_ = c + (b - c) / b.distance(c)
+  a_ = c + (a - c) / a.distance(c)
+  m = (a_ + b_) * 0.5
+  x = line_line_intersection(Line(c, m), Line(p, g))
+  return x.foot(ac), x.foot(bc), g, x
+
+
+def sketch_3peq(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  a, b, c = args
+  ab, bc, ca = Line(a, b), Line(b, c), Line(c, a)
+
+  z = b + (c - b) * np.random.uniform(-0.5, 1.5)
+
+  z_ = z * 2 - c
+  l = z_.parallel_line(ca)
+  x = line_line_intersection(l, ab)
+  y = z * 2 - x
+  return x, y, z
+
+
+def try_to_sketch_intersect(
+    name1: str,
+    args1: list[Union[gm.Point, Point]],
+    name2: str,
+    args2: list[Union[gm.Point, Point]],
+    existing_points: list[Point],
+) -> Optional[Point]:
+  """Try to sketch an intersection between two objects."""
+  obj1 = sketch(name1, args1)[0]
+  obj2 = sketch(name2, args2)[0]
+
+  if isinstance(obj1, Line) and isinstance(obj2, Line):
+    fn = line_line_intersection
+  elif isinstance(obj1, Circle) and isinstance(obj2, Circle):
+    fn = circle_circle_intersection
+  else:
+    fn = line_circle_intersection
+    if isinstance(obj2, Line) and isinstance(obj1, Circle):
+      obj1, obj2 = obj2, obj1
+
+  try:
+    x = fn(obj1, obj2)
+  except:  # pylint: disable=bare-except
+    return None
+
+  if isinstance(x, Point):
+    return x
+
+  x1, x2 = x
+
+  close1 = check_too_close([x1], existing_points)
+  far1 = check_too_far([x1], existing_points)
+  if not close1 and not far1:
+    return x1
+  close2 = check_too_close([x2], existing_points)
+  far2 = check_too_far([x2], existing_points)
+  if not close2 and not far2:
+    return x2
+
+  return None
+
+
+def sketch_acircle(args: tuple[gm.Point, ...]) -> Circle:
+  a, b, c, d, f = args
+  de = sketch_aline([c, a, b, f, d])
+  fe = sketch_aline([a, c, b, d, f])
+  e = line_line_intersection(de, fe)
+  return Circle(p1=d, p2=e, p3=f)
+
+
+def sketch_aline(args: tuple[gm.Point, ...]) -> HalfLine:
+  """Sketch the construction aline."""
+  A, B, C, D, E = args
+  ab = A - B
+  cb = C - B
+  de = D - E
+
+  dab = A.distance(B)
+  ang_ab = np.arctan2(ab.y / dab, ab.x / dab)
+
+  dcb = C.distance(B)
+  ang_bc = np.arctan2(cb.y / dcb, cb.x / dcb)
+
+  dde = D.distance(E)
+  ang_de = np.arctan2(de.y / dde, de.x / dde)
+
+  ang_ex = ang_de + ang_bc - ang_ab
+  X = E + Point(np.cos(ang_ex), np.sin(ang_ex))
+  return HalfLine(E, X)
+
+
+def sketch_amirror(args: tuple[gm.Point, ...]) -> HalfLine:
+  """Sketch the angle mirror."""
+  A, B, C = args  # pylint: disable=invalid-name
+  ab = A - B
+  cb = C - B
+
+  dab = A.distance(B)
+  ang_ab = np.arctan2(ab.y / dab, ab.x / dab)
+  dcb = C.distance(B)
+  ang_bc = np.arctan2(cb.y / dcb, cb.x / dcb)
+
+  ang_bx = 2 * ang_bc - ang_ab
+  X = B + Point(np.cos(ang_bx), np.sin(ang_bx))  # pylint: disable=invalid-name
+  return HalfLine(B, X)
+
+
+def sketch_bisect(args: tuple[gm.Point, ...]) -> Line:
+  a, b, c = args
+  ab = a.distance(b)
+  bc = b.distance(c)
+  x = b + (c - b) * (ab / bc)
+  m = (a + x) * 0.5
+  return Line(b, m)
+
+
+def sketch_exbisect(args: tuple[gm.Point, ...]) -> Line:
+  a, b, c = args
+  return sketch_bisect(args).perpendicular_line(b)
+
+
+def sketch_bline(args: tuple[gm.Point, ...]) -> Line:
+  a, b = args
+  m = (a + b) * 0.5
+  return m.perpendicular_line(Line(a, b))
+
+
+def sketch_dia(args: tuple[gm.Point, ...]) -> Circle:
+  a, b = args
+  return Circle((a + b) * 0.5, p1=a)
+
+
+def sketch_tangent(args: tuple[gm.Point, ...]) -> tuple[Point, Point]:
+  a, o, b = args
+  dia = sketch_dia([a, o])
+  return circle_circle_intersection(Circle(o, p1=b), dia)
+
+
+def sketch_circle(args: tuple[gm.Point, ...]) -> Circle:
+  a, b, c = args
+  return Circle(center=a, radius=b.distance(c))
+
+
+def sketch_cc_tangent(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  """Sketch tangents to two circles."""
+  o, a, w, b = args
+  ra, rb = o.distance(a), w.distance(b)
+
+  ow = Line(o, w)
+  if close_enough(ra, rb):
+    oo = ow.perpendicular_line(o)
+    oa = Circle(o, ra)
+    x, z = line_circle_intersection(oo, oa)
+    y = x + w - o
+    t = z + w - o
+    return x, y, z, t
+
+  swap = rb > ra
+  if swap:
+    o, a, w, b = w, b, o, a
+    ra, rb = rb, ra
+
+  oa = Circle(o, ra)
+  q = o + (w - o) * ra / (ra - rb)
+
+  x, z = circle_circle_intersection(sketch_dia([o, q]), oa)
+  y = w.foot(Line(x, q))
+  t = w.foot(Line(z, q))
+
+  if swap:
+    x, y, z, t = y, x, t, z
+
+  return x, y, z, t
+
+
+def sketch_hcircle(args: tuple[gm.Point, ...]) -> HoleCircle:
+  a, b = args
+  return HoleCircle(center=a, radius=a.distance(b), hole=b)
+
+
+def sketch_e5128(args: tuple[gm.Point, ...]) -> tuple[Point, Point]:
+  a, b, c, d = args
+  ad = Line(a, d)
+
+  g = (a + b) * 0.5
+  de = Line(d, g)
+
+  e, f = line_circle_intersection(de, Circle(c, p1=b))
+
+  if e.distance(d) < f.distance(d):
+    e = f
+  return e, g
+
+
+def sketch_eq_quadrangle(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  """Sketch quadrangle with two equal opposite sides."""
+  a = Point(0.0, 0.0)
+  b = Point(1.0, 0.0)
+
+  length = np.random.uniform(0.5, 2.0)
+  ang = np.random.uniform(np.pi / 3, np.pi * 2 / 3)
+  d = head_from(a, ang, length)
+
+  ang = ang_of(b, d)
+  ang = np.random.uniform(ang / 10, ang / 9)
+  c = head_from(b, ang, length)
+  a, b, c, d = random_rfss(a, b, c, d)
+  return a, b, c, d
+
+
+def sketch_eq_trapezoid(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  a = Point(0.0, 0.0)
+  b = Point(1.0, 0.0)
+  l = unif(0.5, 2.0)
+
+  height = unif(0.5, 2.0)
+  c = Point(0.5 + l / 2.0, height)
+  d = Point(0.5 - l / 2.0, height)
+
+  a, b, c, d = random_rfss(a, b, c, d)
+  return a, b, c, d
+
+
+def sketch_eqangle2(args: tuple[gm.Point, ...]) -> Point:
+  """Sketch the def eqangle2."""
+  a, b, c = args
+
+  d = c * 2 - b
+
+  ba = b.distance(a)
+  bc = b.distance(c)
+  l = ba * ba / bc
+
+  if unif(0.0, 1.0) < 0.5:
+    be = min(l, bc)
+    be = unif(be * 0.1, be * 0.9)
+  else:
+    be = max(l, bc)
+    be = unif(be * 1.1, be * 1.5)
+
+  e = b + (c - b) * (be / bc)
+  y = b + (a - b) * (be / l)
+  return line_line_intersection(Line(c, y), Line(a, e))
+
+
+def sketch_eqangle3(args: tuple[gm.Point, ...]) -> Circle:
+  a, b, d, e, f = args
+  de = d.distance(e)
+  ef = e.distance(f)
+  ab = b.distance(a)
+  ang_ax = ang_of(a, b) + ang_between(e, d, f)
+  x = head_from(a, ang_ax, length=de / ef * ab)
+  return Circle(p1=a, p2=b, p3=x)
+
+
+def sketch_eqdia_quadrangle(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  """Sketch quadrangle with two equal diagonals."""
+  m = unif(0.3, 0.7)
+  n = unif(0.3, 0.7)
+  a = Point(-m, 0.0)
+  c = Point(1 - m, 0.0)
+  b = Point(0.0, -n)
+  d = Point(0.0, 1 - n)
+
+  ang = unif(-0.25 * np.pi, 0.25 * np.pi)
+  sin, cos = np.sin(ang), np.cos(ang)
+  b = b.rotate(sin, cos)
+  d = d.rotate(sin, cos)
+  a, b, c, d = random_rfss(a, b, c, d)
+  return a, b, c, d
+
+
+def sketch_free(args: tuple[gm.Point, ...]) -> Point:
+  return random_points(1)[0]
+
+
+def sketch_isos(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  base = unif(0.5, 1.5)
+  height = unif(0.5, 1.5)
+
+  b = Point(-base / 2, 0.0)
+  c = Point(base / 2, 0.0)
+  a = Point(0.0, height)
+  a, b, c = random_rfss(a, b, c)
+  return a, b, c
+
+
+def sketch_line(args: tuple[gm.Point, ...]) -> Line:
+  a, b = args
+  return Line(a, b)
+
+
+def sketch_cyclic(args: tuple[gm.Point, ...]) -> Circle:
+  a, b, c = args
+  return Circle(p1=a, p2=b, p3=c)
+
+
+def sketch_hline(args: tuple[gm.Point, ...]) -> HalfLine:
+  a, b = args
+  return HalfLine(a, b)
+
+
+def sketch_midp(args: tuple[gm.Point, ...]) -> Point:
+  a, b = args
+  return (a + b) * 0.5
+
+
+def sketch_pentagon(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  points = [Point(1.0, 0.0)]
+  ang = 0.0
+
+  for i in range(4):
+    ang += (2 * np.pi - ang) / (5 - i) * unif(0.5, 1.5)
+    point = Point(np.cos(ang), np.sin(ang))
+    points.append(point)
+
+  a, b, c, d, e = points  # pylint: disable=unbalanced-tuple-unpacking
+  a, b, c, d, e = random_rfss(a, b, c, d, e)
+  return a, b, c, d, e
+
+
+def sketch_pline(args: tuple[gm.Point, ...]) -> Line:
+  a, b, c = args
+  return a.parallel_line(Line(b, c))
+
+
+def sketch_pmirror(args: tuple[gm.Point, ...]) -> Point:
+  a, b = args
+  return b * 2 - a
+
+
+def sketch_quadrangle(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  """Sketch a random quadrangle."""
+  m = unif(0.3, 0.7)
+  n = unif(0.3, 0.7)
+
+  a = Point(-m, 0.0)
+  c = Point(1 - m, 0.0)
+  b = Point(0.0, -unif(0.25, 0.75))
+  d = Point(0.0, unif(0.25, 0.75))
+
+  ang = unif(-0.25 * np.pi, 0.25 * np.pi)
+  sin, cos = np.sin(ang), np.cos(ang)
+  b = b.rotate(sin, cos)
+  d = d.rotate(sin, cos)
+  a, b, c, d = random_rfss(a, b, c, d)
+  return a, b, c, d
+
+
+def sketch_r_trapezoid(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  a = Point(0.0, 1.0)
+  d = Point(0.0, 0.0)
+  b = Point(unif(0.5, 1.5), 1.0)
+  c = Point(unif(0.5, 1.5), 0.0)
+  a, b, c, d = random_rfss(a, b, c, d)
+  return a, b, c, d
+
+
+def sketch_r_triangle(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  a = Point(0.0, 0.0)
+  b = Point(0.0, unif(0.5, 2.0))
+  c = Point(unif(0.5, 2.0), 0.0)
+  a, b, c = random_rfss(a, b, c)
+  return a, b, c
+
+
+def sketch_rectangle(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  a = Point(0.0, 0.0)
+  b = Point(0.0, 1.0)
+  l = unif(0.5, 2.0)
+  c = Point(l, 1.0)
+  d = Point(l, 0.0)
+  a, b, c, d = random_rfss(a, b, c, d)
+  return a, b, c, d
+
+
+def sketch_reflect(args: tuple[gm.Point, ...]) -> Point:
+  a, b, c = args
+  m = a.foot(Line(b, c))
+  return m * 2 - a
+
+
+def sketch_risos(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  a = Point(0.0, 0.0)
+  b = Point(0.0, 1.0)
+  c = Point(1.0, 0.0)
+  a, b, c = random_rfss(a, b, c)
+  return a, b, c
+
+
+def sketch_rotaten90(args: tuple[gm.Point, ...]) -> Point:
+  a, b = args
+  ang = -np.pi / 2
+  return a + (b - a).rotate(np.sin(ang), np.cos(ang))
+
+
+def sketch_rotatep90(args: tuple[gm.Point, ...]) -> Point:
+  a, b = args
+  ang = np.pi / 2
+  return a + (b - a).rotate(np.sin(ang), np.cos(ang))
+
+
+def sketch_s_angle(args: tuple[gm.Point, ...]) -> HalfLine:
+  a, b, y = args
+  ang = y / 180 * np.pi
+  x = b + (a - b).rotatea(ang)
+  return HalfLine(b, x)
+
+
+def sketch_segment(args: tuple[gm.Point, ...]) -> tuple[Point, Point]:
+  a, b = random_points(2)
+  return a, b
+
+
+def sketch_shift(args: tuple[gm.Point, ...]) -> Point:
+  a, b, c = args
+  return c + (b - a)
+
+
+def sketch_square(args: tuple[gm.Point, ...]) -> tuple[Point, Point]:
+  a, b = args
+  c = b + (a - b).rotatea(-np.pi / 2)
+  d = a + (b - a).rotatea(np.pi / 2)
+  return c, d
+
+
+def sketch_isquare(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  a = Point(0.0, 0.0)
+  b = Point(1.0, 0.0)
+  c = Point(1.0, 1.0)
+  d = Point(0.0, 1.0)
+  a, b, c, d = random_rfss(a, b, c, d)
+  return a, b, c, d
+
+
+def sketch_tline(args: tuple[gm.Point, ...]) -> Line:
+  a, b, c = args
+  return a.perpendicular_line(Line(b, c))
+
+
+def sketch_trapezoid(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  d = Point(0.0, 0.0)
+  c = Point(1.0, 0.0)
+
+  base = unif(0.5, 2.0)
+  height = unif(0.5, 2.0)
+  a = Point(unif(0.2, 0.5), height)
+  b = Point(a.x + base, height)
+  a, b, c, d = random_rfss(a, b, c, d)
+  return a, b, c, d
+
+
+def sketch_triangle(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  a = Point(0.0, 0.0)
+  b = Point(1.0, 0.0)
+  ac = unif(0.5, 2.0)
+  ang = unif(0.2, 0.8) * np.pi
+  c = head_from(a, ang, ac)
+  return a, b, c
+
+
+def sketch_triangle12(args: tuple[gm.Point, ...]) -> tuple[Point, ...]:
+  b = Point(0.0, 0.0)
+  c = Point(unif(1.5, 2.5), 0.0)
+  a, _ = circle_circle_intersection(Circle(b, 1.0), Circle(c, 2.0))
+  a, b, c = random_rfss(a, b, c)
+  return a, b, c
+
+
+def sketch_trisect(args: tuple[gm.Point, ...]) -> tuple[Point, Point]:
+  """Sketch two trisectors of an angle."""
+  a, b, c = args
+  ang1 = ang_of(b, a)
+  ang2 = ang_of(b, c)
+
+  swap = 0
+  if ang1 > ang2:
+    ang1, ang2 = ang2, ang1
+    swap += 1
+
+  if ang2 - ang1 > np.pi:
+    ang1, ang2 = ang2, ang1 + 2 * np.pi
+    swap += 1
+
+  angx = ang1 + (ang2 - ang1) / 3
+  angy = ang2 - (ang2 - ang1) / 3
+
+  x = b + Point(np.cos(angx), np.sin(angx))
+  y = b + Point(np.cos(angy), np.sin(angy))
+
+  ac = Line(a, c)
+  x = line_line_intersection(Line(b, x), ac)
+  y = line_line_intersection(Line(b, y), ac)
+
+  if swap == 1:
+    return y, x
+  return x, y
+
+
+def sketch_trisegment(args: tuple[gm.Point, ...]) -> tuple[Point, Point]:
+  a, b = args
+  x, y = a + (b - a) * (1.0 / 3), a + (b - a) * (2.0 / 3)
+  return x, y

ag4masses/alphageometry/numericals_test.py

@@ -0,0 +1,313 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Unit testing for the geometry numericals code."""
+
+import unittest
+
+from absl.testing import absltest
+import numericals as nm
+
+np = nm.np
+
+unif = nm.unif
+Point = nm.Point
+Line = nm.Line
+Circle = nm.Circle
+HalfLine = nm.HalfLine
+
+line_circle_intersection = nm.line_circle_intersection
+line_line_intersection = nm.line_line_intersection
+
+check_coll = nm.check_coll
+check_eqangle = nm.check_eqangle
+
+random_points = nm.random_points
+ang_between = nm.ang_between
+head_from = nm.head_from
+
+
+class NumericalTest(unittest.TestCase):
+
+  def test_sketch_ieq_triangle(self):
+    a, b, c = nm.sketch_ieq_triangle([])
+    self.assertAlmostEqual(a.distance(b), b.distance(c))
+    self.assertAlmostEqual(c.distance(a), b.distance(c))
+
+  def test_sketch_2l1c(self):
+    p = nm.Point(0.0, 0.0)
+    pi = np.pi
+    anga = unif(-0.4 * pi, 0.4 * pi)
+    a = Point(np.cos(anga), np.sin(anga))
+    angb = unif(0.6 * pi, 1.4 * pi)
+    b = Point(np.cos(angb), np.sin(angb))
+
+    angc = unif(anga + 0.05 * pi, angb - 0.05 * pi)
+    c = Point(np.cos(angc), np.sin(angc)) * unif(0.2, 0.8)
+
+    x, y, z, i = nm.sketch_2l1c([a, b, c, p])
+    self.assertTrue(check_coll([x, c, a]))
+    self.assertTrue(check_coll([y, c, b]))
+    self.assertAlmostEqual(z.distance(p), 1.0)
+    self.assertTrue(check_coll([p, i, z]))
+    self.assertTrue(Line(i, x).is_perp(Line(c, a)))
+    self.assertTrue(Line(i, y).is_perp(Line(c, b)))
+    self.assertAlmostEqual(i.distance(x), i.distance(y))
+    self.assertAlmostEqual(i.distance(x), i.distance(z))
+
+  def test_sketch_3peq(self):
+    a, b, c = random_points(3)
+    x, y, z = nm.sketch_3peq([a, b, c])
+
+    self.assertTrue(check_coll([a, b, x]))
+    self.assertTrue(check_coll([a, c, y]))
+    self.assertTrue(check_coll([b, c, z]))
+    self.assertTrue(check_coll([x, y, z]))
+    self.assertAlmostEqual(z.distance(x), z.distance(y))
+
+  def test_sketch_aline(self):
+    a, b, c, d, e = random_points(5)
+    ex = nm.sketch_aline([a, b, c, d, e])
+    self.assertIsInstance(ex, HalfLine)
+    self.assertEqual(ex.tail, e)
+    x = ex.head
+    self.assertAlmostEqual(ang_between(b, a, c), ang_between(e, d, x))
+
+  def test_sketch_amirror(self):
+    a, b, c = random_points(3)
+    bx = nm.sketch_amirror([a, b, c])
+    self.assertIsInstance(bx, HalfLine)
+    assert bx.tail == b
+    x = bx.head
+
+    ang1 = ang_between(b, a, c)
+    ang2 = ang_between(b, c, x)
+    self.assertAlmostEqual(ang1, ang2)
+
+  def test_sketch_bisect(self):
+    a, b, c = random_points(3)
+    line = nm.sketch_bisect([a, b, c])
+    self.assertAlmostEqual(b.distance(line), 0.0)
+
+    l = a.perpendicular_line(line)
+    x = line_line_intersection(l, Line(b, c))
+    self.assertAlmostEqual(a.distance(line), x.distance(line))
+
+    d, _ = line_circle_intersection(line, Circle(b, radius=1))
+    ang1 = ang_between(b, a, d)
+    ang2 = ang_between(b, d, c)
+    self.assertAlmostEqual(ang1, ang2)
+
+  def test_sketch_bline(self):
+    a, b = random_points(2)
+    l = nm.sketch_bline([a, b])
+    self.assertTrue(Line(a, b).is_perp(l))
+    self.assertAlmostEqual(a.distance(l), b.distance(l))
+
+  def test_sketch_cc_tangent(self):
+    o = Point(0.0, 0.0)
+    w = Point(1.0, 0.0)
+
+    ra = unif(0.0, 0.6)
+    rb = unif(0.4, 1.0)
+
+    a = unif(0.0, np.pi)
+    b = unif(0.0, np.pi)
+
+    a = o + ra * Point(np.cos(a), np.sin(a))
+    b = w + rb * Point(np.sin(b), np.cos(b))
+
+    x, y, z, t = nm.sketch_cc_tangent([o, a, w, b])
+    xy = Line(x, y)
+    zt = Line(z, t)
+    self.assertAlmostEqual(o.distance(xy), o.distance(a))
+    self.assertAlmostEqual(o.distance(zt), o.distance(a))
+    self.assertAlmostEqual(w.distance(xy), w.distance(b))
+    self.assertAlmostEqual(w.distance(zt), w.distance(b))
+
+  def test_sketch_circle(self):
+    a, b, c = random_points(3)
+    circle = nm.sketch_circle([a, b, c])
+    self.assertAlmostEqual(circle.center.distance(a), 0.0)
+    self.assertAlmostEqual(circle.radius, b.distance(c))
+
+  def test_sketch_e5128(self):
+    b = Point(0.0, 0.0)
+    c = Point(0.0, 1.0)
+    ang = unif(-np.pi / 2, 3 * np.pi / 2)
+    d = head_from(c, ang, 1.0)
+    a = Point(unif(0.5, 2.0), 0.0)
+
+    e, g = nm.sketch_e5128([a, b, c, d])
+    ang1 = ang_between(a, b, d)
+    ang2 = ang_between(e, a, g)
+    self.assertAlmostEqual(ang1, ang2)
+
+  def test_sketch_eq_quadrangle(self):
+    a, b, c, d = nm.sketch_eq_quadrangle([])
+    self.assertAlmostEqual(a.distance(d), c.distance(b))
+    ac = Line(a, c)
+    assert ac.diff_side(b, d), (ac(b), ac(d))
+    bd = Line(b, d)
+    assert bd.diff_side(a, c), (bd(a), bd(c))
+
+  def test_sketch_eq_trapezoid(self):
+    a, b, c, d = nm.sketch_eq_trapezoid([])
+    assert Line(a, b).is_parallel(Line(c, d))
+    self.assertAlmostEqual(a.distance(d), b.distance(c))
+
+  def test_sketch_eqangle3(self):
+    points = random_points(5)
+    x = nm.sketch_eqangle3(points).sample_within(points)[0]
+    a, b, d, e, f = points
+    self.assertTrue(check_eqangle([x, a, x, b, d, e, d, f]))
+
+  def test_sketch_eqangle2(self):
+    a, b, c = random_points(3)
+    x = nm.sketch_eqangle2([a, b, c])
+    ang1 = ang_between(a, b, x)
+    ang2 = ang_between(c, x, b)
+    self.assertAlmostEqual(ang1, ang2)
+
+  def test_sketch_edia_quadrangle(self):
+    a, b, c, d = nm.sketch_eqdia_quadrangle([])
+    assert Line(a, c).diff_side(b, d)
+    assert Line(b, d).diff_side(a, c)
+    self.assertAlmostEqual(a.distance(c), b.distance(d))
+
+  def test_sketch_isos(self):
+    a, b, c = nm.sketch_isos([])
+    self.assertAlmostEqual(a.distance(b), a.distance(c))
+    self.assertAlmostEqual(ang_between(b, a, c), ang_between(c, b, a))
+
+  def test_sketch_quadrange(self):
+    a, b, c, d = nm.sketch_quadrangle([])
+    self.assertTrue(Line(a, c).diff_side(b, d))
+    self.assertTrue(Line(b, d).diff_side(a, c))
+
+  def test_sketch_r_trapezoid(self):
+    a, b, c, d = nm.sketch_r_trapezoid([])
+    self.assertTrue(Line(a, b).is_perp(Line(a, d)))
+    self.assertTrue(Line(a, b).is_parallel(Line(c, d)))
+    self.assertTrue(Line(a, c).diff_side(b, d))
+    self.assertTrue(Line(b, d).diff_side(a, c))
+
+  def test_sketch_r_triangle(self):
+    a, b, c = nm.sketch_r_triangle([])
+    self.assertTrue(Line(a, b).is_perp(Line(a, c)))
+
+  def test_sketch_rectangle(self):
+    a, b, c, d = nm.sketch_rectangle([])
+    self.assertTrue(Line(a, b).is_perp(Line(b, c)))
+    self.assertTrue(Line(b, c).is_perp(Line(c, d)))
+    self.assertTrue(Line(c, d).is_perp(Line(d, a)))
+
+  def test_sketch_reflect(self):
+    a, b, c = random_points(3)
+    x = nm.sketch_reflect([a, b, c])
+    self.assertTrue(Line(a, x).is_perp(Line(b, c)))
+    self.assertAlmostEqual(x.distance(Line(b, c)), a.distance(Line(b, c)))
+
+  def test_sketch_risos(self):
+    a, b, c = nm.sketch_risos([])
+    self.assertAlmostEqual(a.distance(b), a.distance(c))
+    self.assertTrue(Line(a, b).is_perp(Line(a, c)))
+
+  def test_sketch_rotaten90(self):
+    a, b = random_points(2)
+    x = nm.sketch_rotaten90([a, b])
+    self.assertAlmostEqual(a.distance(x), a.distance(b))
+    self.assertTrue(Line(a, x).is_perp(Line(a, b)))
+    d = Point(0.0, 0.0)
+    e = Point(0.0, 1.0)
+    f = Point(1.0, 0.0)
+    self.assertAlmostEqual(ang_between(d, e, f), ang_between(a, b, x))
+
+  def test_sketch_rotatep90(self):
+    a, b = random_points(2)
+    x = nm.sketch_rotatep90([a, b])
+    self.assertAlmostEqual(a.distance(x), a.distance(b))
+    self.assertTrue(Line(a, x).is_perp(Line(a, b)))
+    d = Point(0.0, 0.0)
+    e = Point(0.0, 1.0)
+    f = Point(1.0, 0.0)
+    self.assertAlmostEqual(ang_between(d, f, e), ang_between(a, b, x))
+
+  def test_sketch_s_angle(self):
+    a, b = random_points(2)
+    y = unif(0.0, np.pi)
+    bx = nm.sketch_s_angle([a, b, y / np.pi * 180])
+    self.assertIsInstance(bx, HalfLine)
+    self.assertEqual(bx.tail, b)
+    x = bx.head
+
+    d = Point(1.0, 0.0)
+    e = Point(0.0, 0.0)
+    f = Point(np.cos(y), np.sin(y))
+    self.assertAlmostEqual(ang_between(e, d, f), ang_between(b, a, x))
+
+  def test_sketch_shift(self):
+    a, b, c = random_points(3)
+    x = nm.sketch_shift([a, b, c])
+    self.assertTrue((b - a).close(x - c))
+
+  def test_sketch_square(self):
+    a, b = random_points(2)
+    c, d = nm.sketch_square([a, b])
+    self.assertTrue(Line(a, b).is_perp(Line(b, c)))
+    self.assertTrue(Line(b, c).is_perp(Line(c, d)))
+    self.assertTrue(Line(c, d).is_perp(Line(d, a)))
+    self.assertAlmostEqual(a.distance(b), b.distance(c))
+
+  def test_sketch_isquare(self):
+    a, b, c, d = nm.sketch_isquare([])
+    self.assertTrue(Line(a, b).is_perp(Line(b, c)))
+    self.assertTrue(Line(b, c).is_perp(Line(c, d)))
+    self.assertTrue(Line(c, d).is_perp(Line(d, a)))
+    self.assertAlmostEqual(a.distance(b), b.distance(c))
+
+  def test_sketch_trapezoid(self):
+    a, b, c, d = nm.sketch_trapezoid([])
+    self.assertTrue(Line(a, b).is_parallel(Line(c, d)))
+    self.assertTrue(Line(a, c).diff_side(b, d))
+    self.assertTrue(Line(b, d).diff_side(a, c))
+
+  def test_sketch_triangle(self):
+    a, b, c = nm.sketch_triangle([])
+    self.assertFalse(check_coll([a, b, c]))
+
+  def test_sketch_triangle12(self):
+    a, b, c = nm.sketch_triangle12([])
+    self.assertAlmostEqual(a.distance(b) * 2, a.distance(c))
+
+  def test_sketch_trisect(self):
+    a, b, c = random_points(3)
+    x, y = nm.sketch_trisect([a, b, c])
+    self.assertAlmostEqual(ang_between(b, a, x), ang_between(b, x, y))
+    self.assertAlmostEqual(ang_between(b, x, y), ang_between(b, y, c))
+    self.assertAlmostEqual(ang_between(b, a, x) * 3, ang_between(b, a, c))
+
+  def test_sketch_trisegment(self):
+    a, b = random_points(2)
+    x, y = nm.sketch_trisegment([a, b])
+    self.assertAlmostEqual(
+        a.distance(x) + x.distance(y) + y.distance(b), a.distance(b)
+    )
+    self.assertAlmostEqual(a.distance(x), x.distance(y))
+    self.assertAlmostEqual(x.distance(y), y.distance(b))
+
+
+if __name__ == '__main__':
+  absltest.main()

ag4masses/alphageometry/pretty.py

@@ -0,0 +1,216 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Utilities for string manipulation in the DSL."""
+
+MAP_SYMBOL = {
+    'T': 'perp',
+    'P': 'para',
+    'D': 'cong',
+    'S': 'simtri',
+    'I': 'circle',
+    'M': 'midp',
+    'O': 'cyclic',
+    'C': 'coll',
+    '^': 'eqangle',
+    '/': 'eqratio',
+    '%': 'eqratio',
+    '=': 'contri',
+    'X': 'collx',
+    'A': 'acompute',
+    'R': 'rcompute',
+    'Q': 'fixc',
+    'E': 'fixl',
+    'V': 'fixb',
+    'H': 'fixt',
+    'Z': 'fixp',
+    'Y': 'ind',
+}
+
+
+def map_symbol(c: str) -> str:
+  return MAP_SYMBOL[c]
+
+
+def map_symbol_inv(c: str) -> str:
+  return {v: k for k, v in MAP_SYMBOL.items()}[c]
+
+
+def _gcd(x: int, y: int) -> int:
+  while y:
+    x, y = y, x % y
+  return x
+
+
+def simplify(n: int, d: int) -> tuple[int, int]:
+  g = _gcd(n, d)
+  return (n // g, d // g)
+
+
+def pretty2r(a: str, b: str, c: str, d: str) -> str:
+  if b in (c, d):
+    a, b = b, a
+
+  if a == d:
+    c, d = d, c
+
+  return f'{a} {b} {c} {d}'
+
+
+def pretty2a(a: str, b: str, c: str, d: str) -> str:
+  if b in (c, d):
+    a, b = b, a
+
+  if a == d:
+    c, d = d, c
+
+  return f'{a} {b} {c} {d}'
+
+
+def pretty_angle(a: str, b: str, c: str, d: str) -> str:
+  if b in (c, d):
+    a, b = b, a
+  if a == d:
+    c, d = d, c
+
+  if a == c:
+    return f'\u2220{b}{a}{d}'
+  return f'\u2220({a}{b}-{c}{d})'
+
+
+def pretty_nl(name: str, args: list[str]) -> str:
+  """Natural lang formatting a predicate."""
+  if name == 'aconst':
+    a, b, c, d, y = args
+    return f'{pretty_angle(a, b, c, d)} = {y}'
+  if name == 'rconst':
+    a, b, c, d, y = args
+    return f'{a}{b}:{c}{d} = {y}'
+  if name == 'acompute':
+    a, b, c, d = args
+    return f'{pretty_angle(a, b, c, d)}'
+  if name in ['coll', 'C']:
+    return '' + ','.join(args) + ' are collinear'
+  if name == 'collx':
+    return '' + ','.join(list(set(args))) + ' are collinear'
+  if name in ['cyclic', 'O']:
+    return '' + ','.join(args) + ' are concyclic'
+  if name in ['midp', 'midpoint', 'M']:
+    x, a, b = args
+    return f'{x} is midpoint of {a}{b}'
+  if name in ['eqangle', 'eqangle6', '^']:
+    a, b, c, d, e, f, g, h = args
+    return f'{pretty_angle(a, b, c, d)} = {pretty_angle(e, f, g, h)}'
+  if name in ['eqratio', 'eqratio6', '/']:
+    return '{}{}:{}{} = {}{}:{}{}'.format(*args)
+  if name == 'eqratio3':
+    a, b, c, d, o, o = args  # pylint: disable=redeclared-assigned-name
+    return f'S {o} {a} {b} {o} {c} {d}'
+  if name in ['cong', 'D']:
+    a, b, c, d = args
+    return f'{a}{b} = {c}{d}'
+  if name in ['perp', 'T']:
+    if len(args) == 2:  # this is algebraic derivation.
+      ab, cd = args  # ab = 'd( ... )'
+      return f'{ab} \u27c2 {cd}'
+    a, b, c, d = args
+    return f'{a}{b} \u27c2 {c}{d}'
+  if name in ['para', 'P']:
+    if len(args) == 2:  # this is algebraic derivation.
+      ab, cd = args  # ab = 'd( ... )'
+      return f'{ab} \u2225 {cd}'
+    a, b, c, d = args
+    return f'{a}{b} \u2225 {c}{d}'
+  if name in ['simtri2', 'simtri', 'simtri*']:
+    a, b, c, x, y, z = args
+    return f'\u0394{a}{b}{c} is similar to \u0394{x}{y}{z}'
+  if name in ['contri2', 'contri', 'contri*']:
+    a, b, c, x, y, z = args
+    return f'\u0394{a}{b}{c} is congruent to \u0394{x}{y}{z}'
+  if name in ['circle', 'I']:
+    o, a, b, c = args
+    return f'{o} is the circumcenter of \\Delta {a}{b}{c}'
+  if name == 'foot':
+    a, b, c, d = args
+    return f'{a} is the foot of {b} on {c}{d}'
+
+
+def pretty(txt: str) -> str:
+  """Pretty formating a predicate string."""
+  if isinstance(txt, str):
+    txt = txt.split(' ')
+  name, *args = txt
+  if name == 'ind':
+    return 'Y ' + ' '.join(args)
+  if name in ['fixc', 'fixl', 'fixb', 'fixt', 'fixp']:
+    return map_symbol_inv(name) + ' ' + ' '.join(args)
+  if name == 'acompute':
+    a, b, c, d = args
+    return 'A ' + ' '.join(args)
+  if name == 'rcompute':
+    a, b, c, d = args
+    return 'R ' + ' '.join(args)
+  if name == 'aconst':
+    a, b, c, d, y = args
+    return f'^ {pretty2a(a, b, c, d)} {y}'
+  if name == 'rconst':
+    a, b, c, d, y = args
+    return f'/ {pretty2r(a, b, c, d)} {y}'
+  if name == 'coll':
+    return 'C ' + ' '.join(args)
+  if name == 'collx':
+    return 'X ' + ' '.join(args)
+  if name == 'cyclic':
+    return 'O ' + ' '.join(args)
+  if name in ['midp', 'midpoint']:
+    x, a, b = args
+    return f'M {x} {a} {b}'
+  if name == 'eqangle':
+    a, b, c, d, e, f, g, h = args
+    return f'^ {pretty2a(a, b, c, d)} {pretty2a(e, f, g, h)}'
+  if name == 'eqratio':
+    a, b, c, d, e, f, g, h = args
+    return f'/ {pretty2r(a, b, c, d)} {pretty2r(e, f, g, h)}'
+  if name == 'eqratio3':
+    a, b, c, d, o, o = args  # pylint: disable=redeclared-assigned-name
+    return f'S {o} {a} {b} {o} {c} {d}'
+  if name == 'cong':
+    a, b, c, d = args
+    return f'D {a} {b} {c} {d}'
+  if name == 'perp':
+    if len(args) == 2:  # this is algebraic derivation.
+      ab, cd = args  # ab = 'd( ... )'
+      return f'T {ab} {cd}'
+    a, b, c, d = args
+    return f'T {a} {b} {c} {d}'
+  if name == 'para':
+    if len(args) == 2:  # this is algebraic derivation.
+      ab, cd = args  # ab = 'd( ... )'
+      return f'P {ab} {cd}'
+    a, b, c, d = args
+    return f'P {a} {b} {c} {d}'
+  if name in ['simtri2', 'simtri', 'simtri*']:
+    a, b, c, x, y, z = args
+    return f'S {a} {b} {c} {x} {y} {z}'
+  if name in ['contri2', 'contri', 'contri*']:
+    a, b, c, x, y, z = args
+    return f'= {a} {b} {c} {x} {y} {z}'
+  if name == 'circle':
+    o, a, b, c = args
+    return f'I {o} {a} {b} {c}'
+  if name == 'foot':
+    a, b, c, d = args
+    return f'F {a} {b} {c} {d}'
+  return ' '.join(txt)

ag4masses/alphageometry/problem.py

@@ -0,0 +1,1133 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Implements objects to represent problems, theorems, proofs, traceback."""
+
+from __future__ import annotations
+
+from collections import defaultdict  # pylint: disable=g-importing-member
+from typing import Any
+
+import geometry as gm
+import pretty as pt
+
+
+# pylint: disable=protected-access
+# pylint: disable=unused-variable
+# pylint: disable=unused-argument
+# pylint: disable=unused-assignment
+
+
+def reshape(l: list[Any], n: int = 1) -> list[list[Any]]:
+  assert len(l) % n == 0
+  columns = [[] for i in range(n)]
+  for i, x in enumerate(l):
+    columns[i % n].append(x)
+  return zip(*columns)
+
+
+def isint(x: str) -> bool:
+  try:
+    int(x)
+    return True
+  except:  # pylint: disable=bare-except
+    return False
+
+
+class Construction:
+  """One predicate."""
+
+  @classmethod
+  def from_txt(cls, data: str) -> Construction:
+    data = data.split(' ')
+    return Construction(data[0], data[1:])
+
+  def __init__(self, name: str, args: list[str]):
+    self.name = name
+    self.args = args
+
+  def translate(self, mapping: dict[str, str]) -> Construction:
+    args = [a if isint(a) else mapping[a] for a in self.args]
+    return Construction(self.name, args)
+
+  def txt(self) -> str:
+    return ' '.join([self.name] + list(self.args))
+
+
+class Clause:
+  """One construction (>= 1 predicate)."""
+
+  @classmethod
+  def from_txt(cls, data: str) -> Clause:
+    if data == ' =':
+      return Clause([], [])
+    points, constructions = data.split(' = ')
+    return Clause(
+        points.split(' '),
+        [Construction.from_txt(c) for c in constructions.split(', ')],
+    )
+
+  def __init__(self, points: list[str], constructions: list[Construction]):
+    self.points = []
+    self.nums = []
+
+    for p in points:
+      num = None
+      if isinstance(p, str) and '@' in p:
+        p, num = p.split('@')
+        x, y = num.split('_')
+        num = float(x), float(y)
+      self.points.append(p)
+      self.nums.append(num)
+
+    self.constructions = constructions
+
+  def translate(self, mapping: dict[str, str]) -> Clause:
+    points0 = []
+    for p in self.points:
+      pcount = len(mapping) + 1
+      name = chr(96 + pcount)
+      if name > 'z':  # pcount = 26 -> name = 'z'
+        name = chr(97 + (pcount - 1) % 26) + str((pcount - 1) // 26)
+
+      p0 = mapping.get(p, name)
+      mapping[p] = p0
+      points0.append(p0)
+    return Clause(points0, [c.translate(mapping) for c in self.constructions])
+
+  def add(self, name: str, args: list[str]) -> None:
+    self.constructions.append(Construction(name, args))
+
+  def txt(self) -> str:
+    return (
+        ' '.join(self.points)
+        + ' = '
+        + ', '.join(c.txt() for c in self.constructions)
+    )
+
+
+def _gcd(x: int, y: int) -> int:
+  while y:
+    x, y = y, x % y
+  return x
+
+
+def simplify(n: int, d: int) -> tuple[int, int]:
+  g = _gcd(n, d)
+  return (n // g, d // g)
+
+
+def compare_fn(dep: Dependency) -> tuple[Dependency, str]:
+  return (dep, pt.pretty(dep))
+
+
+def sort_deps(deps: list[Dependency]) -> list[Dependency]:
+  return sorted(deps, key=compare_fn)
+
+
+class Problem:
+  """Describe one problem to solve."""
+
+  @classmethod
+  def from_txt_file(
+      cls, fname: str, to_dict: bool = False, translate: bool = True
+  ):
+    """Load a problem from a text file."""
+    with open(fname, 'r') as f:
+      lines = f.read().split('\n')
+
+    lines = [l for l in lines if l]
+    data = [
+        cls.from_txt(url + '\n' + problem, translate)
+        for (url, problem) in reshape(lines, 2)
+    ]
+    if to_dict:
+      return cls.to_dict(data)
+    return data
+
+  @classmethod
+  def from_txt(cls, data: str, translate: bool = True) -> Problem:
+    """Load a problem from a str object."""
+    url = ''
+    if '\n' in data:
+      url, data = data.split('\n')
+
+    if ' ? ' in data:
+      clauses, goal = data.split(' ? ')
+      goal = Construction.from_txt(goal)
+    else:
+      clauses, goal = data, None
+
+    clauses = clauses.split('; ')
+    problem = Problem(
+        url=url, clauses=[Clause.from_txt(c) for c in clauses], goal=goal
+    )
+    if translate:
+      return problem.translate()
+    return problem
+
+  @classmethod
+  def to_dict(cls, data: list[Problem]) -> dict[str, Problem]:
+    return {p.url: p for p in data}
+
+  def __init__(self, url: str, clauses: list[Clause], goal: Construction):
+    self.url = url
+    self.clauses = clauses
+    self.goal = goal
+
+  def copy(self) -> Problem:
+    return Problem(self.url, list(self.clauses), self.goal)
+
+  def translate(self) -> Problem:  # to single-char point names
+    """Translate point names into alphabetical."""
+    mapping = {}
+    clauses = []
+
+    for clause in self.clauses:
+      clauses.append(clause.translate(mapping))
+
+    if self.goal:
+      goal = self.goal.translate(mapping)
+    else:
+      goal = self.goal
+
+    p = Problem(self.url, clauses, goal)
+    p.mapping = mapping
+    return p
+
+  def txt(self) -> str:
+    return (
+        '; '.join([c.txt() for c in self.clauses]) + ' ? ' + self.goal.txt()
+        if self.goal
+        else ''
+    )
+
+  def setup_str_from_problem(self, definitions: list[Definition]) -> str:
+    """Construct the <theorem_premises> string from Problem object."""
+    ref = 0
+
+    string = []
+    for clause in self.clauses:
+      group = {}
+      p2deps = defaultdict(list)
+      for c in clause.constructions:
+        cdef = definitions[c.name]
+
+        if len(c.args) != len(cdef.construction.args):
+          assert len(c.args) + len(clause.points) == len(cdef.construction.args)
+          c.args = clause.points + c.args
+
+        mapping = dict(zip(cdef.construction.args, c.args))
+        for points, bs in cdef.basics:
+          points = tuple([mapping[x] for x in points])
+          for p in points:
+            group[p] = points
+
+          for b in bs:
+            args = [mapping[a] for a in b.args]
+            name = b.name
+            if b.name in ['s_angle', 'aconst']:
+              x, y, z, v = args
+              name = 'aconst'
+              v = int(v)
+
+              if v < 0:
+                v = -v
+                x, z = z, x
+
+              m, n = simplify(int(v), 180)
+              args = [y, z, y, x, f'{m}pi/{n}']
+
+            p2deps[points].append(hashed_txt(name, args))
+
+      for k, v in p2deps.items():
+        p2deps[k] = sort_deps(v)
+
+      points = clause.points
+      while points:
+        p = points[0]
+        gr = group[p]
+        points = [x for x in points if x not in gr]
+
+        deps_str = []
+        for dep in p2deps[gr]:
+          ref_str = '{:02}'.format(ref)
+          dep_str = pt.pretty(dep)
+
+          if dep[0] == 'aconst':
+            m, n = map(int, dep[-1].split('pi/'))
+            mn = f'{m}. pi / {n}.'
+            dep_str = ' '.join(dep_str.split()[:-1] + [mn])
+
+          deps_str.append(dep_str + ' ' + ref_str)
+          ref += 1
+
+        string.append(' '.join(gr) + ' : ' + ' '.join(deps_str))
+
+    string = '{S} ' + ' ; '.join([s.strip() for s in string])
+    goal = self.goal
+    string += ' ? ' + pt.pretty([goal.name] + goal.args)
+    return string
+
+
+def parse_rely(s: str) -> dict[str, str]:
+  result = {}
+  if not s:
+    return result
+  s = [x.strip() for x in s.split(',')]
+  for x in s:
+    a, b = x.split(':')
+    a, b = a.strip().split(), b.strip().split()
+    result.update({m: b for m in a})
+  return result
+
+
+class Definition:
+  """Definitions of construction statements."""
+
+  @classmethod
+  def from_txt_file(cls, fname: str, to_dict: bool = False) -> Definition:
+    with open(fname, 'r') as f:
+      lines = f.read()
+    return cls.from_string(lines, to_dict)
+
+  @classmethod
+  def from_string(cls, string: str, to_dict: bool = False) -> Definition:
+    lines = string.split('\n')
+    data = [cls.from_txt('\n'.join(group)) for group in reshape(lines, 6)]
+    if to_dict:
+      return cls.to_dict(data)
+    return data
+
+  @classmethod
+  def to_dict(cls, data: list[Definition]) -> dict[str, Definition]:
+    return {d.construction.name: d for d in data}
+
+  @classmethod
+  def from_txt(cls, data: str) -> Definition:
+    """Load definitions from a str object."""
+    construction, rely, deps, basics, numerics, _ = data.split('\n')
+    basics = [] if not basics else [b.strip() for b in basics.split(';')]
+
+    levels = []
+    for bs in basics:
+      if ':' in bs:
+        points, bs = bs.split(':')
+        points = points.strip().split()
+      else:
+        points = []
+      if bs.strip():
+        bs = [Construction.from_txt(b.strip()) for b in bs.strip().split(',')]
+      else:
+        bs = []
+      levels.append((points, bs))
+
+    numerics = [] if not numerics else numerics.split(', ')
+
+    return Definition(
+        construction=Construction.from_txt(construction),
+        rely=parse_rely(rely),
+        deps=Clause.from_txt(deps),
+        basics=levels,
+        numerics=[Construction.from_txt(c) for c in numerics],
+    )
+
+  def __init__(
+      self,
+      construction: Construction,
+      rely: dict[str, str],
+      deps: Clause,
+      basics: list[tuple[list[str], list[Construction]]],
+      numerics: list[Construction],
+  ):
+    self.construction = construction
+    self.rely = rely
+    self.deps = deps
+    self.basics = basics
+    self.numerics = numerics
+
+    args = set()
+    for num in numerics:
+      args.update(num.args)
+
+    self.points = []
+    self.args = []
+    for p in self.construction.args:
+      if p in args:
+        self.args.append(p)
+      else:
+        self.points.append(p)
+
+
+class Theorem:
+  """Deduction rule."""
+
+  @classmethod
+  def from_txt_file(cls, fname: str, to_dict: bool = False) -> Theorem:
+    with open(fname, 'r') as f:
+      theorems = f.read()
+    return cls.from_string(theorems, to_dict)
+
+  @classmethod
+  def from_string(cls, string: str, to_dict: bool = False) -> Theorem:
+    """Load deduction rule from a str object."""
+    theorems = string.split('\n')
+    theorems = [l for l in theorems if l and not l.startswith('#')]
+    theorems = [cls.from_txt(l) for l in theorems]
+
+    for i, th in enumerate(theorems):
+      th.rule_name = 'r{:02}'.format(i)
+
+    if to_dict:
+      result = {}
+      for t in theorems:
+        if t.name in result:
+          t.name += '_'
+        result[t.rule_name] = t
+
+      return result
+
+    return theorems
+
+  @classmethod
+  def from_txt(cls, data: str) -> Theorem:
+    premises, conclusion = data.split(' => ')
+    premises = premises.split(', ')
+    conclusion = conclusion.split(', ')
+    return Theorem(
+        premise=[Construction.from_txt(p) for p in premises],
+        conclusion=[Construction.from_txt(c) for c in conclusion],
+    )
+
+  def __init__(
+      self, premise: list[Construction], conclusion: list[Construction]
+  ):
+    if len(conclusion) != 1:
+      raise ValueError('Cannot have more than one conclusion')
+    self.name = '_'.join([p.name for p in premise + conclusion])
+    self.premise = premise
+    self.conclusion = conclusion
+    self.is_arg_reduce = False
+
+    assert len(self.conclusion) == 1
+    con = self.conclusion[0]
+
+    if con.name in [
+        'eqratio3',
+        'midp',
+        'contri',
+        'simtri',
+        'contri2',
+        'simtri2',
+        'simtri*',
+        'contri*',
+    ]:
+      return
+
+    prem_args = set(sum([p.args for p in self.premise], []))
+    con_args = set(con.args)
+    if len(prem_args) <= len(con_args):
+      self.is_arg_reduce = True
+
+  def txt(self) -> str:
+    premise_txt = ', '.join([clause.txt() for clause in self.premise])
+    conclusion_txt = ', '.join([clause.txt() for clause in self.conclusion])
+    return f'{premise_txt} => {conclusion_txt}'
+
+  def conclusion_name_args(
+      self, mapping: dict[str, gm.Point]
+  ) -> tuple[str, list[gm.Point]]:
+    mapping = {arg: p for arg, p in mapping.items() if isinstance(arg, str)}
+    c = self.conclusion[0]
+    args = [mapping[a] for a in c.args]
+    return c.name, args
+
+
+def why_eqratio(
+    d1: gm.Direction,
+    d2: gm.Direction,
+    d3: gm.Direction,
+    d4: gm.Direction,
+    level: int,
+) -> list[Dependency]:
+  """Why two ratios are equal, returns a Dependency objects."""
+  all12 = list(gm.all_ratios(d1, d2, level))
+  all34 = list(gm.all_ratios(d3, d4, level))
+
+  min_why = None
+  for ang12, d1s, d2s in all12:
+    for ang34, d3s, d4s in all34:
+      why0 = gm.why_equal(ang12, ang34, level)
+      if why0 is None:
+        continue
+      d1_, d2_ = ang12._l
+      d3_, d4_ = ang34._l
+      why1 = gm.bfs_backtrack(d1, [d1_], d1s)
+      why2 = gm.bfs_backtrack(d2, [d2_], d2s)
+      why3 = gm.bfs_backtrack(d3, [d3_], d3s)
+      why4 = gm.bfs_backtrack(d4, [d4_], d4s)
+      why = why0 + why1 + why2 + why3 + why4
+      if min_why is None or len(why) < len(min_why[0]):
+        min_why = why, ang12, ang34, why0, why1, why2, why3, why4
+
+  if min_why is None:
+    return None
+
+  _, ang12, ang34, why0, why1, why2, why3, why4 = min_why
+  d1_, d2_ = ang12._l
+  d3_, d4_ = ang34._l
+
+  if d1 == d1_ and d2 == d2_ and d3 == d3_ and d4 == d4_:
+    return why0
+
+  (a_, b_), (c_, d_) = d1_._obj.points, d2_._obj.points
+  (e_, f_), (g_, h_) = d3_._obj.points, d4_._obj.points
+  deps = []
+  if why0:
+    dep = Dependency('eqratio', [a_, b_, c_, d_, e_, f_, g_, h_], '', level)
+    dep.why = why0
+    deps.append(dep)
+
+  (a, b), (c, d) = d1._obj.points, d2._obj.points
+  (e, f), (g, h) = d3._obj.points, d4._obj.points
+  for why, (x, y), (x_, y_) in zip(
+      [why1, why2, why3, why4],
+      [(a, b), (c, d), (e, f), (g, h)],
+      [(a_, b_), (c_, d_), (e_, f_), (g_, h_)],
+  ):
+    if why:
+      dep = Dependency('cong', [x, y, x_, y_], '', level)
+      dep.why = why
+      deps.append(dep)
+
+  return deps
+
+
+def why_eqangle(
+    d1: gm.Direction,
+    d2: gm.Direction,
+    d3: gm.Direction,
+    d4: gm.Direction,
+    level: int,
+    verbose: bool = False,
+) -> list[Dependency]:
+  """Why two angles are equal, returns a Dependency objects."""
+  all12 = list(gm.all_angles(d1, d2, level))
+  all34 = list(gm.all_angles(d3, d4, level))
+
+  min_why = None
+  for ang12, d1s, d2s in all12:
+    for ang34, d3s, d4s in all34:
+      why0 = gm.why_equal(ang12, ang34, level)
+      if why0 is None:
+        continue
+      d1_, d2_ = ang12._d
+      d3_, d4_ = ang34._d
+      why1 = gm.bfs_backtrack(d1, [d1_], d1s)
+      why2 = gm.bfs_backtrack(d2, [d2_], d2s)
+      why3 = gm.bfs_backtrack(d3, [d3_], d3s)
+      why4 = gm.bfs_backtrack(d4, [d4_], d4s)
+      why = why0 + why1 + why2 + why3 + why4
+      if min_why is None or len(why) < len(min_why[0]):
+        min_why = why, ang12, ang34, why0, why1, why2, why3, why4
+
+  if min_why is None:
+    return None
+
+  _, ang12, ang34, why0, why1, why2, why3, why4 = min_why
+  why0 = gm.why_equal(ang12, ang34, level)
+  d1_, d2_ = ang12._d
+  d3_, d4_ = ang34._d
+
+  if d1 == d1_ and d2 == d2_ and d3 == d3_ and d4 == d4_:
+    return (d1_, d2_, d3_, d4_), why0
+
+  (a_, b_), (c_, d_) = d1_._obj.points, d2_._obj.points
+  (e_, f_), (g_, h_) = d3_._obj.points, d4_._obj.points
+  deps = []
+  if why0:
+    dep = Dependency('eqangle', [a_, b_, c_, d_, e_, f_, g_, h_], '', None)
+    dep.why = why0
+    deps.append(dep)
+
+  (a, b), (c, d) = d1._obj.points, d2._obj.points
+  (e, f), (g, h) = d3._obj.points, d4._obj.points
+  for why, d_xy, (x, y), d_xy_, (x_, y_) in zip(
+      [why1, why2, why3, why4],
+      [d1, d2, d3, d4],
+      [(a, b), (c, d), (e, f), (g, h)],
+      [d1_, d2_, d3_, d4_],
+      [(a_, b_), (c_, d_), (e_, f_), (g_, h_)],
+  ):
+    xy, xy_ = d_xy._obj, d_xy_._obj
+    if why:
+      if xy == xy_:
+        name = 'collx'
+      else:
+        name = 'para'
+      dep = Dependency(name, [x_, y_, x, y], '', None)
+      dep.why = why
+      deps.append(dep)
+
+  return (d1_, d2_, d3_, d4_), deps
+
+
+CONSTRUCTION_RULE = 'c0'
+
+
+class EmptyDependency:
+  """Empty dependency predicate ready to get filled up."""
+
+  def __init__(self, level: int, rule_name: str):
+    self.level = level
+    self.rule_name = rule_name or ''
+    self.empty = True
+    self.why = []
+    self.trace = None
+
+  def populate(self, name: str, args: list[gm.Point]) -> Dependency:
+    dep = Dependency(name, args, self.rule_name, self.level)
+    dep.trace2 = self.trace
+    dep.why = list(self.why)
+    return dep
+
+  def copy(self) -> EmptyDependency:
+    other = EmptyDependency(self.level, self.rule_name)
+    other.why = list(self.why)
+    return other
+
+  def extend(
+      self,
+      g: Any,
+      name0: str,
+      args0: list[gm.Point],
+      name: str,
+      args: list[gm.Point],
+  ) -> EmptyDependency:
+    """Extend the dependency list by (name, args)."""
+    dep0 = self.populate(name0, args0)
+    deps = EmptyDependency(level=self.level, rule_name=None)
+    dep = Dependency(name, args, None, deps.level)
+    deps.why = [dep0, dep.why_me_or_cache(g, None)]
+    return deps
+
+  def extend_many(
+      self,
+      g: Any,
+      name0: str,
+      args0: list[gm.Point],
+      name_args: list[tuple[str, list[gm.Point]]],
+  ) -> EmptyDependency:
+    """Extend the dependency list by many name_args."""
+    if not name_args:
+      return self
+    dep0 = self.populate(name0, args0)
+    deps = EmptyDependency(level=self.level, rule_name=None)
+    deps.why = [dep0]
+    for name, args in name_args:
+      dep = Dependency(name, args, None, deps.level)
+      deps.why += [dep.why_me_or_cache(g, None)]
+    return deps
+
+
+def maybe_make_equal_pairs(
+    a: gm.Point,
+    b: gm.Point,
+    c: gm.Point,
+    d: gm.Point,
+    m: gm.Point,
+    n: gm.Point,
+    p: gm.Point,
+    q: gm.Point,
+    ab: gm.Line,
+    mn: gm.Line,
+    g: Any,
+    level: int,
+) -> list[Dependency]:
+  """Make a-b:c-d==m-n:p-q in case a-b==m-n or c-d==p-q."""
+  if ab != mn:
+    return
+  why = []
+  eqname = 'para' if isinstance(ab, gm.Line) else 'cong'
+  colls = [a, b, m, n]
+  if len(set(colls)) > 2 and eqname == 'para':
+    dep = Dependency('collx', colls, None, level)
+    dep.why_me(g, level)
+    why += [dep]
+
+  dep = Dependency(eqname, [c, d, p, q], None, level)
+  dep.why_me(g, level)
+  why += [dep]
+  return why
+
+
+class Dependency(Construction):
+  """Dependency is a predicate that other predicates depend on."""
+
+  def __init__(
+      self, name: str, args: list[gm.Point], rule_name: str, level: int
+  ):
+    super().__init__(name, args)
+    self.rule_name = rule_name or ''
+    self.level = level
+    self.why = []
+
+    self._stat = None
+    self.trace = None
+
+  def _find(self, dep_hashed: tuple[str, ...]) -> Dependency:
+    for w in self.why:
+      f = w._find(dep_hashed)
+      if f:
+        return f
+      if w.hashed() == dep_hashed:
+        return w
+
+  def remove_loop(self) -> Dependency:
+    f = self._find(self.hashed())
+    if f:
+      return f
+    return self
+
+  def copy(self) -> Dependency:
+    dep = Dependency(self.name, self.args, self.rule_name, self.level)
+    dep.trace = self.trace
+    dep.why = list(self.why)
+    return dep
+
+  def why_me_or_cache(self, g: Any, level: int) -> Dependency:
+    if self.hashed() in g.cache:
+      return g.cache[self.hashed()]
+    self.why_me(g, level)
+    return self
+
+  def populate(self, name: str, args: list[gm.Point]) -> Dependency:
+    assert self.rule_name == CONSTRUCTION_RULE, self.rule_name
+    dep = Dependency(self.name, self.args, self.rule_name, self.level)
+    dep.why = list(self.why)
+    return dep
+
+  def why_me(self, g: Any, level: int) -> None:
+    """Figure out the dependencies predicates of self."""
+    name, args = self.name, self.args
+
+    hashed_me = hashed(name, args)
+    if hashed_me in g.cache:
+      dep = g.cache[hashed_me]
+      self.why = dep.why
+      self.rule_name = dep.rule_name
+      return
+
+    if self.name == 'para':
+      a, b, c, d = self.args
+      if {a, b} == {c, d}:
+        self.why = []
+        return
+
+      ab = g._get_line(a, b)
+      cd = g._get_line(c, d)
+      if ab == cd:
+        if {a, b} == {c, d}:
+          self.why = []
+          self.rule_name = ''
+          return
+        dep = Dependency('coll', list({a, b, c, d}), 't??', None)
+        self.why = [dep.why_me_or_cache(g, level)]
+        return
+
+      for (x, y), xy in zip([(a, b), (c, d)], [ab, cd]):
+        x_, y_ = xy.points
+        if {x, y} == {x_, y_}:
+          continue
+        d = Dependency('collx', [x, y, x_, y_], None, level)
+        self.why += [d.why_me_or_cache(g, level)]
+
+      whypara = g.why_equal(ab, cd, None)
+      self.why += whypara
+
+    elif self.name == 'midp':
+      m, a, b = self.args
+      ma = g._get_segment(m, a)
+      mb = g._get_segment(m, b)
+      dep = Dependency('coll', [m, a, b], None, None).why_me_or_cache(g, None)
+      self.why = [dep] + g.why_equal(ma, mb, level)
+
+    elif self.name == 'perp':
+      a, b, c, d = self.args
+      ab = g._get_line(a, b)
+      cd = g._get_line(c, d)
+      for (x, y), xy in zip([(a, b), (c, d)], [ab, cd]):
+        x_, y_ = xy.points
+        if {x, y} == {x_, y_}:
+          continue
+        d = Dependency('collx', [x, y, x_, y_], None, level)
+        self.why += [d.why_me_or_cache(g, level)]
+
+      _, why = why_eqangle(ab._val, cd._val, cd._val, ab._val, level)
+      a, b = ab.points
+      c, d = cd.points
+
+      if hashed(self.name, [a, b, c, d]) != self.hashed():
+        d = Dependency(self.name, [a, b, c, d], None, level)
+        d.why = why
+        why = [d]
+
+      self.why += why
+
+    elif self.name == 'cong':
+      a, b, c, d = self.args
+      ab = g._get_segment(a, b)
+      cd = g._get_segment(c, d)
+
+      self.why = g.why_equal(ab, cd, level)
+
+    elif self.name == 'coll':
+      _, why = gm.line_of_and_why(self.args, level)
+      self.why = why
+
+    elif self.name == 'collx':
+      if g.check_coll(self.args):
+        args = list(set(self.args))
+        hashed_me = hashed('coll', args)
+        if hashed_me in g.cache:
+          dep = g.cache[hashed_me]
+          self.why = [dep]
+          self.rule_name = ''
+          return
+        _, self.why = gm.line_of_and_why(args, level)
+      else:
+        self.name = 'para'
+        self.why_me(g, level)
+
+    elif self.name == 'cyclic':
+      _, why = gm.circle_of_and_why(self.args, level)
+      self.why = why
+
+    elif self.name == 'circle':
+      o, a, b, c = self.args
+      oa = g._get_segment(o, a)
+      ob = g._get_segment(o, b)
+      oc = g._get_segment(o, c)
+      self.why = g.why_equal(oa, ob, level) + g.why_equal(oa, oc, level)
+
+    elif self.name in ['eqangle', 'eqangle6']:
+      a, b, c, d, m, n, p, q = self.args
+
+      ab, why1 = g.get_line_thru_pair_why(a, b)
+      cd, why2 = g.get_line_thru_pair_why(c, d)
+      mn, why3 = g.get_line_thru_pair_why(m, n)
+      pq, why4 = g.get_line_thru_pair_why(p, q)
+
+      if ab is None or cd is None or mn is None or pq is None:
+        if {a, b} == {m, n}:
+          d = Dependency('para', [c, d, p, q], None, level)
+          self.why = [d.why_me_or_cache(g, level)]
+        if {a, b} == {c, d}:
+          d = Dependency('para', [p, q, m, n], None, level)
+          self.why = [d.why_me_or_cache(g, level)]
+        if {c, d} == {p, q}:
+          d = Dependency('para', [a, b, m, n], None, level)
+          self.why = [d.why_me_or_cache(g, level)]
+        if {p, q} == {m, n}:
+          d = Dependency('para', [a, b, c, d], None, level)
+          self.why = [d.why_me_or_cache(g, level)]
+        return
+
+      for (x, y), xy, whyxy in zip(
+          [(a, b), (c, d), (m, n), (p, q)],
+          [ab, cd, mn, pq],
+          [why1, why2, why3, why4],
+      ):
+        x_, y_ = xy.points
+        if {x, y} == {x_, y_}:
+          continue
+        d = Dependency('collx', [x, y, x_, y_], None, level)
+        d.why = whyxy
+        self.why += [d]
+
+      a, b = ab.points
+      c, d = cd.points
+      m, n = mn.points
+      p, q = pq.points
+      diff = hashed(self.name, [a, b, c, d, m, n, p, q]) != self.hashed()
+
+      whyeqangle = None
+      if ab._val and cd._val and mn._val and pq._val:
+        whyeqangle = why_eqangle(ab._val, cd._val, mn._val, pq._val, level)
+
+      if whyeqangle:
+        (dab, dcd, dmn, dpq), whyeqangle = whyeqangle
+        if diff:
+          d = Dependency('eqangle', [a, b, c, d, m, n, p, q], None, level)
+          d.why = whyeqangle
+          whyeqangle = [d]
+        self.why += whyeqangle
+
+      else:
+        if (ab == cd and mn == pq) or (ab == mn and cd == pq):
+          self.why += []
+        elif ab == mn:
+          self.why += maybe_make_equal_pairs(
+              a, b, c, d, m, n, p, q, ab, mn, g, level
+          )
+        elif cd == pq:
+          self.why += maybe_make_equal_pairs(
+              c, d, a, b, p, q, m, n, cd, pq, g, level
+          )
+        elif ab == cd:
+          self.why += maybe_make_equal_pairs(
+              a, b, m, n, c, d, p, q, ab, cd, g, level
+          )
+        elif mn == pq:
+          self.why += maybe_make_equal_pairs(
+              m, n, a, b, p, q, c, d, mn, pq, g, level
+          )
+        elif g.is_equal(ab, mn) or g.is_equal(cd, pq):
+          dep1 = Dependency('para', [a, b, m, n], None, level)
+          dep1.why_me(g, level)
+          dep2 = Dependency('para', [c, d, p, q], None, level)
+          dep2.why_me(g, level)
+          self.why += [dep1, dep2]
+        elif g.is_equal(ab, cd) or g.is_equal(mn, pq):
+          dep1 = Dependency('para', [a, b, c, d], None, level)
+          dep1.why_me(g, level)
+          dep2 = Dependency('para', [m, n, p, q], None, level)
+          dep2.why_me(g, level)
+          self.why += [dep1, dep2]
+        elif ab._val and cd._val and mn._val and pq._val:
+          self.why = why_eqangle(ab._val, cd._val, mn._val, pq._val, level)
+
+    elif self.name in ['eqratio', 'eqratio6']:
+      a, b, c, d, m, n, p, q = self.args
+      ab = g._get_segment(a, b)
+      cd = g._get_segment(c, d)
+      mn = g._get_segment(m, n)
+      pq = g._get_segment(p, q)
+
+      if ab is None or cd is None or mn is None or pq is None:
+        if {a, b} == {m, n}:
+          d = Dependency('cong', [c, d, p, q], None, level)
+          self.why = [d.why_me_or_cache(g, level)]
+        if {a, b} == {c, d}:
+          d = Dependency('cong', [p, q, m, n], None, level)
+          self.why = [d.why_me_or_cache(g, level)]
+        if {c, d} == {p, q}:
+          d = Dependency('cong', [a, b, m, n], None, level)
+          self.why = [d.why_me_or_cache(g, level)]
+        if {p, q} == {m, n}:
+          d = Dependency('cong', [a, b, c, d], None, level)
+          self.why = [d.why_me_or_cache(g, level)]
+        return
+
+      if ab._val and cd._val and mn._val and pq._val:
+        self.why = why_eqratio(ab._val, cd._val, mn._val, pq._val, level)
+
+      if self.why is None:
+        self.why = []
+        if (ab == cd and mn == pq) or (ab == mn and cd == pq):
+          self.why = []
+        elif ab == mn:
+          self.why += maybe_make_equal_pairs(
+              a, b, c, d, m, n, p, q, ab, mn, g, level
+          )
+        elif cd == pq:
+          self.why += maybe_make_equal_pairs(
+              c, d, a, b, p, q, m, n, cd, pq, g, level
+          )
+        elif ab == cd:
+          self.why += maybe_make_equal_pairs(
+              a, b, m, n, c, d, p, q, ab, cd, g, level
+          )
+        elif mn == pq:
+          self.why += maybe_make_equal_pairs(
+              m, n, a, b, p, q, c, d, mn, pq, g, level
+          )
+        elif g.is_equal(ab, mn) or g.is_equal(cd, pq):
+          dep1 = Dependency('cong', [a, b, m, n], None, level)
+          dep1.why_me(g, level)
+          dep2 = Dependency('cong', [c, d, p, q], None, level)
+          dep2.why_me(g, level)
+          self.why += [dep1, dep2]
+        elif g.is_equal(ab, cd) or g.is_equal(mn, pq):
+          dep1 = Dependency('cong', [a, b, c, d], None, level)
+          dep1.why_me(g, level)
+          dep2 = Dependency('cong', [m, n, p, q], None, level)
+          dep2.why_me(g, level)
+          self.why += [dep1, dep2]
+        elif ab._val and cd._val and mn._val and pq._val:
+          self.why = why_eqangle(ab._val, cd._val, mn._val, pq._val, level)
+
+    elif self.name in ['diff', 'npara', 'nperp', 'ncoll', 'sameside']:
+      self.why = []
+
+    elif self.name == 'simtri':
+      a, b, c, x, y, z = self.args
+      dep1 = Dependency('eqangle', [a, b, a, c, x, y, x, z], '', level)
+      dep1.why_me(g, level)
+      dep2 = Dependency('eqangle', [b, a, b, c, y, x, y, z], '', level)
+      dep2.why_me(g, level)
+      self.rule_name = 'r34'
+      self.why = [dep1, dep2]
+
+    elif self.name == 'contri':
+      a, b, c, x, y, z = self.args
+      dep1 = Dependency('cong', [a, b, x, y], '', level)
+      dep1.why_me(g, level)
+      dep2 = Dependency('cong', [b, c, y, z], '', level)
+      dep2.why_me(g, level)
+      dep3 = Dependency('cong', [c, a, z, x], '', level)
+      dep3.why_me(g, level)
+      self.rule_name = 'r32'
+      self.why = [dep1, dep2, dep3]
+
+    elif self.name == 'ind':
+      pass
+
+    elif self.name == 'aconst':
+      a, b, c, d, ang0 = self.args
+
+      measure = ang0._val
+
+      for ang in measure.neighbors(gm.Angle):
+        if ang == ang0:
+          continue
+        d1, d2 = ang._d
+        l1, l2 = d1._obj, d2._obj
+        (a1, b1), (c1, d1) = l1.points, l2.points
+
+        if not g.check_para_or_coll([a, b, a1, b1]) or not g.check_para_or_coll(
+            [c, d, c1, d1]
+        ):
+          continue
+
+        self.why = []
+        for args in [(a, b, a1, b1), (c, d, c1, d1)]:
+          if g.check_coll(args):
+            if len(set(args)) > 2:
+              dep = Dependency('coll', args, None, None)
+              self.why.append(dep.why_me_or_cache(g, level))
+          else:
+            dep = Dependency('para', args, None, None)
+            self.why.append(dep.why_me_or_cache(g, level))
+
+        self.why += gm.why_equal(ang, ang0)
+        break
+
+    elif self.name == 'rconst':
+      a, b, c, d, rat0 = self.args
+
+      val = rat0._val
+
+      for rat in val.neighbors(gm.Ratio):
+        if rat == rat0:
+          continue
+        l1, l2 = rat._l
+        s1, s2 = l1._obj, l2._obj
+        (a1, b1), (c1, d1) = list(s1.points), list(s2.points)
+
+        if not g.check_cong([a, b, a1, b1]) or not g.check_cong([c, d, c1, d1]):
+          continue
+
+        self.why = []
+        for args in [(a, b, a1, b1), (c, d, c1, d1)]:
+          if len(set(args)) > 2:
+            dep = Dependency('cong', args, None, None)
+            self.why.append(dep.why_me_or_cache(g, level))
+
+        self.why += gm.why_equal(rat, rat0)
+        break
+
+    else:
+      raise ValueError('Not recognize', self.name)
+
+  def hashed(self, rename: bool = False) -> tuple[str, ...]:
+    return hashed(self.name, self.args, rename=rename)
+
+
+def hashed(
+    name: str, args: list[gm.Point], rename: bool = False
+) -> tuple[str, ...]:
+  if name == 's_angle':
+    args = [p.name if not rename else p.new_name for p in args[:-1]] + [
+        str(args[-1])
+    ]
+  else:
+    args = [p.name if not rename else p.new_name for p in args]
+  return hashed_txt(name, args)
+
+
+def hashed_txt(name: str, args: list[str]) -> tuple[str, ...]:
+  """Return a tuple unique to name and args upto arg permutation equivariant."""
+
+  if name in ['const', 'aconst', 'rconst']:
+    a, b, c, d, y = args
+    a, b = sorted([a, b])
+    c, d = sorted([c, d])
+    return name, a, b, c, d, y
+
+  if name in ['npara', 'nperp', 'para', 'cong', 'perp', 'collx']:
+    a, b, c, d = args
+
+    a, b = sorted([a, b])
+    c, d = sorted([c, d])
+    (a, b), (c, d) = sorted([(a, b), (c, d)])
+
+    return (name, a, b, c, d)
+
+  if name in ['midp', 'midpoint']:
+    a, b, c = args
+    b, c = sorted([b, c])
+    return (name, a, b, c)
+
+  if name in ['coll', 'cyclic', 'ncoll', 'diff', 'triangle']:
+    return (name,) + tuple(sorted(list(set(args))))
+
+  if name == 'circle':
+    x, a, b, c = args
+    return (name, x) + tuple(sorted([a, b, c]))
+
+  if name in ['eqangle', 'eqratio', 'eqangle6', 'eqratio6']:
+    a, b, c, d, e, f, g, h = args
+    a, b = sorted([a, b])
+    c, d = sorted([c, d])
+    e, f = sorted([e, f])
+    g, h = sorted([g, h])
+    if tuple(sorted([a, b, e, f])) > tuple(sorted([c, d, g, h])):
+      a, b, e, f, c, d, g, h = c, d, g, h, a, b, e, f
+    if (a, b, c, d) > (e, f, g, h):
+      a, b, c, d, e, f, g, h = e, f, g, h, a, b, c, d
+
+    if name == 'eqangle6':
+      name = 'eqangle'
+    if name == 'eqratio6':
+      name = 'eqratio'
+    return (name,) + (a, b, c, d, e, f, g, h)
+
+  if name in ['contri', 'simtri', 'simtri2', 'contri2', 'contri*', 'simtri*']:
+    a, b, c, x, y, z = args
+    (a, x), (b, y), (c, z) = sorted([(a, x), (b, y), (c, z)], key=sorted)
+    (a, b, c), (x, y, z) = sorted([(a, b, c), (x, y, z)], key=sorted)
+    return (name, a, b, c, x, y, z)
+
+  if name in ['eqratio3']:
+    a, b, c, d, o, o = args  # pylint: disable=redeclared-assigned-name
+    (a, c), (b, d) = sorted([(a, c), (b, d)], key=sorted)
+    (a, b), (c, d) = sorted([(a, b), (c, d)], key=sorted)
+    return (name, a, b, c, d, o, o)
+
+  if name in ['sameside', 's_angle']:
+    return (name,) + tuple(args)
+
+  raise ValueError(f'Not recognize {name} to hash.')

ag4masses/alphageometry/problem_test.py

@@ -0,0 +1,61 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Unit tests for problem.py."""
+import unittest
+
+from absl.testing import absltest
+import problem as pr
+
+
+class ProblemTest(unittest.TestCase):
+
+  @classmethod
+  def setUpClass(cls):
+    super().setUpClass()
+    cls.defs = pr.Definition.from_txt_file('defs.txt', to_dict=True)
+
+  def test_orthocenter_no_translate(self):
+    txt = 'a b c = triangle a b c; h = on_tline h b a c, on_tline h c a b ? perp a h b c'  # pylint: disable=line-too-long
+
+    # read the txt into pr.Problem object, do not change the name of points:
+    p = pr.Problem.from_txt(txt, translate=False)
+
+    # This is fed into the LM, translating from constructive to constrained:
+    setup_str = p.setup_str_from_problem(ProblemTest.defs)
+
+    self.assertEqual(
+        setup_str,
+        '{S} a : ; b : ; c : ; h : T a b c h 00 T a c b h 01 ? T a h b c',
+    )
+
+  def test_orthocenter_translate(self):
+    txt = 'a b c = triangle a b c; h = on_tline h b a c, on_tline h c a b ? perp a h b c'  # pylint: disable=line-too-long
+
+    # Read the txt into pr.Problem object, change h -> d to match
+    # training data distribution.
+    p = pr.Problem.from_txt(txt, translate=True)
+
+    # This is fed into the LM, translating from constructive to constrained:
+    setup_str = p.setup_str_from_problem(ProblemTest.defs)
+
+    self.assertEqual(
+        setup_str,
+        '{S} a : ; b : ; c : ; d : T a b c d 00 T a c b d 01 ? T a d b c',
+    )
+
+
+if __name__ == '__main__':
+  absltest.main()

ag4masses/alphageometry/rules.txt

@@ -0,0 +1,43 @@
+perp A B C D, perp C D E F, ncoll A B E => para A B E F
+cong O A O B, cong O B O C, cong O C O D => cyclic A B C D
+eqangle A B P Q C D P Q => para A B C D
+cyclic A B P Q => eqangle P A P B Q A Q B
+eqangle6 P A P B Q A Q B, ncoll P Q A B => cyclic A B P Q
+cyclic A B C P Q R, eqangle C A C B R P R Q => cong A B P Q
+midp E A B, midp F A C => para E F B C
+para A B C D, coll O A C, coll O B D => eqratio3 A B C D O O
+perp A B C D, perp E F G H, npara A B E F => eqangle A B E F C D G H
+eqangle a b c d m n p q, eqangle c d e f p q r u => eqangle a b e f m n r u
+eqratio a b c d m n p q, eqratio c d e f p q r u => eqratio a b e f m n r u
+eqratio6 d b d c a b a c, coll d b c, ncoll a b c => eqangle6 a b a d a d a c
+eqangle6 a b a d a d a c, coll d b c, ncoll a b c => eqratio6 d b d c a b a c
+cong O A O B, ncoll O A B => eqangle O A A B A B O B
+eqangle6 A O A B B A B O, ncoll O A B => cong O A O B
+circle O A B C, perp O A A X => eqangle A X A B C A C B
+circle O A B C, eqangle A X A B C A C B => perp O A A X
+circle O A B C, midp M B C => eqangle A B A C O B O M
+circle O A B C, coll M B C, eqangle A B A C O B O M => midp M B C
+perp A B B C, midp M A C => cong A M B M
+circle O A B C, coll O A C => perp A B B C
+cyclic A B C D, para A B C D => eqangle A D C D C D C B
+midp M A B, perp O M A B => cong O A O B
+cong A P B P, cong A Q B Q => perp A B P Q
+cong A P B P, cong A Q B Q, cyclic A B P Q => perp P A A Q
+midp M A B, midp M C D => para A C B D
+midp M A B, para A C B D, para A D B C => midp M C D
+eqratio O A A C O B B D, coll O A C, coll O B D, ncoll A B C, sameside A O C B O D => para A B C D
+para A B A C => coll A B C
+midp M A B, midp N C D => eqratio M A A B N C C D
+eqangle A B P Q C D U V, perp P Q U V => perp A B C D
+eqratio A B P Q C D U V, cong P Q U V => cong A B C D
+cong A B P Q, cong B C Q R, cong C A R P, ncoll A B C => contri* A B C P Q R
+cong A B P Q, cong B C Q R, eqangle6 B A B C Q P Q R, ncoll A B C => contri* A B C P Q R
+eqangle6 B A B C Q P Q R, eqangle6 C A C B R P R Q, ncoll A B C => simtri A B C P Q R
+eqangle6 B A B C Q R Q P, eqangle6 C A C B R Q R P, ncoll A B C => simtri2 A B C P Q R
+eqangle6 B A B C Q P Q R, eqangle6 C A C B R P R Q, ncoll A B C, cong A B P Q => contri A B C P Q R
+eqangle6 B A B C Q R Q P, eqangle6 C A C B R Q R P, ncoll A B C, cong A B P Q => contri2 A B C P Q R
+eqratio6 B A B C Q P Q R, eqratio6 C A C B R P R Q, ncoll A B C => simtri* A B C P Q R
+eqratio6 B A B C Q P Q R, eqangle6 B A B C Q P Q R, ncoll A B C => simtri* A B C P Q R
+eqratio6 B A B C Q P Q R, eqratio6 C A C B R P R Q, ncoll A B C, cong A B P Q => contri* A B C P Q R
+para a b c d, coll m a d, coll n b c, eqratio6 m a m d n b n c, sameside m a d n b c => para m n a b
+para a b c d, coll m a d, coll n b c, para m n a b => eqratio6 m a m d n b n c

ag4masses/alphageometry/trace_back.py

@@ -0,0 +1,374 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Implements DAG-level traceback."""
+
+from typing import Any
+
+import geometry as gm
+import pretty as pt
+import problem
+
+
+pretty = pt.pretty
+
+
+def point_levels(
+    setup: list[problem.Dependency], existing_points: list[gm.Point]
+) -> list[tuple[set[gm.Point], list[problem.Dependency]]]:
+  """Reformat setup into levels of point constructions."""
+  levels = []
+  for con in setup:
+    plevel = max([p.plevel for p in con.args if isinstance(p, gm.Point)])
+
+    while len(levels) - 1 < plevel:
+      levels.append((set(), []))
+
+    for p in con.args:
+      if not isinstance(p, gm.Point):
+        continue
+      if existing_points and p in existing_points:
+        continue
+
+      levels[p.plevel][0].add(p)
+
+    cons = levels[plevel][1]
+    cons.append(con)
+
+  return [(p, c) for p, c in levels if p or c]
+
+
+def point_log(
+    setup: list[problem.Dependency],
+    ref_id: dict[tuple[str, ...], int],
+    existing_points=list[gm.Point],
+) -> list[tuple[list[gm.Point], list[problem.Dependency]]]:
+  """Reformat setup into groups of point constructions."""
+  log = []
+
+  levels = point_levels(setup, existing_points)
+
+  for points, cons in levels:
+    for con in cons:
+      if con.hashed() not in ref_id:
+        ref_id[con.hashed()] = len(ref_id)
+
+    log.append((points, cons))
+
+  return log
+
+
+def setup_to_levels(
+    setup: list[problem.Dependency],
+) -> list[list[problem.Dependency]]:
+  """Reformat setup into levels of point constructions."""
+  levels = []
+  for d in setup:
+    plevel = max([p.plevel for p in d.args if isinstance(p, gm.Point)])
+    while len(levels) - 1 < plevel:
+      levels.append([])
+
+    levels[plevel].append(d)
+
+  levels = [lvl for lvl in levels if lvl]
+  return levels
+
+
+def separate_dependency_difference(
+    query: problem.Dependency,
+    log: list[tuple[list[problem.Dependency], list[problem.Dependency]]],
+) -> tuple[
+    list[tuple[list[problem.Dependency], list[problem.Dependency]]],
+    list[problem.Dependency],
+    list[problem.Dependency],
+    set[gm.Point],
+    set[gm.Point],
+]:
+  """Identify and separate the dependency difference."""
+  setup = []
+  log_, log = log, []
+  for prems, cons in log_:
+    if not prems:
+      setup.extend(cons)
+      continue
+    cons_ = []
+    for con in cons:
+      if con.rule_name == 'c0':
+        setup.append(con)
+      else:
+        cons_.append(con)
+    if not cons_:
+      continue
+
+    prems = [p for p in prems if p.name != 'ind']
+    log.append((prems, cons_))
+
+  points = set(query.args)
+  queue = list(query.args)
+  i = 0
+  while i < len(queue):
+    q = queue[i]
+    i += 1
+    if not isinstance(q, gm.Point):
+      continue
+    for p in q.rely_on:
+      if p not in points:
+        points.add(p)
+        queue.append(p)
+
+  setup_, setup, aux_setup, aux_points = setup, [], [], set()
+  for con in setup_:
+    if con.name == 'ind':
+      continue
+    elif any([p not in points for p in con.args if isinstance(p, gm.Point)]):
+      aux_setup.append(con)
+      aux_points.update(
+          [p for p in con.args if isinstance(p, gm.Point) and p not in points]
+      )
+    else:
+      setup.append(con)
+
+  return log, setup, aux_setup, points, aux_points
+
+
+def recursive_traceback(
+    query: problem.Dependency,
+) -> list[tuple[list[problem.Dependency], list[problem.Dependency]]]:
+  """Recursively traceback from the query, i.e. the conclusion."""
+  visited = set()
+  log = []
+  stack = []
+
+  def read(q: problem.Dependency) -> None:
+    q = q.remove_loop()
+    hashed = q.hashed()
+    if hashed in visited:
+      return
+
+    if hashed[0] in ['ncoll', 'npara', 'nperp', 'diff', 'sameside']:
+      return
+
+    nonlocal stack
+
+    stack.append(hashed)
+    prems = []
+
+    if q.rule_name != problem.CONSTRUCTION_RULE:
+      all_deps = []
+      dep_names = set()
+      for d in q.why:
+        if d.hashed() in dep_names:
+          continue
+        dep_names.add(d.hashed())
+        all_deps.append(d)
+
+      for d in all_deps:
+        h = d.hashed()
+        if h not in visited:
+          read(d)
+        if h in visited:
+          prems.append(d)
+
+    visited.add(hashed)
+    hashs = sorted([d.hashed() for d in prems])
+    found = False
+    for ps, qs in log:
+      if sorted([d.hashed() for d in ps]) == hashs:
+        qs += [q]
+        found = True
+        break
+    if not found:
+      log.append((prems, [q]))
+
+    stack.pop(-1)
+
+  read(query)
+
+  # post process log: separate multi-conclusion lines
+  log_, log = log, []
+  for ps, qs in log_:
+    for q in qs:
+      log.append((ps, [q]))
+
+  return log
+
+
+def collx_to_coll_setup(
+    setup: list[problem.Dependency],
+) -> list[problem.Dependency]:
+  """Convert collx to coll in setups."""
+  result = []
+  for level in setup_to_levels(setup):
+    hashs = set()
+    for dep in level:
+      if dep.name == 'collx':
+        dep.name = 'coll'
+        dep.args = list(set(dep.args))
+
+      if dep.hashed() in hashs:
+        continue
+      hashs.add(dep.hashed())
+      result.append(dep)
+
+  return result
+
+
+def collx_to_coll(
+    setup: list[problem.Dependency],
+    aux_setup: list[problem.Dependency],
+    log: list[tuple[list[problem.Dependency], list[problem.Dependency]]],
+) -> tuple[
+    list[problem.Dependency],
+    list[problem.Dependency],
+    list[tuple[list[problem.Dependency], list[problem.Dependency]]],
+]:
+  """Convert collx to coll and dedup."""
+  setup = collx_to_coll_setup(setup)
+  aux_setup = collx_to_coll_setup(aux_setup)
+
+  con_set = set([p.hashed() for p in setup + aux_setup])
+  log_, log = log, []
+  for prems, cons in log_:
+    prem_set = set()
+    prems_, prems = prems, []
+    for p in prems_:
+      if p.name == 'collx':
+        p.name = 'coll'
+        p.args = list(set(p.args))
+      if p.hashed() in prem_set:
+        continue
+      prem_set.add(p.hashed())
+      prems.append(p)
+
+    cons_, cons = cons, []
+    for c in cons_:
+      if c.name == 'collx':
+        c.name = 'coll'
+        c.args = list(set(c.args))
+      if c.hashed() in con_set:
+        continue
+      con_set.add(c.hashed())
+      cons.append(c)
+
+    if not cons or not prems:
+      continue
+
+    log.append((prems, cons))
+
+  return setup, aux_setup, log
+
+
+def get_logs(
+    query: problem.Dependency, g: Any, merge_trivials: bool = False
+) -> tuple[
+    list[problem.Dependency],
+    list[problem.Dependency],
+    list[tuple[list[problem.Dependency], list[problem.Dependency]]],
+    set[gm.Point],
+]:
+  """Given a DAG and conclusion N, return the premise, aux, proof."""
+  query = query.why_me_or_cache(g, query.level)
+  log = recursive_traceback(query)
+  log, setup, aux_setup, setup_points, _ = separate_dependency_difference(
+      query, log
+  )
+
+  setup, aux_setup, log = collx_to_coll(setup, aux_setup, log)
+
+  setup, aux_setup, log = shorten_and_shave(
+      setup, aux_setup, log, merge_trivials
+  )
+
+  return setup, aux_setup, log, setup_points
+
+
+def shorten_and_shave(
+    setup: list[problem.Dependency],
+    aux_setup: list[problem.Dependency],
+    log: list[tuple[list[problem.Dependency], list[problem.Dependency]]],
+    merge_trivials: bool = False,
+) -> tuple[
+    list[problem.Dependency],
+    list[problem.Dependency],
+    list[tuple[list[problem.Dependency], list[problem.Dependency]]],
+]:
+  """Shorten the proof by removing unused predicates."""
+  log, _ = shorten_proof(log, merge_trivials=merge_trivials)
+
+  all_prems = sum([list(prems) for prems, _ in log], [])
+  all_prems = set([p.hashed() for p in all_prems])
+  setup = [d for d in setup if d.hashed() in all_prems]
+  aux_setup = [d for d in aux_setup if d.hashed() in all_prems]
+  return setup, aux_setup, log
+
+
+def join_prems(
+    con: problem.Dependency,
+    con2prems: dict[tuple[str, ...], list[problem.Dependency]],
+    expanded: set[tuple[str, ...]],
+) -> list[problem.Dependency]:
+  """Join proof steps with the same premises."""
+  h = con.hashed()
+  if h in expanded or h not in con2prems:
+    return [con]
+
+  result = []
+  for p in con2prems[h]:
+    result += join_prems(p, con2prems, expanded)
+  return result
+
+
+def shorten_proof(
+    log: list[tuple[list[problem.Dependency], list[problem.Dependency]]],
+    merge_trivials: bool = False,
+) -> tuple[
+    list[tuple[list[problem.Dependency], list[problem.Dependency]]],
+    dict[tuple[str, ...], list[problem.Dependency]],
+]:
+  """Join multiple trivials proof steps into one."""
+  pops = set()
+  con2prem = {}
+  for prems, cons in log:
+    assert len(cons) == 1
+    con = cons[0]
+    if con.rule_name == '':  # pylint: disable=g-explicit-bool-comparison
+      con2prem[con.hashed()] = prems
+    elif not merge_trivials:
+      # except for the ones that are premises to non-trivial steps.
+      pops.update({p.hashed() for p in prems})
+
+  for p in pops:
+    if p in con2prem:
+      con2prem.pop(p)
+
+  expanded = set()
+  log2 = []
+  for i, (prems, cons) in enumerate(log):
+    con = cons[0]
+    if i < len(log) - 1 and con.hashed() in con2prem:
+      continue
+
+    hashs = set()
+    new_prems = []
+
+    for p in sum([join_prems(p, con2prem, expanded) for p in prems], []):
+      if p.hashed() not in hashs:
+        new_prems.append(p)
+        hashs.add(p.hashed())
+
+    log2 += [(new_prems, [con])]
+    expanded.add(con.hashed())
+
+  return log2, con2prem

ag4masses/alphageometry/trace_back_test.py

@@ -0,0 +1,61 @@
+# Copyright 2023 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Unit testing for the trace_back code."""
+
+import unittest
+
+from absl.testing import absltest
+import ddar
+import graph as gh
+import problem as pr
+import trace_back as tb
+
+
+class TracebackTest(unittest.TestCase):
+
+  @classmethod
+  def setUpClass(cls):
+    super().setUpClass()
+    cls.defs = pr.Definition.from_txt_file('defs.txt', to_dict=True)
+    cls.rules = pr.Theorem.from_txt_file('rules.txt', to_dict=True)
+
+  def test_orthocenter_dependency_difference(self):
+    txt = 'a b c = triangle a b c; d = on_tline d b a c, on_tline d c a b; e = on_line e a c, on_line e b d ? perp a d b c'  # pylint: disable=line-too-long
+    p = pr.Problem.from_txt(txt)
+    g, _ = gh.Graph.build_problem(p, TracebackTest.defs)
+
+    ddar.solve(g, TracebackTest.rules, p)
+
+    goal_args = g.names2nodes(p.goal.args)
+    query = pr.Dependency(p.goal.name, goal_args, None, None)
+
+    setup, aux, _, _ = tb.get_logs(query, g, merge_trivials=False)
+
+    # Convert each predicates to its hash string:
+    setup = [p.hashed() for p in setup]
+    aux = [p.hashed() for p in aux]
+
+    self.assertCountEqual(
+        setup, [('perp', 'a', 'c', 'b', 'd'), ('perp', 'a', 'b', 'c', 'd')]
+    )
+
+    self.assertCountEqual(
+        aux, [('coll', 'a', 'c', 'e'), ('coll', 'b', 'd', 'e')]
+    )
+
+
+if __name__ == '__main__':
+  absltest.main()