Method dump_rule_rhs_first_diff

crates/kernel/src/inductive.rs:1593–1658

(
    &mut self,
    lhs: &KExpr<M>,
    rhs: &KExpr<M>,
    path: &str,
    depth: u64,
  )

      rec_ids.len()
    );
    log::info!(
      "  failed gen major: {}",
      Self::major_domain_signature_text(failed_gen_major)
    );
    log::info!(
      "  failed stored major: {}",
      Self::major_domain_signature_text(failed_stored_major)
    );
    let n = generated_snapshot.len().min(flat.len()).min(rec_ids.len());
    for gi in 0..n {
      let gen_rec = &generated_snapshot[gi];
      let target_addr = &gen_rec.ind_addr;
      let gen_major = self
        .recursor_major_domain_for_addr(
          &gen_rec.ty,
          prefix_base + flat[gi].n_indices,
          target_addr,
        )
        .unwrap_or(None);
      let rid = &rec_ids[gi];
      let (stored_skip, stored_ty) =
        match self.try_get_const(rid).ok().flatten() {
          Some(KConst::Recr {
            params, motives, minors, indices, ty, ..
          }) => (params + motives + minors + indices, Some(ty.clone())),
          _ => (0, None),
        };
      let stored_major = match stored_ty {
        Some(ty) => self
          .recursor_major_domain_for_addr(&ty, stored_skip, target_addr)
          .unwrap_or(None),
        None => None,
      };
      let mark = if gi == failed_gi { "!!" } else { "  " };
      log::info!(
        "  {mark} peer[{gi:2}] flat.id={} target={}… aux={} ind={}…",
        flat[gi].id,
        &target_addr.hex()[..8],
        flat[gi].is_aux,
        &gen_rec.ind_addr.hex()[..8]
      );
      log::info!(
        "       gen   : {}",
        Self::major_domain_signature_text(gen_major.as_ref())
      );
      log::info!(
        "       sto   : {} (rid={})",
        Self::major_domain_signature_text(stored_major.as_ref()),
        rid
      );
    }
  }

  fn dump_rule_rhs_first_diff(
    &mut self,
    lhs: &KExpr<M>,
    rhs: &KExpr<M>,
    path: &str,