packages feed

twee 2.1 → 2.1.1

raw patch · 39 files changed

+3110/−629 lines, 39 filesdep ~twee-lib

Dependency ranges changed: twee-lib

Files

− Main.hs 
@@ -1,625 +0,0 @@-{-# LANGUAGE CPP, RecordWildCards, FlexibleInstances, PatternGuards #-}-import Control.Monad-import Data.Char-import Data.Either-import Twee hiding (message)-import Twee.Base hiding (char, lookup, vars)-import Twee.Rule(lhs, rhs, unorient)-import Twee.Equation-import qualified Twee.Proof as Proof-import Twee.Proof hiding (Config, defaultConfig)-import qualified Twee.Join as Join-import Twee.Utils-import qualified Twee.CP as CP-import Data.Ord-import qualified Data.Map.Strict as Map-import qualified Twee.KBO as KBO-import Data.List.Split-import Data.List-import Data.Maybe-import Jukebox.Options-import Jukebox.Toolbox-import Jukebox.Name hiding (lhs, rhs)-import qualified Jukebox.Form as Jukebox-import Jukebox.Form hiding ((:=:), Var, Symbolic(..), Term, Axiom, size, Lemma)-import Jukebox.Tools.EncodeTypes-import Jukebox.TPTP.Print-import Jukebox.Tools.HornToUnit-import qualified Data.IntMap.Strict as IntMap-import System.IO-import System.Exit-import qualified Data.Set as Set--data MainFlags =-  MainFlags {-    flags_proof :: Bool,-    flags_trace :: Maybe (String, String) }--parseMainFlags :: OptionParser MainFlags-parseMainFlags =-  MainFlags <$> proof <*> trace-  where-    proof =-      inGroup "Output options" $-      bool "proof" ["Produce proofs (on by default)."]-      True-    trace =-      expert $-      inGroup "Output options" $-      flag "trace"-        ["Write a Prolog-format execution trace to this file (off by default)."]-        Nothing ((\x y -> Just (x, y)) <$> argFile <*> argModule)-    argModule = arg "<module>" "expected a Prolog module name" Just--parseConfig :: OptionParser Config-parseConfig =-  Config <$> maxSize <*> maxCPs <*> maxCPDepth <*> simplify <*> normPercent <*>-    (CP.Config <$> lweight <*> rweight <*> funweight <*> varweight <*> depthweight <*> dupcost <*> dupfactor) <*>-    (Join.Config <$> ground_join <*> connectedness <*> set_join) <*>-    (Proof.Config <$> all_lemmas <*> flat_proof <*> show_instances)-  where-    maxSize =-      inGroup "Resource limits" $-      flag "max-term-size" ["Discard rewrite rules whose left-hand side is bigger than this limit (unlimited by default)."] maxBound argNum-    maxCPs =-      inGroup "Resource limits" $-      flag "max-cps" ["Give up after considering this many critical pairs (unlimited by default)."] maxBound argNum-    maxCPDepth =-      inGroup "Resource limits" $-      flag "max-cp-depth" ["Only consider critical pairs up to this depth (unlimited by default)."] maxBound argNum-    simplify =-      expert $-      inGroup "Completion heuristics" $-      bool "simplify"-        ["Simplify rewrite rules with respect to one another (on by default)."]-        True-    normPercent =-      expert $-      inGroup "Completion heuristics" $-      defaultFlag "normalise-queue-percent" "Percent of time spent renormalising queued critical pairs" (cfg_renormalise_percent) argNum-    lweight =-      expert $-      inGroup "Critical pair weighting heuristics" $-      defaultFlag "lhs-weight" "Weight given to LHS of critical pair" (CP.cfg_lhsweight . cfg_critical_pairs) argNum-    rweight =-      expert $-      inGroup "Critical pair weighting heuristics" $-      defaultFlag "rhs-weight" "Weight given to RHS of critical pair" (CP.cfg_rhsweight . cfg_critical_pairs) argNum-    funweight =-      expert $-      inGroup "Critical pair weighting heuristics" $-      defaultFlag "fun-weight" "Weight given to function symbols" (CP.cfg_funweight . cfg_critical_pairs) argNum-    varweight =-      expert $-      inGroup "Critical pair weighting heuristics" $-      defaultFlag "var-weight" "Weight given to variable symbols" (CP.cfg_varweight . cfg_critical_pairs) argNum-    depthweight =-      expert $-      inGroup "Critical pair weighting heuristics" $-      defaultFlag "depth-weight" "Weight given to critical pair depth" (CP.cfg_depthweight . cfg_critical_pairs) argNum-    dupcost =-      expert $-      inGroup "Critical pair weighting heuristics" $-      defaultFlag "dup-cost" "Cost of duplicate subterms" (CP.cfg_dupcost . cfg_critical_pairs) argNum-    dupfactor =-      expert $-      inGroup "Critical pair weighting heuristics" $-      defaultFlag "dup-factor" "Size factor of duplicate subterms" (CP.cfg_dupfactor . cfg_critical_pairs) argNum-    ground_join =-      expert $-      inGroup "Critical pair joining heuristics" $-      bool "ground-joining"-        ["Test terms for ground joinability (on by default)."]-        True-    connectedness =-      expert $-      inGroup "Critical pair joining heuristics" $-      bool "connectedness"-        ["Test terms for subconnectedness (on by default)."]-        True-    set_join =-      expert $-      inGroup "Critical pair joining heuristics" $-      bool "set-join"-        ["Compute all normal forms when joining critical pairs (off by default)."]-        False-    all_lemmas =-      expert $-      inGroup "Proof presentation" $-      bool "all-lemmas"-        ["Produce a proof with one lemma for each critical pair (off by default)."]-        False-    flat_proof =-      expert $-      inGroup "Proof presentation" $-      bool "no-lemmas"-        ["Produce a proof with no lemmas (off by default).",-         "May lead to exponentially large proofs."]-        False-    show_instances =-      expert $-      inGroup "Proof presentation" $-      bool "show-instances"-        ["Show which instances of each axiom and lemma were used (off by default)."]-        False-    defaultFlag name desc field parser =-      flag name [desc ++ " (" ++ show def ++ " by default)."] def parser-      where-        def = field defaultConfig--parsePrecedence :: OptionParser [String]-parsePrecedence =-  expert $-  inGroup "Term order options" $-  fmap (splitOn ",")-  (flag "precedence" ["List of functions in descending order of precedence."] [] (arg "<function>" "expected a function name" Just))--data Constant =-  Constant {-    con_prec  :: {-# UNPACK #-} !Precedence,-    con_id    :: {-# UNPACK #-} !Jukebox.Function,-    con_arity :: {-# UNPACK #-} !Int,-    con_size  :: {-# UNPACK #-} !Int,-    con_bonus :: !Bool }-  deriving (Eq, Ord)--data Precedence = Precedence !Bool !Bool !(Maybe Int) !Int-  deriving (Eq, Ord)--instance Sized Constant where-  size Constant{..} = con_size-instance Arity Constant where-  arity Constant{..} = con_arity--instance Pretty Constant where-  pPrint Constant{..} = text (base con_id)--instance PrettyTerm Constant where-  termStyle Constant{..}-    | "$to_" `isPrefixOf` (base con_id) = invisible-    | any isAlphaNum (base con_id) = uncurried-    | otherwise =-      case con_arity of-        1 -> prefix-        2 -> infixStyle 5-        _ -> uncurried--instance Ordered (Extended Constant) where-  lessEq t u = {-# SCC lessEq #-} KBO.lessEq t u-  lessIn model t u = {-# SCC lessIn #-} KBO.lessIn model t u--instance EqualsBonus Constant where-  hasEqualsBonus = con_bonus-  isEquals = Main.isEquals . con_id-  isTrue = Main.isTrue . con_id-  isFalse = Main.isFalse . con_id--data TweeContext =-  TweeContext {-    ctx_var     :: Jukebox.Variable,-    ctx_minimal :: Jukebox.Function,-    ctx_true    :: Jukebox.Function,-    ctx_false   :: Jukebox.Function,-    ctx_equals  :: Jukebox.Function,-    ctx_type    :: Type }---- Convert back and forth between Twee and Jukebox.-tweeConstant :: HornFlags -> TweeContext -> Precedence -> Jukebox.Function -> Extended Constant-tweeConstant flags TweeContext{..} prec fun-  | fun == ctx_minimal = Minimal-  | otherwise = Function (Constant prec fun (Jukebox.arity fun) (sz fun) (bonus fun))-  where-    sz fun = if isType fun then 0 else 1-    bonus fun =-      (isIfeq fun && encoding flags /= Asymmetric2) ||-      Main.isEquals fun--isType :: Jukebox.Function -> Bool-isType fun = "$to_" `isPrefixOf` base (name fun)--isIfeq :: Jukebox.Function -> Bool-isIfeq fun = "$ifeq" `isPrefixOf` base (name fun)--isEquals :: Jukebox.Function -> Bool-isEquals fun = "$equals" `isPrefixOf` base (name fun)--isTrue :: Jukebox.Function -> Bool-isTrue fun = "$true" `isPrefixOf` base (name fun)--isFalse :: Jukebox.Function -> Bool-isFalse fun = "$false" `isPrefixOf` base (name fun)--jukeboxFunction :: TweeContext -> Extended Constant -> Jukebox.Function-jukeboxFunction _ (Function Constant{..}) = con_id-jukeboxFunction TweeContext{..} Minimal = ctx_minimal-jukeboxFunction TweeContext{..} (Skolem _) =-  error "Skolem variable leaked into rule"--tweeTerm :: HornFlags -> TweeContext -> (Jukebox.Function -> Precedence) -> Jukebox.Term -> Term (Extended Constant)-tweeTerm flags ctx prec t = build (tm t)-  where-    tm (Jukebox.Var (Unique x _ _ ::: _)) =-      var (V (fromIntegral x))-    tm (f :@: ts) =-      app (fun (tweeConstant flags ctx (prec f) f)) (map tm ts)--jukeboxTerm :: TweeContext -> Term (Extended Constant) -> Jukebox.Term-jukeboxTerm TweeContext{..} (Var (V x)) =-  Jukebox.Var (Unique (fromIntegral x) "X" defaultRenamer ::: ctx_type)-jukeboxTerm ctx@TweeContext{..} (App f t) =-  jukeboxFunction ctx (fun_value f) :@: map (jukeboxTerm ctx) ts-  where-    ts = unpack t--makeContext :: Problem Clause -> TweeContext-makeContext prob = run prob $ \prob -> do-  let-    ty =-      case types' prob of-        []   -> indType-        [ty] -> ty--  var     <- newSymbol "X" ty-  minimal <- newFunction "$constant" [] ty-  true    <- newFunction "$true" [] ty-  false   <- newFunction "$false" [] ty-  equals  <- newFunction "$equals" [ty, ty] ty--  return TweeContext {-    ctx_var = var,-    ctx_minimal = minimal,-    ctx_true = true,-    ctx_false = false,-    ctx_equals = equals,-    ctx_type = ty }---- Encode existentials so that all goals are ground.-addNarrowing :: TweeContext -> Problem Clause -> Problem Clause-addNarrowing TweeContext{..} prob =-  unchanged ++ equalityClauses-  where-    (unchanged, nonGroundGoals) = partitionEithers (map f prob)-      where-        f inp@Input{what = Clause (Bind _ [Neg (x Jukebox.:=: y)])}-          | not (ground x) || not (ground y) =-            Right (inp, (x, y))-        f inp = Left inp--    equalityClauses-      | null nonGroundGoals = []-      | otherwise =-        -- Turn a != b & c != d & ...-        -- into eq(a,b)=false & eq(c,d)=false & eq(X,X)=true & true!=false (esa)-        -- and then extract the individual components (thm)-        let-          equalityLiterals =-            -- true != false-            ("true_equals_false", Neg ((ctx_true :@:) [] Jukebox.:=: (ctx_false :@: []))):-            -- eq(X,X)=true-            ("reflexivity", Pos (ctx_equals :@: [Jukebox.Var ctx_var, Jukebox.Var ctx_var] Jukebox.:=: (ctx_true :@: []))):-            -- [eq(a,b)=false, eq(c,d)=false, ...]-            [ (tag, Pos (ctx_equals :@: [x, y] Jukebox.:=: (ctx_false :@: [])))-            | (Input{tag = tag}, (x, y)) <- nonGroundGoals ]--          -- Equisatisfiable to the input clauses-          justification =-            Input {-              tag  = "new_negated_conjecture",-              kind = Jukebox.Ax NegatedConjecture,-              what =-                let form = And (map (Literal . snd) equalityLiterals) in-                ForAll (Bind (Set.fromList (vars form)) form),-              source =-                Inference "encode_existential" "esa"-                  (map (fmap toForm . fst) nonGroundGoals) }--          input tag form =-            Input {-              tag = tag,-              kind = Conj Conjecture,-              what = clause [form],-              source =-                Inference "split_conjunct" "thm" [justification] }--        in [input tag form | (tag, form) <- equalityLiterals]--data PreEquation =-  PreEquation {-    pre_name :: String,-    pre_form :: Input Form,-    pre_eqn  :: (Jukebox.Term, Jukebox.Term) }---- Split the problem into axioms and ground goals.-identifyProblem ::-  TweeContext -> Problem Clause -> Either (Input Clause) ([PreEquation], [PreEquation])-identifyProblem TweeContext{..} prob =-  fmap partitionEithers (mapM identify prob)--  where-    pre inp x =-      PreEquation {-        pre_name = tag inp,-        pre_form = fmap toForm inp,-        pre_eqn = x }--    identify inp@Input{what = Clause (Bind _ [Pos (t Jukebox.:=: u)])} =-      return $ Left (pre inp (t, u))-    identify inp@Input{what = Clause (Bind _ [Neg (t Jukebox.:=: u)])}-      | ground t && ground u =-        return $ Right (pre inp (t, u))-    identify inp@Input{what = Clause (Bind _ [])} =-      -- The empty clause can appear after clausification if-      -- the conjecture was trivial-      return $ Left (pre inp (Jukebox.Var ctx_var, ctx_minimal :@: []))-    identify inp = Left inp--runTwee :: GlobalFlags -> TSTPFlags -> MainFlags -> HornFlags -> Config -> [String] -> (IO () -> IO ()) -> Problem Clause -> IO Answer-runTwee globals (TSTPFlags tstp) main horn config precedence later obligs = {-# SCC runTwee #-} do-  let-    -- Encode whatever needs encoding in the problem-    ctx = makeContext obligs-    prob = addNarrowing ctx obligs--  (axioms0, goals0) <--    case identifyProblem ctx prob of-      Left inp -> do-        mapM_ (hPutStrLn stderr) [-          "The problem contains the following clause, which is not a unit equality:",-          indent (show (pPrintClauses [inp])),-          "Twee only handles unit equality problems."]-        exitWith (ExitFailure 1)-      Right x -> return x--  let-    -- Work out a precedence for function symbols-    prec c =-      Precedence-        (isType c)-        (isNothing (elemIndex (base c) precedence))-        (fmap negate (elemIndex (base c) precedence))-        (negate (Map.findWithDefault 0 c occs))-    occs = funsOcc prob--    -- Translate everything to Twee.-    toEquation (t, u) =-      canonicalise (tweeTerm horn ctx prec t :=: tweeTerm horn ctx prec u)--    goals =-      [ goal n pre_name (toEquation pre_eqn)-      | (n, PreEquation{..}) <- zip [1..] goals0 ]-    axioms =-      [ Axiom n pre_name (toEquation pre_eqn)-      | (n, PreEquation{..}) <- zip [1..] axioms0 ]--    withGoals = foldl' (addGoal config) initialState goals-    withAxioms = foldl' (addAxiom config) withGoals axioms--  -- Set up tracing.-  sayTrace <--    case flags_trace main of-      Nothing -> return $ \_ -> return ()-      Just (file, mod) -> do-        h <- openFile file WriteMode-        hSetBuffering h LineBuffering-        let put msg = hPutStrLn h msg-        put $ ":- module(" ++ mod ++ ", [step/1, lemma/1])."-        put ":- discontiguous(step/1)."-        put ":- discontiguous(lemma/1)."-        put ":- style_check(-singleton)."-        return $ \msg -> hPutStrLn h msg-  -  let-    say msg = unless (quiet globals) (putStrLn msg)-    line = say ""-    output = Output {-      output_message = \msg -> do-        say (prettyShow msg)-        sayTrace (show (traceMsg msg)) }--    traceMsg (NewActive active) =-      step "add" [traceActive active]-    traceMsg (NewEquation eqn) =-      step "hard" [traceEqn eqn]-    traceMsg (DeleteActive active) =-      step "delete" [traceActive active]-    traceMsg SimplifyQueue =-      step "simplify_queue" []-    traceMsg Interreduce =-      step "interreduce" []--    traceActive Active{..} =-      traceApp "rule" [pPrint active_id, traceEqn (unorient active_rule)]-    traceEqn (t :=: u) =-      pPrintPrec prettyNormal 6 t <+> text "=" <+> pPrintPrec prettyNormal 6 u-    traceApp f xs =-      pPrintTerm uncurried prettyNormal 0 (text f) xs--    step :: String -> [Doc] -> Doc-    step f xs = traceApp "step" [traceApp f xs] <> text "."--  say "Here is the input problem:"-  forM_ axioms $ \Axiom{..} ->-    say $ show $ nest 2 $-      describeEquation "Axiom"-        (show axiom_number) (Just axiom_name) axiom_eqn-  forM_ goals $ \Goal{..} ->-    say $ show $ nest 2 $-      describeEquation "Goal"-        (show goal_number) (Just goal_name) goal_eqn-  line--  state <- complete output config withAxioms-  line--  when (solved state && flags_proof main) $ later $ do-    let-      pres = present (cfg_proof_presentation config) (solutions state)--    sayTrace ""-    forM_ (pres_lemmas pres) $ \Lemma{..} ->-      sayTrace $ show $-        traceApp "lemma" [traceEqn (equation lemma_proof)] <> text "."--    when tstp $ do-      putStrLn "% SZS output start CNFRefutation"-      print $ pPrintProof $-        presentToJukebox ctx (curry toEquation)-          (zip (map axiom_number axioms) (map pre_form axioms0))-          (zip (map goal_number goals) (map pre_form goals0))-          pres-      putStrLn "% SZS output end CNFRefutation"-      putStrLn ""--    putStrLn "The conjecture is true! Here is a proof."-    putStrLn ""-    print $ pPrintPresentation (cfg_proof_presentation config) pres-    putStrLn ""--  when (not (quiet globals) && not (solved state)) $ later $ do-    let-      state' = interreduce config state-      score rule =-        (size (lhs rule), lhs rule,-         size (rhs rule), rhs rule)-      actives =-        sortBy (comparing (score . active_rule)) $-        IntMap.elems (st_active_ids state')--    when (tstp && configIsComplete config) $ do-      putStrLn "% SZS output start Saturation"-      print $ pPrintProof $-        map pre_form axioms0 ++-        map pre_form goals0 ++-        [ Input "rule" (Jukebox.Ax Jukebox.Axiom) Unknown $-            toForm $ clause-              [Pos (jukeboxTerm ctx (lhs rule) Jukebox.:=: jukeboxTerm ctx (rhs rule))]-        | rule <- rules state ]-      putStrLn "% SZS output end Saturation"-      putStrLn ""--    if configIsComplete config then do-      putStrLn "Ran out of critical pairs. This means the conjecture is not true."-    else do-      putStrLn "Gave up on reaching the given resource limit."-    putStrLn "Here is the final rewrite system:"-    forM_ actives $ \active ->-      putStrLn ("  " ++ prettyShow (canonicalise (active_rule active)))-    putStrLn ""--  return $-    if solved state then Unsat Unsatisfiable Nothing-    else if configIsComplete config then Sat Satisfiable Nothing-    else NoAnswer GaveUp---- Transform a proof presentation into a Jukebox proof.-presentToJukebox ::-  TweeContext ->-  (Jukebox.Term -> Jukebox.Term -> Equation (Extended Constant)) ->-  -- Axioms, indexed by axiom number.-  [(Int, Input Form)] ->-  -- N.B. the formula here proves the negated goal.-  [(Int, Input Form)] ->-  Presentation (Extended Constant) ->-  Problem Form-presentToJukebox ctx toEquation axioms goals Presentation{..} =-  [ Input {-      tag = pg_name,-      kind = Jukebox.Ax Jukebox.Axiom,-      what = false,-      source =-        Inference "resolution" "thm"-          [-- A proof of t != u-           existentialHack pg_goal_hint (fromJust (lookup pg_number goals)),-           -- A proof of t = u-           fromJust (Map.lookup pg_number goal_proofs)] }-  | ProvedGoal{..} <- pres_goals ]--  where-    axiom_proofs =-      Map.fromList-        [ (axiom_number, fromJust (lookup axiom_number axioms))-        | Axiom{..} <- pres_axioms ]--    lemma_proofs =-      Map.fromList [(lemma_id, tstp lemma_proof) | Lemma{..} <- pres_lemmas]--    goal_proofs =-      Map.fromList [(pg_number, tstp pg_proof) | ProvedGoal{..} <- pres_goals]--    tstp :: Proof (Extended Constant) -> Input Form-    tstp = deriv . derivation--    deriv :: Derivation (Extended Constant) -> Input Form-    deriv p@(Trans q r) = derivFrom (deriv r:sources q) p-    deriv p = derivFrom (sources p) p--    derivFrom :: [Input Form] -> Derivation (Extended Constant) -> Input Form-    derivFrom sources p =-      Input {-        tag = "step",-        kind = Jukebox.Ax Jukebox.Axiom,-        what = jukeboxEquation (equation (certify p)),-        source =-          Inference "rw" "thm" sources }--    jukeboxEquation :: Equation (Extended Constant) -> Form-    jukeboxEquation (t :=: u) =-      toForm $ clause [Pos (jukeboxTerm ctx t Jukebox.:=: jukeboxTerm ctx u)]--    sources :: Derivation (Extended Constant) -> [Input Form]-    sources p =-      [ fromJust (Map.lookup lemma_id lemma_proofs)-      | Lemma{..} <- usortBy (comparing lemma_id) (usedLemmas p) ] ++-      [ fromJust (Map.lookup axiom_number axiom_proofs)-      | Axiom{..} <- usort (usedAxioms p) ]--    -- An ugly hack: since Twee.Proof decodes $true = $false into a-    -- proof of the existentially quantified goal, we need to do the-    -- same decoding at the Jukebox level.-    existentialHack eqn input =-      case find input of-        [] -> error $ "bug in TSTP output: can't fix up decoded existential"-        (inp:_) -> inp-        where-          -- Check if this looks like the correct clause;-          -- if not, try its ancestors.-          find inp | ok inp = [inp]-          find Input{source = Inference _ _ inps} =-            concatMap find inps-          find _ = []--          ok inp =-            case toClause (what inp) of-              Nothing -> False-              Just (Clause (Bind _ [Neg (t' Jukebox.:=: u')])) ->-                let-                  eqn' = toEquation t' u'-                  ts = buildList [eqn_lhs eqn, eqn_rhs eqn]-                  us = buildList [eqn_lhs eqn', eqn_rhs eqn']-                in-                  isJust (matchList ts us) && isJust (matchList us ts)--main = do-  hSetBuffering stdout LineBuffering-  join . parseCommandLineWithExtraArgs-    ["--no-conjunctive-conjectures", "--no-split"]-    "Twee, an equational theorem prover" . version ("twee version " ++ VERSION_twee) $-      globalFlags *> parseMainFlags *>-      -- hack: get --quiet and --no-proof options to appear before --tstp-      forAllFilesBox <*>-        (readProblemBox =>>=-         expert clausifyBox =>>=-         forAllConjecturesBox <*>-           (combine <$>-             expert hornToUnitBox <*>-             (toFormulasBox =>>=-              expert (toFof <$> clausifyBox <*> pure (tags True)) =>>=-              expert clausifyBox =>>= expert oneConjectureBox) <*>-             (runTwee <$> globalFlags <*> tstpFlags <*> parseMainFlags <*> expert hornFlags <*> parseConfig <*> parsePrecedence)))-  where-    combine horn encode prove later prob = do-      res <- horn prob-      case res of-        Left ans -> return ans-        Right prob ->-          encode prob >>= prove later
+ README.md view
@@ -0,0 +1,25 @@+This is twee, an equational theorem prover.++The version in this git repository is likely to be unstable!+To install the latest stable version, run:++    cabal install twee++If you have LLVM installed, you can get a slightly faster version by+running:++    cabal install twee -fllvm++If you really want the latest unstable version, run+`cabal install src/ .` in this repository. You will most likely need+the latest git version of Jukebox, from+https://github.com/nick8325/jukebox, too - and things may break from+time to time.++Afterwards, run `twee nameofproblem.p`. The problem should be in TPTP+format (http://www.tptp.org). You can find a few examples in the+`tests` directory. All axioms and conjectures must be equations, but+you can freely use quantifiers. If it succeeds in proving your+problem, twee will print a human-readable proof.++For the official manual, see http://nick8325.github.io/twee.
+ executable/Main.hs view
@@ -0,0 +1,626 @@+{-# LANGUAGE CPP, RecordWildCards, FlexibleInstances, PatternGuards #-}+import Control.Monad+import Data.Char+import Data.Either+import Twee hiding (message)+import Twee.Base hiding (char, lookup, vars)+import Twee.Rule(lhs, rhs, unorient)+import Twee.Equation+import qualified Twee.Proof as Proof+import Twee.Proof hiding (Config, defaultConfig)+import qualified Twee.Join as Join+import Twee.Utils+import qualified Twee.CP as CP+import Data.Ord+import qualified Data.Map.Strict as Map+import qualified Twee.KBO as KBO+import Data.List.Split+import Data.List+import Data.Maybe+import Jukebox.Options+import Jukebox.Toolbox+import Jukebox.Name hiding (lhs, rhs)+import qualified Jukebox.Form as Jukebox+import Jukebox.Form hiding ((:=:), Var, Symbolic(..), Term, Axiom, size, Lemma)+import Jukebox.Tools.EncodeTypes+import Jukebox.TPTP.Print+import Jukebox.Tools.HornToUnit+import qualified Data.IntMap.Strict as IntMap+import System.IO+import System.Exit+import qualified Data.Set as Set+import Twee.Label++data MainFlags =+  MainFlags {+    flags_proof :: Bool,+    flags_trace :: Maybe (String, String) }++parseMainFlags :: OptionParser MainFlags+parseMainFlags =+  MainFlags <$> proof <*> trace+  where+    proof =+      inGroup "Output options" $+      bool "proof" ["Produce proofs (on by default)."]+      True+    trace =+      expert $+      inGroup "Output options" $+      flag "trace"+        ["Write a Prolog-format execution trace to this file (off by default)."]+        Nothing ((\x y -> Just (x, y)) <$> argFile <*> argModule)+    argModule = arg "<module>" "expected a Prolog module name" Just++parseConfig :: OptionParser Config+parseConfig =+  Config <$> maxSize <*> maxCPs <*> maxCPDepth <*> simplify <*> normPercent <*>+    (CP.Config <$> lweight <*> rweight <*> funweight <*> varweight <*> depthweight <*> dupcost <*> dupfactor) <*>+    (Join.Config <$> ground_join <*> connectedness <*> set_join) <*>+    (Proof.Config <$> all_lemmas <*> flat_proof <*> show_instances)+  where+    maxSize =+      inGroup "Resource limits" $+      flag "max-term-size" ["Discard rewrite rules whose left-hand side is bigger than this limit (unlimited by default)."] maxBound argNum+    maxCPs =+      inGroup "Resource limits" $+      flag "max-cps" ["Give up after considering this many critical pairs (unlimited by default)."] maxBound argNum+    maxCPDepth =+      inGroup "Resource limits" $+      flag "max-cp-depth" ["Only consider critical pairs up to this depth (unlimited by default)."] maxBound argNum+    simplify =+      expert $+      inGroup "Completion heuristics" $+      bool "simplify"+        ["Simplify rewrite rules with respect to one another (on by default)."]+        True+    normPercent =+      expert $+      inGroup "Completion heuristics" $+      defaultFlag "normalise-queue-percent" "Percent of time spent renormalising queued critical pairs" (cfg_renormalise_percent) argNum+    lweight =+      expert $+      inGroup "Critical pair weighting heuristics" $+      defaultFlag "lhs-weight" "Weight given to LHS of critical pair" (CP.cfg_lhsweight . cfg_critical_pairs) argNum+    rweight =+      expert $+      inGroup "Critical pair weighting heuristics" $+      defaultFlag "rhs-weight" "Weight given to RHS of critical pair" (CP.cfg_rhsweight . cfg_critical_pairs) argNum+    funweight =+      expert $+      inGroup "Critical pair weighting heuristics" $+      defaultFlag "fun-weight" "Weight given to function symbols" (CP.cfg_funweight . cfg_critical_pairs) argNum+    varweight =+      expert $+      inGroup "Critical pair weighting heuristics" $+      defaultFlag "var-weight" "Weight given to variable symbols" (CP.cfg_varweight . cfg_critical_pairs) argNum+    depthweight =+      expert $+      inGroup "Critical pair weighting heuristics" $+      defaultFlag "depth-weight" "Weight given to critical pair depth" (CP.cfg_depthweight . cfg_critical_pairs) argNum+    dupcost =+      expert $+      inGroup "Critical pair weighting heuristics" $+      defaultFlag "dup-cost" "Cost of duplicate subterms" (CP.cfg_dupcost . cfg_critical_pairs) argNum+    dupfactor =+      expert $+      inGroup "Critical pair weighting heuristics" $+      defaultFlag "dup-factor" "Size factor of duplicate subterms" (CP.cfg_dupfactor . cfg_critical_pairs) argNum+    ground_join =+      expert $+      inGroup "Critical pair joining heuristics" $+      bool "ground-joining"+        ["Test terms for ground joinability (on by default)."]+        True+    connectedness =+      expert $+      inGroup "Critical pair joining heuristics" $+      bool "connectedness"+        ["Test terms for subconnectedness (on by default)."]+        True+    set_join =+      expert $+      inGroup "Critical pair joining heuristics" $+      bool "set-join"+        ["Compute all normal forms when joining critical pairs (off by default)."]+        False+    all_lemmas =+      expert $+      inGroup "Proof presentation" $+      bool "all-lemmas"+        ["Produce a proof with one lemma for each critical pair (off by default)."]+        False+    flat_proof =+      expert $+      inGroup "Proof presentation" $+      bool "no-lemmas"+        ["Produce a proof with no lemmas (off by default).",+         "May lead to exponentially large proofs."]+        False+    show_instances =+      expert $+      inGroup "Proof presentation" $+      bool "show-instances"+        ["Show which instances of each axiom and lemma were used (off by default)."]+        False+    defaultFlag name desc field parser =+      flag name [desc ++ " (" ++ show def ++ " by default)."] def parser+      where+        def = field defaultConfig++parsePrecedence :: OptionParser [String]+parsePrecedence =+  expert $+  inGroup "Term order options" $+  fmap (splitOn ",")+  (flag "precedence" ["List of functions in descending order of precedence."] [] (arg "<function>" "expected a function name" Just))++data Constant =+  Constant {+    con_prec  :: {-# UNPACK #-} !Precedence,+    con_id    :: {-# UNPACK #-} !Jukebox.Function,+    con_arity :: {-# UNPACK #-} !Int,+    con_size  :: {-# UNPACK #-} !Int,+    con_bonus :: !Bool }+  deriving (Eq, Ord)++data Precedence = Precedence !Bool !Bool !(Maybe Int) !Int+  deriving (Eq, Ord)++instance Sized Constant where+  size Constant{..} = con_size+instance Arity Constant where+  arity Constant{..} = con_arity++instance Pretty Constant where+  pPrint Constant{..} = text (base con_id)++instance PrettyTerm Constant where+  termStyle Constant{..}+    | "$to_" `isPrefixOf` (base con_id) = invisible+    | any isAlphaNum (base con_id) = uncurried+    | otherwise =+      case con_arity of+        1 -> prefix+        2 -> infixStyle 5+        _ -> uncurried++instance Ordered (Extended Constant) where+  lessEq t u = {-# SCC lessEq #-} KBO.lessEq t u+  lessIn model t u = {-# SCC lessIn #-} KBO.lessIn model t u++instance EqualsBonus Constant where+  hasEqualsBonus = con_bonus+  isEquals = Main.isEquals . con_id+  isTrue = Main.isTrue . con_id+  isFalse = Main.isFalse . con_id++data TweeContext =+  TweeContext {+    ctx_var     :: Jukebox.Variable,+    ctx_minimal :: Jukebox.Function,+    ctx_true    :: Jukebox.Function,+    ctx_false   :: Jukebox.Function,+    ctx_equals  :: Jukebox.Function,+    ctx_type    :: Type }++-- Convert back and forth between Twee and Jukebox.+tweeConstant :: HornFlags -> TweeContext -> Precedence -> Jukebox.Function -> Extended Constant+tweeConstant flags TweeContext{..} prec fun+  | fun == ctx_minimal = Minimal+  | otherwise = Function (Constant prec fun (Jukebox.arity fun) (sz fun) (bonus fun))+  where+    sz fun = if isType fun then 0 else 1+    bonus fun =+      (isIfeq fun && encoding flags /= Asymmetric2) ||+      Main.isEquals fun++isType :: Jukebox.Function -> Bool+isType fun = "$to_" `isPrefixOf` base (name fun)++isIfeq :: Jukebox.Function -> Bool+isIfeq fun = "$ifeq" `isPrefixOf` base (name fun)++isEquals :: Jukebox.Function -> Bool+isEquals fun = "$equals" `isPrefixOf` base (name fun)++isTrue :: Jukebox.Function -> Bool+isTrue fun = "$true" `isPrefixOf` base (name fun)++isFalse :: Jukebox.Function -> Bool+isFalse fun = "$false" `isPrefixOf` base (name fun)++jukeboxFunction :: TweeContext -> Extended Constant -> Jukebox.Function+jukeboxFunction _ (Function Constant{..}) = con_id+jukeboxFunction TweeContext{..} Minimal = ctx_minimal+jukeboxFunction TweeContext{..} (Skolem _) =+  error "Skolem variable leaked into rule"++tweeTerm :: HornFlags -> TweeContext -> (Jukebox.Function -> Precedence) -> Jukebox.Term -> Term (Extended Constant)+tweeTerm flags ctx prec t = build (tm t)+  where+    tm (Jukebox.Var (x ::: _)) =+      var (V (fromIntegral (labelNum (label x))))+    tm (f :@: ts) =+      app (fun (tweeConstant flags ctx (prec f) f)) (map tm ts)++jukeboxTerm :: TweeContext -> Term (Extended Constant) -> Jukebox.Term+jukeboxTerm TweeContext{..} (Var (V x)) =+  Jukebox.Var (Unique (fromIntegral x) "X" defaultRenamer ::: ctx_type)+jukeboxTerm ctx@TweeContext{..} (App f t) =+  jukeboxFunction ctx (fun_value f) :@: map (jukeboxTerm ctx) ts+  where+    ts = unpack t++makeContext :: Problem Clause -> TweeContext+makeContext prob = run prob $ \prob -> do+  let+    ty =+      case types' prob of+        []   -> indType+        [ty] -> ty++  var     <- newSymbol "X" ty+  minimal <- newFunction "$constant" [] ty+  true    <- newFunction "$true" [] ty+  false   <- newFunction "$false" [] ty+  equals  <- newFunction "$equals" [ty, ty] ty++  return TweeContext {+    ctx_var = var,+    ctx_minimal = minimal,+    ctx_true = true,+    ctx_false = false,+    ctx_equals = equals,+    ctx_type = ty }++-- Encode existentials so that all goals are ground.+addNarrowing :: TweeContext -> Problem Clause -> Problem Clause+addNarrowing TweeContext{..} prob =+  unchanged ++ equalityClauses+  where+    (unchanged, nonGroundGoals) = partitionEithers (map f prob)+      where+        f inp@Input{what = Clause (Bind _ [Neg (x Jukebox.:=: y)])}+          | not (ground x) || not (ground y) =+            Right (inp, (x, y))+        f inp = Left inp++    equalityClauses+      | null nonGroundGoals = []+      | otherwise =+        -- Turn a != b & c != d & ...+        -- into eq(a,b)=false & eq(c,d)=false & eq(X,X)=true & true!=false (esa)+        -- and then extract the individual components (thm)+        let+          equalityLiterals =+            -- true != false+            ("true_equals_false", Neg ((ctx_true :@:) [] Jukebox.:=: (ctx_false :@: []))):+            -- eq(X,X)=true+            ("reflexivity", Pos (ctx_equals :@: [Jukebox.Var ctx_var, Jukebox.Var ctx_var] Jukebox.:=: (ctx_true :@: []))):+            -- [eq(a,b)=false, eq(c,d)=false, ...]+            [ (tag, Pos (ctx_equals :@: [x, y] Jukebox.:=: (ctx_false :@: [])))+            | (Input{tag = tag}, (x, y)) <- nonGroundGoals ]++          -- Equisatisfiable to the input clauses+          justification =+            Input {+              tag  = "new_negated_conjecture",+              kind = Jukebox.Ax NegatedConjecture,+              what =+                let form = And (map (Literal . snd) equalityLiterals) in+                ForAll (Bind (Set.fromList (vars form)) form),+              source =+                Inference "encode_existential" "esa"+                  (map (fmap toForm . fst) nonGroundGoals) }++          input tag form =+            Input {+              tag = tag,+              kind = Conj Conjecture,+              what = clause [form],+              source =+                Inference "split_conjunct" "thm" [justification] }++        in [input tag form | (tag, form) <- equalityLiterals]++data PreEquation =+  PreEquation {+    pre_name :: String,+    pre_form :: Input Form,+    pre_eqn  :: (Jukebox.Term, Jukebox.Term) }++-- Split the problem into axioms and ground goals.+identifyProblem ::+  TweeContext -> Problem Clause -> Either (Input Clause) ([PreEquation], [PreEquation])+identifyProblem TweeContext{..} prob =+  fmap partitionEithers (mapM identify prob)++  where+    pre inp x =+      PreEquation {+        pre_name = tag inp,+        pre_form = fmap toForm inp,+        pre_eqn = x }++    identify inp@Input{what = Clause (Bind _ [Pos (t Jukebox.:=: u)])} =+      return $ Left (pre inp (t, u))+    identify inp@Input{what = Clause (Bind _ [Neg (t Jukebox.:=: u)])}+      | ground t && ground u =+        return $ Right (pre inp (t, u))+    identify inp@Input{what = Clause (Bind _ [])} =+      -- The empty clause can appear after clausification if+      -- the conjecture was trivial+      return $ Left (pre inp (Jukebox.Var ctx_var, ctx_minimal :@: []))+    identify inp = Left inp++runTwee :: GlobalFlags -> TSTPFlags -> MainFlags -> HornFlags -> Config -> [String] -> (IO () -> IO ()) -> Problem Clause -> IO Answer+runTwee globals (TSTPFlags tstp) main horn config precedence later obligs = {-# SCC runTwee #-} do+  let+    -- Encode whatever needs encoding in the problem+    ctx = makeContext obligs+    prob = addNarrowing ctx obligs++  (axioms0, goals0) <-+    case identifyProblem ctx prob of+      Left inp -> do+        mapM_ (hPutStrLn stderr) [+          "The problem contains the following clause, which is not a unit equality:",+          indent (show (pPrintClauses [inp])),+          "Twee only handles unit equality problems."]+        exitWith (ExitFailure 1)+      Right x -> return x++  let+    -- Work out a precedence for function symbols+    prec c =+      Precedence+        (isType c)+        (isNothing (elemIndex (base c) precedence))+        (fmap negate (elemIndex (base c) precedence))+        (negate (Map.findWithDefault 0 c occs))+    occs = funsOcc prob++    -- Translate everything to Twee.+    toEquation (t, u) =+      canonicalise (tweeTerm horn ctx prec t :=: tweeTerm horn ctx prec u)++    goals =+      [ goal n pre_name (toEquation pre_eqn)+      | (n, PreEquation{..}) <- zip [1..] goals0 ]+    axioms =+      [ Axiom n pre_name (toEquation pre_eqn)+      | (n, PreEquation{..}) <- zip [1..] axioms0 ]++    withGoals = foldl' (addGoal config) initialState goals+    withAxioms = foldl' (addAxiom config) withGoals axioms++  -- Set up tracing.+  sayTrace <-+    case flags_trace main of+      Nothing -> return $ \_ -> return ()+      Just (file, mod) -> do+        h <- openFile file WriteMode+        hSetBuffering h LineBuffering+        let put msg = hPutStrLn h msg+        put $ ":- module(" ++ mod ++ ", [step/1, lemma/1])."+        put ":- discontiguous(step/1)."+        put ":- discontiguous(lemma/1)."+        put ":- style_check(-singleton)."+        return $ \msg -> hPutStrLn h msg+  +  let+    say msg = unless (quiet globals) (putStrLn msg)+    line = say ""+    output = Output {+      output_message = \msg -> do+        say (prettyShow msg)+        sayTrace (show (traceMsg msg)) }++    traceMsg (NewActive active) =+      step "add" [traceActive active]+    traceMsg (NewEquation eqn) =+      step "hard" [traceEqn eqn]+    traceMsg (DeleteActive active) =+      step "delete" [traceActive active]+    traceMsg SimplifyQueue =+      step "simplify_queue" []+    traceMsg Interreduce =+      step "interreduce" []++    traceActive Active{..} =+      traceApp "rule" [pPrint active_id, traceEqn (unorient active_rule)]+    traceEqn (t :=: u) =+      pPrintPrec prettyNormal 6 t <+> text "=" <+> pPrintPrec prettyNormal 6 u+    traceApp f xs =+      pPrintTerm uncurried prettyNormal 0 (text f) xs++    step :: String -> [Doc] -> Doc+    step f xs = traceApp "step" [traceApp f xs] <> text "."++  say "Here is the input problem:"+  forM_ axioms $ \Axiom{..} ->+    say $ show $ nest 2 $+      describeEquation "Axiom"+        (show axiom_number) (Just axiom_name) axiom_eqn+  forM_ goals $ \Goal{..} ->+    say $ show $ nest 2 $+      describeEquation "Goal"+        (show goal_number) (Just goal_name) goal_eqn+  line++  state <- complete output config withAxioms+  line++  when (solved state && flags_proof main) $ later $ do+    let+      pres = present (cfg_proof_presentation config) (solutions state)++    sayTrace ""+    forM_ (pres_lemmas pres) $ \Lemma{..} ->+      sayTrace $ show $+        traceApp "lemma" [traceEqn (equation lemma_proof)] <> text "."++    when tstp $ do+      putStrLn "% SZS output start CNFRefutation"+      print $ pPrintProof $+        presentToJukebox ctx (curry toEquation)+          (zip (map axiom_number axioms) (map pre_form axioms0))+          (zip (map goal_number goals) (map pre_form goals0))+          pres+      putStrLn "% SZS output end CNFRefutation"+      putStrLn ""++    putStrLn "The conjecture is true! Here is a proof."+    putStrLn ""+    print $ pPrintPresentation (cfg_proof_presentation config) pres+    putStrLn ""++  when (not (quiet globals) && not (solved state)) $ later $ do+    let+      state' = interreduce config state+      score rule =+        (size (lhs rule), lhs rule,+         size (rhs rule), rhs rule)+      actives =+        sortBy (comparing (score . active_rule)) $+        IntMap.elems (st_active_ids state')++    when (tstp && configIsComplete config) $ do+      putStrLn "% SZS output start Saturation"+      print $ pPrintProof $+        map pre_form axioms0 +++        map pre_form goals0 +++        [ Input "rule" (Jukebox.Ax Jukebox.Axiom) Unknown $+            toForm $ clause+              [Pos (jukeboxTerm ctx (lhs rule) Jukebox.:=: jukeboxTerm ctx (rhs rule))]+        | rule <- rules state ]+      putStrLn "% SZS output end Saturation"+      putStrLn ""++    if configIsComplete config then do+      putStrLn "Ran out of critical pairs. This means the conjecture is not true."+    else do+      putStrLn "Gave up on reaching the given resource limit."+    putStrLn "Here is the final rewrite system:"+    forM_ actives $ \active ->+      putStrLn ("  " ++ prettyShow (canonicalise (active_rule active)))+    putStrLn ""++  return $+    if solved state then Unsat Unsatisfiable Nothing+    else if configIsComplete config then Sat Satisfiable Nothing+    else NoAnswer GaveUp++-- Transform a proof presentation into a Jukebox proof.+presentToJukebox ::+  TweeContext ->+  (Jukebox.Term -> Jukebox.Term -> Equation (Extended Constant)) ->+  -- Axioms, indexed by axiom number.+  [(Int, Input Form)] ->+  -- N.B. the formula here proves the negated goal.+  [(Int, Input Form)] ->+  Presentation (Extended Constant) ->+  Problem Form+presentToJukebox ctx toEquation axioms goals Presentation{..} =+  [ Input {+      tag = pg_name,+      kind = Jukebox.Ax Jukebox.Axiom,+      what = false,+      source =+        Inference "resolution" "thm"+          [-- A proof of t != u+           existentialHack pg_goal_hint (fromJust (lookup pg_number goals)),+           -- A proof of t = u+           fromJust (Map.lookup pg_number goal_proofs)] }+  | ProvedGoal{..} <- pres_goals ]++  where+    axiom_proofs =+      Map.fromList+        [ (axiom_number, fromJust (lookup axiom_number axioms))+        | Axiom{..} <- pres_axioms ]++    lemma_proofs =+      Map.fromList [(lemma_id, tstp lemma_proof) | Lemma{..} <- pres_lemmas]++    goal_proofs =+      Map.fromList [(pg_number, tstp pg_proof) | ProvedGoal{..} <- pres_goals]++    tstp :: Proof (Extended Constant) -> Input Form+    tstp = deriv . derivation++    deriv :: Derivation (Extended Constant) -> Input Form+    deriv p@(Trans q r) = derivFrom (deriv r:sources q) p+    deriv p = derivFrom (sources p) p++    derivFrom :: [Input Form] -> Derivation (Extended Constant) -> Input Form+    derivFrom sources p =+      Input {+        tag = "step",+        kind = Jukebox.Ax Jukebox.Axiom,+        what = jukeboxEquation (equation (certify p)),+        source =+          Inference "rw" "thm" sources }++    jukeboxEquation :: Equation (Extended Constant) -> Form+    jukeboxEquation (t :=: u) =+      toForm $ clause [Pos (jukeboxTerm ctx t Jukebox.:=: jukeboxTerm ctx u)]++    sources :: Derivation (Extended Constant) -> [Input Form]+    sources p =+      [ fromJust (Map.lookup lemma_id lemma_proofs)+      | Lemma{..} <- usortBy (comparing lemma_id) (usedLemmas p) ] +++      [ fromJust (Map.lookup axiom_number axiom_proofs)+      | Axiom{..} <- usort (usedAxioms p) ]++    -- An ugly hack: since Twee.Proof decodes $true = $false into a+    -- proof of the existentially quantified goal, we need to do the+    -- same decoding at the Jukebox level.+    existentialHack eqn input =+      case find input of+        [] -> error $ "bug in TSTP output: can't fix up decoded existential"+        (inp:_) -> inp+        where+          -- Check if this looks like the correct clause;+          -- if not, try its ancestors.+          find inp | ok inp = [inp]+          find Input{source = Inference _ _ inps} =+            concatMap find inps+          find _ = []++          ok inp =+            case toClause (what inp) of+              Nothing -> False+              Just (Clause (Bind _ [Neg (t' Jukebox.:=: u')])) ->+                let+                  eqn' = toEquation t' u'+                  ts = buildList [eqn_lhs eqn, eqn_rhs eqn]+                  us = buildList [eqn_lhs eqn', eqn_rhs eqn']+                in+                  isJust (matchList ts us) && isJust (matchList us ts)++main = do+  hSetBuffering stdout LineBuffering+  join . parseCommandLineWithExtraArgs+    ["--no-conjunctive-conjectures", "--no-split"]+    "Twee, an equational theorem prover" . version ("twee version " ++ VERSION_twee) $+      globalFlags *> parseMainFlags *>+      -- hack: get --quiet and --no-proof options to appear before --tstp+      forAllFilesBox <*>+        (readProblemBox =>>=+         expert clausifyBox =>>=+         forAllConjecturesBox <*>+           (combine <$>+             expert hornToUnitBox <*>+             (toFormulasBox =>>=+              expert (toFof <$> clausifyBox <*> pure (tags True)) =>>=+              expert clausifyBox =>>= expert oneConjectureBox) <*>+             (runTwee <$> globalFlags <*> tstpFlags <*> parseMainFlags <*> expert hornFlags <*> parseConfig <*> parsePrecedence)))+  where+    combine horn encode prove later prob = do+      res <- horn prob+      case res of+        Left ans -> return ans+        Right prob ->+          encode prob >>= prove later
+ misc/analyse_trace.pl view
@@ -0,0 +1,32 @@+:- use_module(boo067_good, []).+:- use_module(boo067_bad, []).++ground(Pred, X) :-+	call(Pred, Y),+	numbervars(Y, 1, _),+	X=Y.++default(Pred, X) :-+    call(Pred, boo067_good, boo067_bad, X).++missing(X) :- default(missing, X).+missing(Good, Bad, X) :-+	ground(Good:lemma, X),+	\+ found(Bad, add(rule(_, X))).++variant(rule(N, X=Y), rule(N, X=Y)).+variant(rule(N, X=Y), rule(N, Y=X)).++found(Mod, Rule) :-+	variant(Rule, Rule1),+	Mod:step(add(Rule1)).++gone(Mod, rule(N, X)) :-+	ground(Mod:lemma, X),+	found(Mod, rule(N, X)),+	Mod:step(delete(N)).++reappeared(Mod, rule(N, X), M) :-+	ground(found(Mod), rule(N, X)),+	found(Mod, rule(M, X)),+	M > N.
+ misc/bench.hs view
@@ -0,0 +1,74 @@+{-# LANGUAGE PatternGuards, FlexibleInstances #-}+import Criterion.Main+import Twee.Term hiding (isFun)+import qualified Twee.Term+import Test.QuickCheck+import Data.Int+import Data.Maybe+import Twee.Term.Core hiding (subst)++instance Num (Fun Int) where fromInteger n = F (fromInteger n) (fromInteger n)+instance Num Var where fromInteger = V . fromInteger++t0, t1, u0, u1, t2, t, u :: Term Int+t0 = build $ fun 0 [var 0, fun 0 [var 0, fun 0 [fun 0 [var 0, var 1], var 2]]]+u0 = build $ fun 0 [fun 0 [fun 2 [fun 2 [var 2, var 2], var 1], fun 0 [fun 2 [var 2, var 2], var 3]], fun 0 [fun 0 [fun 2 [fun 2 [var 2, var 2], var 1], fun 0 [fun 2 [var 2, var 2], var 3]], fun 0 [fun 0 [fun 0 [fun 2 [fun 2 [var 2, var 2], var 1], fun 0 [fun 2 [var 2, var 2], var 3]], fun 2 [fun 2 [var 2, var 2], var 1]], fun 2 [var 2, var 2]]]]++t1 = build $ fun 0 [fun 1 [var 0], fun 1 [var 1]]+u1 = build $ fun 0 [fun 1 [fun 0 [fun 2 emptyTermList, fun 3 emptyTermList]], fun 1 [fun 0 [fun 4 emptyTermList, fun 5 emptyTermList]]]++t2 = build $ fun 0 [var 0, fun 1 [var 1, fun 1 [var 1, var 1]]]+u2 = build $ fun 0 [fun 0 [var 2, var 2], var 2]++t = t0+u = u0++Just sub = match t u++mgu1 t u = let Just sub = unifyTri t u in build (subst sub t)+mgu2 t u = let Just sub = unify t u in build (subst sub t)++Just sub' = unifyTri t2 u2+Just csub' = unify t2 u2++main = do+  print t+  print u+  print (match t u)+  print (build (subst sub t))+  print (unifyTri t2 u2)+  print (close sub')+  print (build (subst sub' t2))+  print (build (subst sub' u2))+  print (mgu1 t2 u2)+  print (mgu2 t2 u2)+  print (t == t)+  print (build (subst sub t) == u)+  print (build (subst sub' t2) == build (subst sub' u2))+  print (build (subst csub' t1) == build (subst sub' t1))+  print (mgu1 t2 u2 == mgu2 t2 u2)+  print (build (subst csub' t2) == build (subst sub' t2))+  defaultMain [+    bench "eq-t" (whnf (uncurry (==)) (t, t)),+    bench "eq-u" (whnf (uncurry (==)) (u, u)),+    bench "match" (whnf (fromJust . uncurry match) (t, u)),+    bench "subst" (whnf (build . uncurry subst) (sub, t)),+    bench "unifyTri" (whnf (fromJust . uncurry unifyTri) (t2, u2)),+    bench "unify-close" (whnf (uncurry unify) (t2, u2)),+    bench "unify-subst-iter1" (whnf (build . uncurry subst) (sub', t2)),+    bench "unify-subst-iter2" (whnf (build . uncurry subst) (sub', u2)),+    bench "unify-subst-closed1" (whnf (build . uncurry subst) (csub', t2)),+    bench "unify-subst-closed2" (whnf (build . uncurry subst) (csub', u2)),+    bench "mgu-tri" (whnf (uncurry mgu1) (t2, u2)),+    bench "mgu-close" (whnf (uncurry mgu2) (t2, u2)),+    bench "make-constant" (whnf (build . uncurry fun) (F 0 0, emptyTermList)),+    bench "baseline" (whnf (uncurry (+)) (0 :: Int, 0))]++prop :: Bool -> NonNegative (Small Int) -> NonNegative (Small Int) -> Property+prop fun_ (NonNegative (Small index_)) (NonNegative (Small size_)) =+  (isFun x, index x, size x) === (fun_, index_, size_)+  where+    x = toSymbol (fromSymbol (Symbol fun_ index_ size_))++prop2 :: Int64 -> Property+prop2 x = fromSymbol (toSymbol x) === x
+ misc/ring_conn.pl view
@@ -0,0 +1,801 @@+:- module(ring_conn, [step/1, lemma/1]).+:- discontiguous(step/1).+:- discontiguous(lemma/1).+:- style_check(-singleton).+step(add(rule(1, (X1 + X2) = (X2 + X1)))).+step(add(rule(2, ((X1 + X2) + X3) = (X1 + (X2 + X3))))).+step(add(rule(3, (0 + X1) = X1))).+step(add(rule(4, (X1 + -X1) = 0))).+step(add(rule(5, ((X1 * X2) * X3) = (X1 * (X2 * X3))))).+step(add(rule(6, ((X1 * X2) + (X1 * X3)) = (X1 * (X2 + X3))))).+step(add(rule(7, ((X1 * X3) + (X2 * X3)) = ((X1 + X2) * X3)))).+step(add(rule(8, (X1 * (X1 * X1)) = X1))).+step(add(rule(9, -0 = 0))).+step(add(rule(10, (X1 + 0) = X1))).+step(add(rule(11, (X1 + (-X1 + X2)) = X2))).+step(add(rule(12, -(-X1) = X1))).+step(add(rule(13, (X1 + (X2 + X3)) = (X3 + (X1 + X2))))).+step(add(rule(14, (X1 + (X2 + X3)) = (X2 + (X1 + X3))))).+step(add(rule(15, ((X1 + X1) * X2) = (X1 * (X2 + X2))))).+step(add(rule(16, (X2 + (X1 + -X2)) = X1))).+step(add(rule(17, (0 * (X1 + X1)) = (0 * X1)))).+step(add(rule(18, (X1 * (X1 * (X1 * X2))) = (X1 * X2)))).+step(hard((X1 + (X2 + X3)) = (X3 + (X2 + X1)))).+step(hard((X1 + (X2 + X3)) = (X1 + (X3 + X2)))).+step(add(rule(19, (X1 + (X2 + -(X1 + X2))) = 0))).+step(add(rule(20, (X1 + -(-X2 + X1)) = X2))).+step(add(rule(21, (X1 * ((X1 * X1) + X2)) = (X1 + (X1 * X2))))).+step(add(rule(22, (X1 + (X1 * 0)) = X1))).+step(add(rule(23, (X1 * 0) = 0))).+step(add(rule(24, (X1 * (X2 + (X1 * X1))) = (X1 + (X1 * X2))))).+step(add(rule(25, (X2 + -(X1 + X2)) = -X1))).+step(add(rule(26, ((X1 + X1) * (X1 * X1)) = (X1 + X1)))).+step(hard(0 = (X1 + (X2 + -(X2 + X1))))).+step(add(rule(27, (X2 + -(X2 + -X1)) = X1))).+step(add(rule(28, -(-X1 + -X2) = (X2 + X1)))).+step(add(rule(29, (X1 * (0 * X2)) = (0 * X2)))).+step(add(rule(30, (X1 + (X2 * (X1 * X1))) = ((X1 + X2) * (X1 * X1))))).+step(add(rule(31, (X2 + -(X2 + X1)) = -X1))).+step(hard((-X1 + (X2 + (X3 + X1))) = (X3 + X2))).+step(add(rule(32, (X3 + (X2 + (-X3 + X1))) = (X1 + X2)))).+step(add(rule(33, (X3 + (X1 + (X2 + -X3))) = (X1 + X2)))).+step(add(rule(34, -(X1 + -X2) = (X2 + -X1)))).+step(add(rule(35, (-X1 + -X2) = -(X2 + X1)))).+step(add(rule(36, (X1 + (X1 * -(X1 * X1))) = 0))).+step(add(rule(37, (-X1 * -(-X1 * -X1)) = X1))).+step(add(rule(38, (-X1 * (-X1 * X1)) = X1))).+step(add(rule(39, (X1 * -(X1 * X1)) = -X1))).+step(hard((X1 + (X2 + (X3 + X4))) = (X2 + (X3 + (X4 + X1))))).+step(hard((X1 + (X2 + (X3 + X4))) = (X3 + (X2 + (X4 + X1))))).+step(hard((X1 + (X2 + (X3 + X4))) = (X3 + (X4 + (X1 + X2))))).+step(hard((X1 + (X2 + (X3 + X4))) = (X4 + (X3 + (X1 + X2))))).+step(hard((X1 + (X2 + (X3 + X4))) = (X3 + (X1 + (X2 + X4))))).+step(hard((X1 + (X2 + (X3 + X4))) = (X4 + (X2 + (X3 + X1))))).+step(hard((X1 + (X2 + (X3 + X4))) = (X2 + (X4 + (X1 + X3))))).+step(add(rule(40, ((X1 + X1) * (X2 * X3)) = (X1 * ((X2 + X2) * X3))))).+step(add(rule(41, (X1 * (X1 * (X1 + X1))) = (X1 + X1)))).+step(add(rule(42, (X1 * (X2 * (X3 + X3))) = (X1 * ((X2 + X2) * X3))))).+step(add(rule(43, (X1 + (X1 * (X1 * X2))) = (X1 * (X1 * (X1 + X2)))))).+step(add(rule(44, (X1 + (X1 * (X2 * X1))) = (X1 * ((X1 + X2) * X1))))).+step(add(rule(45, (X1 + (0 * X1)) = X1))).+step(add(rule(46, (0 * X1) = 0))).+step(add(rule(47, (X2 + (X3 + (-(X2 + X3) + X1))) = X1))).+step(hard((X1 + (X2 + (-(X2 + X1) + X3))) = X3)).+step(add(rule(48, (X1 * (X1 * -X1)) = -X1))).+step(add(rule(49, -(-X1 + X2) = (X1 + -X2)))).+step(add(rule(50, ((X1 * X2) + ((X1 * X3) + X4)) = ((X1 * (X2 + X3)) + X4)))).+step(add(rule(51, ((X1 * X2) + ((X3 * X2) + X4)) = (((X1 + X3) * X2) + X4)))).+step(add(rule(52, ((X1 * (X2 * X4)) + (X3 * X4)) = (((X1 * X2) + X3) * X4)))).+step(add(rule(53, (((X1 * X1) + X2) * X1) = (X1 + (X2 * X1))))).+step(add(rule(54, (X1 + (-(X1 * X1) * X1)) = 0))).+step(add(rule(55, (-(X1 * X1) * X1) = -X1))).+step(add(rule(56, ((X1 + (X1 * X2)) * X3) = (X1 * (X3 + (X2 * X3)))))).+step(add(rule(57, ((X2 + (X1 * X1)) * X1) = (X1 + (X2 * X1))))).+step(add(rule(58, ((X1 * X4) + (X2 * (X3 * X4))) = ((X1 + (X2 * X3)) * X4)))).+step(add(rule(59, (X1 * (X2 * (X1 * (X2 * (X1 * X2))))) = (X1 * X2)))).+step(add(rule(60, (X1 * ((X1 * (X1 * X2)) + X3)) = (X1 * (X2 + X3))))).+step(add(rule(61, (X1 * (X2 + (X1 * (X1 * X3)))) = (X1 * (X2 + X3))))).+step(add(rule(62, (X1 * (X2 + X2)) = (X1 * (X1 * ((X1 + X1) * X2)))))).+step(add(rule(63, (X1 * (X1 * (X1 + (X1 * X2)))) = (X1 + (X1 * X2))))).+step(add(rule(64, (X1 + (X1 * (-(X1 * X1) + X2))) = (X1 * X2)))).+step(add(rule(65, ((X1 + X1) * (X2 * X3)) = (X1 * (X2 * (X3 + X3)))))).+step(add(rule(66, (-(X1 * X3) + (X1 * (X2 + X3))) = (X1 * X2)))).+step(add(rule(67, -(X1 * -X2) = (X1 * X2)))).+step(add(rule(68, -(X1 * X2) = (X1 * -X2)))).+step(add(rule(69, (X1 * (X2 * (-X2 * -X2))) = (X1 * X2)))).+step(add(rule(70, (-X1 * (X1 * -X1)) = X1))).+step(add(rule(71, (X1 * (-X1 * -X1)) = X1))).+step(add(rule(72, (-X1 * (X1 * X1)) = -X1))).+step(add(rule(73, (X1 * (-X1 * X1)) = -X1))).+step(add(rule(74, ((X2 * -X3) + ((X1 + X2) * X3)) = (X1 * X3)))).+step(add(rule(75, (-X1 * -X2) = (X1 * X2)))).+step(add(rule(76, (-X1 * X2) = (X1 * -X2)))).+step(add(rule(77, (X2 + (X3 + (X1 + -(X2 + X3)))) = X1))).+step(hard(X1 = (X2 + (X3 + (-(X3 + X2) + X1))))).+step(add(rule(78, ((X1 + (X1 * X1)) * (X1 * X1)) = (X1 + (X1 * X1))))).+step(add(rule(79, (X1 + (X1 * ((X1 + X1) * -X1))) = -X1))).+step(add(rule(80, ((X1 * X2) + (X3 + (X1 * X4))) = (X3 + (X1 * (X4 + X2)))))).+step(add(rule(81, ((X1 * X2) + (X3 + (X4 * X2))) = (X3 + ((X4 + X1) * X2))))).+step(add(rule(82, ((X1 + X2) * (X3 + X3)) = ((X1 + (X2 + (X1 + X2))) * X3)))).+step(add(rule(83, ((X1 + (X1 + X2)) * X3) = ((X1 * (X3 + X3)) + (X2 * X3))))).+step(add(rule(84, ((X1 + (X1 + X1)) * X2) = (X1 * (X2 + (X2 + X2)))))).+step(add(rule(85, ((X1 + (X2 + X2)) * X3) = ((X1 * X3) + (X2 * (X3 + X3)))))).+step(hard(((X1 + X2) * (X3 + X3)) = ((X2 + (X1 + (X2 + X1))) * X3))).+step(add(rule(86, ((X1 + X1) * (X2 + X3)) = (X1 * (X2 + (X3 + (X2 + X3))))))).+step(add(rule(87, (X1 * (X2 + (X2 + X3))) = (((X1 + X1) * X2) + (X1 * X3))))).+step(add(rule(88, (X1 * (X2 + (X3 + X3))) = ((X1 * X2) + ((X1 + X1) * X3))))).+step(add(rule(89, (X1 + (X1 * (X2 + X2))) = (X1 + ((X1 + X1) * X2))))).+step(add(rule(90, (X1 * -(X2 + X2)) = ((X1 + X1) * -X2)))).+step(hard(((X1 + X1) * (X2 + X3)) = (X1 * (X3 + (X2 + (X3 + X2)))))).+step(add(rule(91, (X1 * (((X1 * X1) + X2) * X3)) = ((X1 + (X1 * X2)) * X3)))).+step(add(rule(92, (X1 * (X3 + ((X1 * X1) + X2))) = (X1 + (X1 * (X2 + X3)))))).+step(add(rule(93, (X1 * (X2 + (X3 + (X1 * X1)))) = (X1 + (X1 * (X2 + X3)))))).+step(add(rule(94, (X1 * ((X2 + (X1 * X1)) * X3)) = ((X1 + (X1 * X2)) * X3)))).+step(add(rule(95, (X1 + (-(X2 + X1) + X3)) = (-X2 + X3)))).+step(add(rule(96, (X3 + -(X1 + (X2 + X3))) = -(X1 + X2)))).+step(add(rule(97, (X1 + (X2 + -(X3 + X1))) = (X2 + -X3)))).+step(add(rule(98, (((X1 * X1) + X2) * (X1 * X3)) = ((X1 + (X2 * X1)) * X3)))).+step(add(rule(99, ((X1 + (X2 * X3)) * (X3 * X3)) = (((X1 * X3) + X2) * X3)))).+step(add(rule(100, ((X1 + (X2 * X2)) * (X2 * X3)) = ((X2 + (X1 * X2)) * X3)))).+step(add(rule(101, (X1 * (X1 * -(X1 + X1))) = -(X1 + X1)))).+step(add(rule(102, (X1 * (X1 * ((X1 + X1) * X2))) = ((X1 + X1) * X2)))).+step(add(rule(103, ((X1 + (X1 + X1)) * (X1 * X1)) = (X1 + (X1 + X1))))).+step(add(rule(104, ((X1 + (X1 * (X2 * X2))) * X2) = (X1 * (X2 + X2))))).+step(add(rule(105, (((X1 * (X2 * X2)) + X3) * X2) = ((X1 + X3) * X2)))).+step(add(rule(106, (X1 + (X1 * (X2 + (X1 * -X1)))) = (X1 * X2)))).+step(add(rule(107, (X1 + (((X1 * -X1) + X2) * X1)) = (X2 * X1)))).+step(add(rule(108, (X1 + ((X2 + (X1 * -X1)) * X1)) = (X2 * X1)))).+step(add(rule(109, (X1 + ((-X2 + (X1 * X1)) * -X1)) = (X2 * X1)))).+step(add(rule(110, ((X3 * -X2) + ((X3 + X1) * X2)) = (X1 * X2)))).+step(hard(X1 = (X2 + (X3 + (X1 + -(X3 + X2)))))).+step(add(rule(111, ((X3 * X2) + ((X1 + X3) * -X2)) = (X1 * -X2)))).+step(add(rule(112, ((X1 + (X1 + (X1 + X1))) * X2) = (X1 * (X2 + (X2 + (X2 + X2))))))).+step(add(rule(113, ((X1 * X3) + (X2 * (X1 * (X1 * X3)))) = ((X1 + X2) * (X1 * (X1 * X3)))))).+step(add(rule(114, (X1 * ((X1 + X1) * ((X1 + X1) * (X2 + X2)))) = ((X1 + X1) * X2)))).+step(add(rule(115, (((X1 + X2) * (X1 * X1)) + X3) = (X1 + ((X2 * (X1 * X1)) + X3))))).+step(interreduce).+step(delete(rule(11, (X1 + (-X1 + X2)) = X2))).+step(delete(rule(13, (X1 + (X2 + X3)) = (X3 + (X1 + X2))))).+step(delete(rule(17, (0 * (X1 + X1)) = (0 * X1)))).+step(delete(rule(19, (X1 + (X2 + -(X1 + X2))) = 0))).+step(delete(rule(20, (X1 + -(-X2 + X1)) = X2))).+step(delete(rule(21, (X1 * ((X1 * X1) + X2)) = (X1 + (X1 * X2))))).+step(delete(rule(22, (X1 + (X1 * 0)) = X1))).+step(delete(rule(25, (X2 + -(X1 + X2)) = -X1))).+step(delete(rule(26, ((X1 + X1) * (X1 * X1)) = (X1 + X1)))).+step(delete(rule(27, (X2 + -(X2 + -X1)) = X1))).+step(delete(rule(28, -(-X1 + -X2) = (X2 + X1)))).+step(delete(rule(29, (X1 * (0 * X2)) = (0 * X2)))).+step(delete(rule(36, (X1 + (X1 * -(X1 * X1))) = 0))).+step(delete(rule(37, (-X1 * -(-X1 * -X1)) = X1))).+step(delete(rule(38, (-X1 * (-X1 * X1)) = X1))).+step(delete(rule(39, (X1 * -(X1 * X1)) = -X1))).+step(delete(rule(45, (X1 + (0 * X1)) = X1))).+step(delete(rule(47, (X2 + (X3 + (-(X2 + X3) + X1))) = X1))).+step(delete(rule(50, ((X1 * X2) + ((X1 * X3) + X4)) = ((X1 * (X2 + X3)) + X4)))).+step(delete(rule(51, ((X1 * X2) + ((X3 * X2) + X4)) = (((X1 + X3) * X2) + X4)))).+step(delete(rule(53, (((X1 * X1) + X2) * X1) = (X1 + (X2 * X1))))).+step(delete(rule(54, (X1 + (-(X1 * X1) * X1)) = 0))).+step(delete(rule(55, (-(X1 * X1) * X1) = -X1))).+step(delete(rule(60, (X1 * ((X1 * (X1 * X2)) + X3)) = (X1 * (X2 + X3))))).+step(delete(rule(62, (X1 * (X2 + X2)) = (X1 * (X1 * ((X1 + X1) * X2)))))).+step(delete(rule(64, (X1 + (X1 * (-(X1 * X1) + X2))) = (X1 * X2)))).+step(delete(rule(66, (-(X1 * X3) + (X1 * (X2 + X3))) = (X1 * X2)))).+step(delete(rule(67, -(X1 * -X2) = (X1 * X2)))).+step(delete(rule(69, (X1 * (X2 * (-X2 * -X2))) = (X1 * X2)))).+step(delete(rule(70, (-X1 * (X1 * -X1)) = X1))).+step(delete(rule(71, (X1 * (-X1 * -X1)) = X1))).+step(delete(rule(72, (-X1 * (X1 * X1)) = -X1))).+step(delete(rule(73, (X1 * (-X1 * X1)) = -X1))).+step(delete(rule(74, ((X2 * -X3) + ((X1 + X2) * X3)) = (X1 * X3)))).+step(delete(rule(75, (-X1 * -X2) = (X1 * X2)))).+step(delete(rule(77, (X2 + (X3 + (X1 + -(X2 + X3)))) = X1))).+step(delete(rule(78, ((X1 + (X1 * X1)) * (X1 * X1)) = (X1 + (X1 * X1))))).+step(delete(rule(79, (X1 + (X1 * ((X1 + X1) * -X1))) = -X1))).+step(delete(rule(91, (X1 * (((X1 * X1) + X2) * X3)) = ((X1 + (X1 * X2)) * X3)))).+step(delete(rule(95, (X1 + (-(X2 + X1) + X3)) = (-X2 + X3)))).+step(delete(rule(98, (((X1 * X1) + X2) * (X1 * X3)) = ((X1 + (X2 * X1)) * X3)))).+step(delete(rule(107, (X1 + (((X1 * -X1) + X2) * X1)) = (X2 * X1)))).+step(add(rule(116, (X1 + (X2 * (X3 * (X1 * X1)))) = ((X1 + (X2 * X3)) * (X1 * X1))))).+step(add(rule(117, (X1 + (X2 + (X3 * (X1 * X1)))) = (X2 + ((X1 + X3) * (X1 * X1)))))).+step(add(rule(118, (X1 * (X1 * (X1 + (X1 + X1)))) = (X1 + (X1 + X1))))).+step(add(rule(119, ((X1 + (X2 + X2)) * (X1 * X1)) = (X1 + (X2 * (X1 * (X1 + X1))))))).+step(add(rule(120, (X1 + (X1 * (X2 * (X3 * X1)))) = (X1 * (((X2 * X3) + X1) * X1))))).+step(add(rule(121, ((X2 * -X3) + (X1 * X3)) = ((X1 + -X2) * X3)))).+step(add(rule(122, (X1 + (-(X1 + X2) + X3)) = (-X2 + X3)))).+step(add(rule(123, (X1 + (X2 + -(X1 + X3))) = (X2 + -X3)))).+step(add(rule(124, (X3 + -(X1 + (X3 + X2))) = -(X1 + X2)))).+step(add(rule(125, (X1 * (X1 * (X2 + (X1 * X3)))) = (X1 * ((X1 * X2) + X3))))).+step(add(rule(126, ((X3 + (X3 + (X2 + X2))) * X4) = ((X3 + X2) * (X4 + X4))))).+step(hard(((X1 + X2) * (X3 + X3)) = ((X1 + (X2 + (X2 + X1))) * X3))).+step(hard(((X1 + X2) * (X3 + X3)) = ((X2 + (X1 + (X1 + X2))) * X3))).+step(hard(((X1 * (X2 + X2)) + (X3 * X2)) = ((X1 + (X3 + X1)) * X2))).+step(add(rule(127, ((X1 + (X1 + X2)) * X3) = ((X2 * X3) + (X1 * (X3 + X3)))))).+step(hard(((X1 + (X1 + X2)) * X3) = ((X2 + (X1 + X1)) * X3))).+step(hard(((X1 * X2) + (X3 * (X2 + X2))) = ((X3 + (X1 + X3)) * X2))).+step(hard(((X1 + (X2 + X2)) * X3) = ((X2 * (X3 + X3)) + (X1 * X3)))).+step(add(rule(128, (X1 * (X4 + (X4 + (X3 + X3)))) = ((X1 + X1) * (X4 + X3))))).+step(hard(((X1 + X1) * (X2 + X3)) = (X1 * (X2 + (X3 + (X3 + X2)))))).+step(hard(((X1 + X1) * (X2 + X3)) = (X1 * (X3 + (X2 + (X2 + X3)))))).+step(hard((((X1 + X1) * X2) + (X1 * X3)) = (X1 * (X2 + (X3 + X2))))).+step(add(rule(129, (X1 * (X2 + (X2 + X3))) = ((X1 * X3) + ((X1 + X1) * X2))))).+step(hard((X1 * (X2 + (X2 + X3))) = (X1 * (X3 + (X2 + X2))))).+step(hard(((X1 * X2) + ((X1 + X1) * X3)) = (X1 * (X3 + (X2 + X3))))).+step(hard((X1 * (X2 + (X3 + X3))) = (((X1 + X1) * X3) + (X1 * X2)))).+step(add(rule(130, (X1 * ((X1 * (X1 * X2)) + (X3 + X3))) = ((X1 * X2) + ((X1 + X1) * X3))))).+step(add(rule(131, (((X3 * X2) + X1) * (X2 * X2)) = (((X1 * X2) + X3) * X2)))).+step(add(rule(132, (X2 + (-X2 + (X1 * -X2))) = (X1 * -X2)))).+step(add(rule(133, (X1 * ((X1 + X1) * (X1 + (X1 + (X1 + X1))))) = (X1 + X1)))).+step(add(rule(134, (X4 + (X2 + (X3 + (-X4 + X1)))) = (X1 + (X2 + X3))))).+step(add(rule(135, -(X1 + (-X2 + X3)) = (X2 + -(X3 + X1))))).+step(add(rule(136, (X4 + (X1 + (X2 + (X3 + -X4)))) = (X1 + (X2 + X3))))).+step(add(rule(137, -(X1 + (X2 + -X3)) = (X3 + -(X1 + X2))))).+step(add(rule(138, (-X1 + (-X2 + X3)) = (-(X2 + X1) + X3)))).+step(add(rule(139, (-X1 + (X2 + -X3)) = (X2 + -(X3 + X1))))).+step(add(rule(140, -(X3 + (X1 * -X2)) = ((X1 * X2) + -X3)))).+step(add(rule(141, ((X2 * -X3) + -X1) = -(X1 + (X2 * X3))))).+step(add(rule(142, (-X3 + (X1 * -X2)) = -((X1 * X2) + X3)))).+step(add(rule(143, ((X1 + -X2) * -X3) = ((X2 + -X1) * X3)))).+step(add(rule(144, ((X2 + (X1 * (X3 * X3))) * X3) = ((X1 + X2) * X3)))).+step(add(rule(145, ((X1 + X1) * (X1 + (X1 + (X1 + X1)))) = (X1 * (X1 + X1))))).+step(add(rule(146, (X1 + (X1 * ((X1 * -X1) + X2))) = (X1 * X2)))).+step(add(rule(147, (X2 + (-X2 + (X1 * X2))) = (X1 * X2)))).+step(add(rule(148, ((X1 * (X2 + X2)) + ((X1 + X1) * X3)) = ((X1 + X1) * (X2 + X3))))).+step(add(rule(149, (((X1 + X1) * X2) + (X1 * (X3 + X3))) = ((X1 + X1) * (X2 + X3))))).+step(add(rule(150, (X1 + (X1 + ((X1 + X1) * X2))) = ((X1 + X1) * (X2 + (X1 * X1)))))).+step(add(rule(151, (((X1 + X1) * X3) + (X2 * (X3 + X3))) = ((X1 + X2) * (X3 + X3))))).+step(add(rule(152, ((X1 * (X3 + X3)) + ((X2 + X2) * X3)) = ((X1 + X2) * (X3 + X3))))).+step(add(rule(153, (((X1 + X1) * -X2) + X3) = ((X1 * -(X2 + X2)) + X3)))).+step(add(rule(154, ((X1 * (X2 + X2)) + X3) = (((X1 + X1) * X2) + X3)))).+step(add(rule(155, (X1 + ((X2 + X2) * X3)) = (X1 + (X2 * (X3 + X3)))))).+step(add(rule(156, (X1 + ((X1 + (X1 * X1)) * -X1)) = (X1 * -X1)))).+step(add(rule(157, (X2 + ((X1 + (X2 * X2)) * -X2)) = (X1 * -X2)))).+step(add(rule(158, ((((X2 * -X2) + X1) * -X2) + X3) = (X2 + (X3 + (X1 * -X2)))))).+step(add(rule(159, ((X3 * X2) + ((X3 + X1) * -X2)) = (X1 * -X2)))).+step(add(rule(160, (((? * X2) + ((? * X2) + ((X3 + ?) * -(X2 + X2)))) * X4) = (X3 * (X2 * -(X4 + X4)))))).+step(add(rule(161, (((X1 * X2) + ((X1 * X2) + ((X3 + X1) * -(X2 + X2)))) * X4) = (((? * X2) + ((? * X2) + ((X3 + ?) * -(X2 + X2)))) * X4)))).+step(interreduce).+step(delete(rule(63, (X1 * (X1 * (X1 + (X1 * X2)))) = (X1 + (X1 * X2))))).+step(delete(rule(82, ((X1 + X2) * (X3 + X3)) = ((X1 + (X2 + (X1 + X2))) * X3)))).+step(delete(rule(85, ((X1 + (X2 + X2)) * X3) = ((X1 * X3) + (X2 * (X3 + X3)))))).+step(delete(rule(86, ((X1 + X1) * (X2 + X3)) = (X1 * (X2 + (X3 + (X2 + X3))))))).+step(delete(rule(88, (X1 * (X2 + (X3 + X3))) = ((X1 * X2) + ((X1 + X1) * X3))))).+step(delete(rule(89, (X1 + (X1 * (X2 + X2))) = (X1 + ((X1 + X1) * X2))))).+step(delete(rule(96, (X3 + -(X1 + (X2 + X3))) = -(X1 + X2)))).+step(delete(rule(104, ((X1 + (X1 * (X2 * X2))) * X2) = (X1 * (X2 + X2))))).+step(delete(rule(105, (((X1 * (X2 * X2)) + X3) * X2) = ((X1 + X3) * X2)))).+step(delete(rule(109, (X1 + ((-X2 + (X1 * X1)) * -X1)) = (X2 * X1)))).+step(delete(rule(110, ((X3 * -X2) + ((X3 + X1) * X2)) = (X1 * X2)))).+step(delete(rule(111, ((X3 * X2) + ((X1 + X3) * -X2)) = (X1 * -X2)))).+step(delete(rule(122, (X1 + (-(X1 + X2) + X3)) = (-X2 + X3)))).+step(delete(rule(132, (X2 + (-X2 + (X1 * -X2))) = (X1 * -X2)))).+step(delete(rule(133, (X1 * ((X1 + X1) * (X1 + (X1 + (X1 + X1))))) = (X1 + X1)))).+step(delete(rule(134, (X4 + (X2 + (X3 + (-X4 + X1)))) = (X1 + (X2 + X3))))).+step(delete(rule(135, -(X1 + (-X2 + X3)) = (X2 + -(X3 + X1))))).+step(delete(rule(138, (-X1 + (-X2 + X3)) = (-(X2 + X1) + X3)))).+step(delete(rule(156, (X1 + ((X1 + (X1 * X1)) * -X1)) = (X1 * -X1)))).+step(delete(rule(160, (((? * X2) + ((? * X2) + ((X3 + ?) * -(X2 + X2)))) * X4) = (X3 * (X2 * -(X4 + X4)))))).+step(add(rule(162, (((? * X2) + ((? * X2) + ((? + X3) * -(X2 + X2)))) * X4) = (X3 * (X2 * -(X4 + X4)))))).+step(delete(rule(161, (((X1 * X2) + ((X1 * X2) + ((X3 + X1) * -(X2 + X2)))) * X4) = (((? * X2) + ((? * X2) + ((X3 + ?) * -(X2 + X2)))) * X4)))).+step(add(rule(163, (((X1 * X2) + ((X1 * X2) + ((X3 + X1) * -(X2 + X2)))) * X4) = (((? * X2) + ((? * X2) + ((? + X3) * -(X2 + X2)))) * X4)))).+step(add(rule(164, (X1 * (X2 * ((X3 + X3) * X4))) = ((X1 + X1) * (X2 * (X3 * X4)))))).+step(add(rule(165, (X1 * (X2 * ((X3 + X3) * X4))) = (X1 * ((X2 + X2) * (X3 * X4)))))).+step(add(rule(166, ((X1 + X1) * (X2 * ((X2 + X2) * (X2 + X2)))) = (X1 * (X2 + X2))))).+step(add(rule(167, (X1 * (X2 * (X3 * (X4 + X4)))) = (X1 * (X2 * ((X3 + X3) * X4)))))).+step(add(rule(168, (X1 * (((X2 + X2) * X3) + X4)) = (X1 * ((X2 * (X3 + X3)) + X4))))).+step(add(rule(169, (X1 * (X2 + ((X3 + X3) * X4))) = (X1 * (X2 + (X3 * (X4 + X4))))))).+step(add(rule(170, ((X1 * (X1 * (X1 + X2))) + X3) = (X1 + ((X1 * (X1 * X2)) + X3))))).+step(add(rule(171, (X1 + (X2 + (X1 * (X1 * X3)))) = (X2 + (X1 * (X1 * (X1 + X3))))))).+step(add(rule(172, (X1 * (X1 * (X1 + (X2 + X2)))) = (X1 + (X1 * ((X1 + X1) * X2)))))).+step(add(rule(173, ((X1 * ((X1 + X2) * X1)) + X3) = (X1 + ((X1 * (X2 * X1)) + X3))))).+step(add(rule(174, (X1 + (X2 + (X1 * (X3 * X1)))) = (X2 + (X1 * ((X1 + X3) * X1)))))).+step(add(rule(175, (X1 * ((X1 + (X2 + X2)) * X1)) = (X1 + (X1 * (X2 * (X1 + X1))))))).+step(add(rule(176, ((((X1 + X1) * X2) + X3) * X4) = (((X1 * (X2 + X2)) + X3) * X4)))).+step(add(rule(177, ((X1 + (X1 * X2)) * (X3 * X4)) = (X1 * ((X3 + (X2 * X3)) * X4))))).+step(add(rule(178, (X1 * (X2 * (X3 + (X4 * X3)))) = (X1 * ((X2 + (X2 * X4)) * X3))))).+step(add(rule(179, (X1 * (X2 + ((X3 + X3) * X2))) = ((X1 + ((X1 + X1) * X3)) * X2)))).+step(add(rule(180, (X1 * (X2 + (X1 * (X3 * X2)))) = (X1 * (X1 * ((X1 + X3) * X2)))))).+step(add(rule(181, (X1 * (X2 + (X3 * (X1 * X2)))) = (X1 * ((X1 + X3) * (X1 * X2)))))).+step(add(rule(182, ((X1 + (X1 * (X2 * X3))) * X4) = (X1 * (X4 + (X2 * (X3 * X4))))))).+step(add(rule(183, ((X1 + (X1 * (X2 + X2))) * X3) = (X1 * (X3 + (X2 * (X3 + X3))))))).+step(add(rule(184, ((X1 + ((X2 + X2) * X3)) * X4) = ((X1 + (X2 * (X3 + X3))) * X4)))).+step(add(rule(185, (X1 * -(X2 + (X1 * X1))) = -(X1 + (X1 * X2))))).+step(add(rule(186, ((X1 + (X2 * X2)) * -X2) = -(X2 + (X1 * X2))))).+step(add(rule(187, ((X2 * X1) + -(X1 + (X2 * X1))) = -X1))).+step(add(rule(188, ((X1 * X3) + (X2 * -X3)) = ((X1 + -X2) * X3)))).+step(add(rule(189, ((X1 * X2) + (X3 * (X2 + X4))) = ((X3 * X4) + ((X1 + X3) * X2))))).+step(hard(((X1 + (X3 + X1)) * X2) = ((X3 + (X1 + X1)) * X2))).+step(hard(((X1 + (X3 + X1)) * X2) = ((X1 + (X1 + X3)) * X2))).+step(add(rule(190, (X1 + (X1 * ((X1 * X2) + X3))) = (X1 * (X3 + (X1 * (X1 + X2))))))).+step(add(rule(191, (X1 + (X1 * ((X2 * X1) + X3))) = (X1 * (X3 + ((X1 + X2) * X1)))))).+step(hard(((X1 + (X1 + X2)) * (X2 * X2)) = (X2 + (X1 * (X2 * (X2 + X2)))))).+step(hard((X1 + (X1 * (X2 * (X1 + X1)))) = (X1 * ((X2 + (X2 + X1)) * X1)))).+step(hard((X1 + (X1 * ((X1 + X1) * X2))) = (X1 * (X1 * (X2 + (X2 + X1)))))).+step(add(rule(192, (X1 * ((X2 * X3) + ((X2 * X3) + X4))) = (X1 * (((X2 + X2) * X3) + X4))))).+step(add(rule(193, (X1 * (X2 + (X2 + (X3 * X2)))) = ((X1 + (X1 + (X1 * X3))) * X2)))).+step(add(rule(194, (X1 + (X1 + (X1 * (X2 + X2)))) = ((X1 + X1) * ((X1 * X1) + X2))))).+step(add(rule(195, (X1 + (X1 * (X2 + (X1 * X3)))) = (X1 * (X2 + (X1 * (X3 + X1))))))).+step(add(rule(196, (X1 + (X1 * (X2 + (X3 * X1)))) = (X1 * (X2 + ((X3 + X1) * X1)))))).+step(add(rule(197, ((X1 + (X2 + (X1 * X1))) * (X1 * X1)) = (X1 + ((X1 + (X2 * X1)) * X1))))).+step(add(rule(198, ((X1 + (X2 * -X2)) * -X2) = (X2 + (X1 * -X2))))).+step(add(rule(199, (((X2 + X1) * (X1 * X1)) + X3) = (X1 + ((X2 * (X1 * X1)) + X3))))).+step(add(rule(200, (X1 + (((X2 * X1) + X3) * X1)) = ((((X1 + X2) * X1) + X3) * X1)))).+step(add(rule(201, (X1 + ((X2 + X3) * (X2 * X2))) = (X2 + ((X3 * (X2 * X2)) + X1))))).+step(add(rule(202, ((X1 + ((X1 * X1) + X2)) * (X1 * X1)) = ((X1 + ((X2 + X1) * X1)) * X1)))).+step(add(rule(203, (X1 + (X2 + (X3 * (X1 * X1)))) = (X2 + ((X3 + X1) * (X1 * X1)))))).+step(add(rule(204, (X1 + ((X2 + (X3 * X1)) * X1)) = ((X2 + ((X1 + X3) * X1)) * X1)))).+step(hard((X1 + (X2 * (X1 * (X1 + X1)))) = ((X2 + (X1 + X2)) * (X1 * X1)))).+step(add(rule(205, ((X1 + X1) * (X2 + (X2 + X2))) = ((X1 + (X1 + X1)) * (X2 + X2))))).+step(add(rule(206, (X1 * (X2 + (X2 + (X1 * (X1 + X1))))) = ((X1 + X1) * (X2 + (X1 * X1)))))).+step(simplify_queue).+step(interreduce).+step(delete(rule(106, (X1 + (X1 * (X2 + (X1 * -X1)))) = (X1 * X2)))).+step(delete(rule(117, (X1 + (X2 + (X3 * (X1 * X1)))) = (X2 + ((X1 + X3) * (X1 * X1)))))).+step(delete(rule(121, ((X2 * -X3) + (X1 * X3)) = ((X1 + -X2) * X3)))).+step(delete(rule(146, (X1 + (X1 * ((X1 * -X1) + X2))) = (X1 * X2)))).+step(delete(rule(157, (X2 + ((X1 + (X2 * X2)) * -X2)) = (X1 * -X2)))).+step(delete(rule(158, ((((X2 * -X2) + X1) * -X2) + X3) = (X2 + (X3 + (X1 * -X2)))))).+step(delete(rule(159, ((X3 * X2) + ((X3 + X1) * -X2)) = (X1 * -X2)))).+step(delete(rule(190, (X1 + (X1 * ((X1 * X2) + X3))) = (X1 * (X3 + (X1 * (X1 + X2))))))).+step(delete(rule(191, (X1 + (X1 * ((X2 * X1) + X3))) = (X1 * (X3 + ((X1 + X2) * X1)))))).+step(delete(rule(197, ((X1 + (X2 + (X1 * X1))) * (X1 * X1)) = (X1 + ((X1 + (X2 * X1)) * X1))))).+step(add(rule(207, ((X1 + (X2 + (X1 * X1))) * (X1 * X1)) = ((X1 + ((X1 + X2) * X1)) * X1)))).+step(delete(rule(200, (X1 + (((X2 * X1) + X3) * X1)) = ((((X1 + X2) * X1) + X3) * X1)))).+step(delete(rule(202, ((X1 + ((X1 * X1) + X2)) * (X1 * X1)) = ((X1 + ((X2 + X1) * X1)) * X1)))).+step(hard(((X1 + X3) * (X2 + X2)) = ((X3 + X1) * (X2 + X2)))).+step(hard(((X1 + X1) * (X2 + X3)) = ((X1 + X1) * (X3 + X2)))).+step(add(rule(208, (X2 + (X2 + (X1 * (X2 * (X2 + X2))))) = ((X1 + X2) * (X2 * (X2 + X2)))))).+step(add(rule(209, (X1 * ((X1 + X1) * (X1 + X1))) = (X1 + (X1 + (X1 + X1)))))).+step(add(rule(210, (X3 + (X4 + (X2 + (-(X3 + X4) + X1)))) = (X1 + X2)))).+step(add(rule(211, (X3 + (X4 + (X1 + (X2 + -(X3 + X4))))) = (X1 + X2)))).+step(add(rule(212, (X1 * ((X1 * (X1 + X1)) + X2)) = (X1 + (X1 + (X1 * X2)))))).+step(add(rule(213, (X1 * (X2 + (X1 * (X1 + X1)))) = (X1 + (X1 + (X1 * X2)))))).+step(add(rule(214, ((X2 + (X3 + (X1 * X1))) * X1) = (X1 + ((X2 + X3) * X1))))).+step(add(rule(215, (X2 + (X2 + (X1 * (X2 + X2)))) = ((X1 + (X2 * X2)) * (X2 + X2))))).+step(add(rule(216, ((X1 + X1) * (X2 + X2)) = (X1 * ((X1 + X1) * ((X1 + X1) * X2)))))).+step(add(rule(217, ((X1 + X1) * ((X1 + X1) * (X2 + X2))) = (X1 * ((X1 + X1) * X2))))).+step(add(rule(218, (X1 * (X1 * ((X1 * X3) + X2))) = (X1 * ((X1 * X2) + X3))))).+step(hard(((X1 + X2) * (X3 + X3)) = ((X1 + (X2 + (X1 + X2))) * X3))).+step(hard(((X1 + (X1 + (X2 + X2))) * X3) = ((X2 + X1) * (X3 + X3)))).+step(hard(((X1 + X1) * (X2 + X3)) = (X1 * (X2 + (X3 + (X2 + X3)))))).+step(hard((X1 * (X2 + (X2 + (X3 + X3)))) = ((X1 + X1) * (X3 + X2)))).+step(add(rule(219, ((X1 + (X2 * (X2 + X2))) * X2) = (X2 + (X2 + (X1 * X2)))))).+step(add(rule(220, -(X2 + (-X1 + X3)) = (X1 + -(X2 + X3))))).+step(add(rule(221, -((X1 * -X2) + X3) = ((X1 * X2) + -X3)))).+step(add(rule(222, ((? + (-? + X2)) * (X3 + X3)) = ((X2 + X2) * X3)))).+step(add(rule(223, ((X1 + (-X1 + X2)) * (X3 + X3)) = ((? + (-? + X2)) * (X3 + X3))))).+step(add(rule(224, ((X1 + X1) * (? + (-? + X3))) = (X1 * (X3 + X3))))).+step(add(rule(225, ((X1 + X1) * (X2 + (-X2 + X3))) = ((X1 + X1) * (? + (-? + X3)))))).+step(add(rule(226, ((-X1 + X2) * -X3) = ((X1 + -X2) * X3)))).+step(add(rule(227, ((X1 * X2) + -(X3 + (X1 * X2))) = -X3))).+step(add(rule(228, (((X1 + X1) * X2) + X3) = (X3 + (X1 * (X2 + X2)))))).+step(add(rule(229, ((X1 * (X2 + X2)) + X3) = (X3 + ((X1 + X1) * X2))))).+step(add(rule(230, (X1 * (X2 * (X1 * (X2 * (X1 * (X2 * X3)))))) = (X1 * (X2 * X3))))).+step(add(rule(231, ((X1 * (X2 * X3)) + ((X4 * X3) + X5)) = ((((X1 * X2) + X4) * X3) + X5)))).+step(add(rule(232, ((X1 * (X2 * (X3 * X5))) + (X4 * X5)) = (((X1 * (X2 * X3)) + X4) * X5)))).+step(add(rule(233, ((X1 * (X2 * X5)) + (X3 * (X4 * X5))) = (((X1 * X2) + (X3 * X4)) * X5)))).+step(add(rule(234, ((X1 * (X2 * X3)) + (X4 + (X5 * X3))) = (X4 + (((X1 * X2) + X5) * X3))))).+step(add(rule(235, ((((X1 + X1) * X2) + X3) * X4) = ((X1 * (X2 * (X4 + X4))) + (X3 * X4))))).+step(add(rule(236, ((X1 + ((X1 + X1) * X2)) * X3) = (X1 * (X3 + (X2 * (X3 + X3))))))).+step(add(rule(237, (((X1 * (X2 + X2)) + X3) * X4) = ((X1 * (X2 * (X4 + X4))) + (X3 * X4))))).+step(add(rule(238, (((X1 * X2) + (X3 + X3)) * X4) = ((X1 * (X2 * X4)) + (X3 * (X4 + X4)))))).+step(add(rule(239, (((X1 * X1) + (X2 + X2)) * X1) = (X1 + (X2 * (X1 + X1)))))).+step(add(rule(240, ((X1 + X1) * ((X2 + (X1 * X1)) * X3)) = ((X1 + X1) * (X3 + (X2 * X3)))))).+step(add(rule(241, ((X2 + ((X1 * X1) + X2)) * X1) = (X1 + (X2 * (X1 + X1)))))).+step(add(rule(242, (((X1 * X2) + X3) * (X2 * (X2 * X4))) = ((X1 + (X3 * X2)) * (X2 * X4))))).+step(add(rule(243, ((X1 + (X1 * (X2 * -X2))) * (X2 * X3)) = 0))).+step(add(rule(244, (X1 * (X2 + (X2 * (X1 * -X1)))) = 0))).+step(add(rule(245, ((X1 + (X1 * (X2 * -X2))) * (X2 + X2)) = 0))).+step(add(rule(246, (X1 * ((X2 + (X2 * (X1 * -X1))) * X3)) = 0))).+step(add(rule(247, ((X1 + (X1 * (X2 * -X2))) * -X2) = 0))).+step(add(rule(248, (X1 * -(X2 + (X2 * (X1 * -X1)))) = 0))).+step(add(rule(249, (X1 * (-X2 + (X2 * (X1 * X1)))) = 0))).+step(add(rule(250, ((X1 * X2) + ((X3 * (X4 * X2)) + X5)) = (((X1 + (X3 * X4)) * X2) + X5)))).+step(add(rule(251, ((X1 * X5) + (X2 * (X3 * (X4 * X5)))) = ((X1 + (X2 * (X3 * X4))) * X5)))).+step(add(rule(252, ((X1 * X2) + (X3 + (X4 * (X5 * X2)))) = (X3 + ((X1 + (X4 * X5)) * X2))))).+step(add(rule(253, (X1 + ((X2 + (X1 * X3)) * X1)) = ((X2 + (X1 * (X1 + X3))) * X1)))).+step(add(rule(254, ((X1 + (X1 + (X2 * X3))) * X4) = ((X1 * (X4 + X4)) + (X2 * (X3 * X4)))))).+step(add(rule(255, ((X1 + ((X2 + X2) * X3)) * X4) = ((X1 * X4) + (X2 * (X3 * (X4 + X4))))))).+step(add(rule(256, ((X1 + (X2 * (X3 + X3))) * X4) = ((X1 * X4) + (X2 * (X3 * (X4 + X4))))))).+step(add(rule(257, ((X1 + (X2 * X3)) * (X3 * (X3 * X4))) = (((X1 * X3) + X2) * (X3 * X4))))).+step(add(rule(258, (X1 * ((X2 * (X1 * (X2 * (X1 * X2)))) + X3)) = (X1 * (X2 + X3))))).+step(add(rule(259, (X1 * (X2 + (X3 * (X1 * (X3 * (X1 * X3)))))) = (X1 * (X2 + X3))))).+step(add(rule(260, (X2 + ((X1 + X2) * (X2 * -X2))) = (X1 * (X2 * -X2))))).+step(add(rule(261, (X1 * (X2 * -(X3 + X3))) = (X1 * ((X2 + X2) * -X3))))).+step(add(rule(262, (X1 * (X2 + (X3 * X2))) = (X1 * (X1 * ((X1 + (X1 * X3)) * X2)))))).+step(add(rule(263, (X1 * (X2 + (X3 + (X1 * (X1 * X4))))) = (X1 * (X2 + (X3 + X4)))))).+step(add(rule(264, (X1 * ((X2 + (X1 * (X1 * X3))) * X4)) = (X1 * ((X2 + X3) * X4))))).+step(add(rule(265, (X1 * (X2 + (X3 + X3))) = (X1 * (X2 + (X1 * ((X1 + X1) * X3))))))).+step(add(rule(266, (X1 * (X2 + (X1 * (X1 + (X1 * X3))))) = (X1 + (X1 * (X2 + X3)))))).+step(add(rule(267, (X1 * (X2 * -(X3 + X3))) = ((X1 + X1) * (X2 * -X3))))).+step(add(rule(268, ((X1 + (X1 * X2)) * -X3) = (X1 * -(X3 + (X2 * X3)))))).+step(add(rule(269, (X1 + (X2 * (X1 * -X1))) = ((X1 + -X2) * (X1 * X1))))).+step(add(rule(270, ((X1 + X1) * (X1 + X1)) = (X1 * -(X1 + X1))))).+step(add(rule(271, ((X1 + X1) * -(X1 + X1)) = (X1 * (X1 + X1))))).+step(add(rule(272, (X1 + (X1 + (X1 + X1))) = -(X1 + X1)))).+step(add(rule(273, -(X1 + (X1 + X1)) = (X1 + (X1 + X1))))).+step(add(rule(274, (-X1 + (X2 * (X1 * X1))) = ((-X1 + X2) * (X1 * X1))))).+step(add(rule(275, -(X1 + (X1 * (X2 * -X1))) = (X1 * ((X2 + -X1) * X1))))).+step(add(rule(276, (X1 + (X1 * (X2 * -X1))) = (X1 * ((X1 + -X2) * X1))))).+step(add(rule(277, ((X1 + (X1 * -X2)) * X3) = (X1 * (X3 + (X2 * -X3)))))).+step(add(rule(278, (X1 * (X2 + (X2 + X2))) = ((X1 + (X1 + X1)) * -X2)))).+step(add(rule(279, ((X1 + X1) * (X2 + (X2 + X2))) = 0))).+step(interreduce).+step(delete(rule(108, (X1 + ((X2 + (X1 * -X1)) * X1)) = (X2 * X1)))).+step(delete(rule(112, ((X1 + (X1 + (X1 + X1))) * X2) = (X1 * (X2 + (X2 + (X2 + X2))))))).+step(delete(rule(113, ((X1 * X3) + (X2 * (X1 * (X1 * X3)))) = ((X1 + X2) * (X1 * (X1 * X3)))))).+step(delete(rule(114, (X1 * ((X1 + X1) * ((X1 + X1) * (X2 + X2)))) = ((X1 + X1) * X2)))).+step(delete(rule(145, ((X1 + X1) * (X1 + (X1 + (X1 + X1)))) = (X1 * (X1 + X1))))).+step(delete(rule(154, ((X1 * (X2 + X2)) + X3) = (((X1 + X1) * X2) + X3)))).+step(delete(rule(166, ((X1 + X1) * (X2 * ((X2 + X2) * (X2 + X2)))) = (X1 * (X2 + X2))))).+step(add(rule(280, ((X1 + X1) * -(X2 + X2)) = (X1 * (X2 + X2))))).+step(delete(rule(187, ((X2 * X1) + -(X1 + (X2 * X1))) = -X1))).+step(delete(rule(205, ((X1 + X1) * (X2 + (X2 + X2))) = ((X1 + (X1 + X1)) * (X2 + X2))))).+step(add(rule(281, ((X1 + (X1 + X1)) * (X2 + X2)) = 0))).+step(delete(rule(209, (X1 * ((X1 + X1) * (X1 + X1))) = (X1 + (X1 + (X1 + X1)))))).+step(delete(rule(210, (X3 + (X4 + (X2 + (-(X3 + X4) + X1)))) = (X1 + X2)))).+step(delete(rule(212, (X1 * ((X1 * (X1 + X1)) + X2)) = (X1 + (X1 + (X1 * X2)))))).+step(delete(rule(231, ((X1 * (X2 * X3)) + ((X4 * X3) + X5)) = ((((X1 * X2) + X4) * X3) + X5)))).+step(delete(rule(242, (((X1 * X2) + X3) * (X2 * (X2 * X4))) = ((X1 + (X3 * X2)) * (X2 * X4))))).+step(delete(rule(247, ((X1 + (X1 * (X2 * -X2))) * -X2) = 0))).+step(delete(rule(250, ((X1 * X2) + ((X3 * (X4 * X2)) + X5)) = (((X1 + (X3 * X4)) * X2) + X5)))).+step(delete(rule(258, (X1 * ((X2 * (X1 * (X2 * (X1 * X2)))) + X3)) = (X1 * (X2 + X3))))).+step(delete(rule(260, (X2 + ((X1 + X2) * (X2 * -X2))) = (X1 * (X2 * -X2))))).+step(delete(rule(271, ((X1 + X1) * -(X1 + X1)) = (X1 * (X1 + X1))))).+step(delete(rule(275, -(X1 + (X1 * (X2 * -X1))) = (X1 * ((X2 + -X1) * X1))))).+step(add(rule(282, ((X1 + (X1 + X1)) * -(X2 + X2)) = 0))).+step(add(rule(283, ((X1 + X1) * (X2 + X2)) = (X1 * -(X2 + X2))))).+step(add(rule(284, ((X1 + (X1 + X1)) * ((X2 + X2) * X3)) = 0))).+step(add(rule(285, ((X1 + (X1 + X1)) * (X2 * (X3 + X3))) = 0))).+step(add(rule(286, ((X1 + X1) * ((X2 + (X2 + X2)) * X3)) = 0))).+step(add(rule(287, (((X1 + X1) * X2) + (((X1 + X1) * X2) + (((X1 + X1) * X2) + X3))) = X3))).+step(add(rule(288, (((X1 + (X1 + X1)) * X2) + (((X1 + (X1 + X1)) * X2) + X3)) = X3))).+step(add(rule(289, ((X1 + X1) * (X2 + (X2 * (X1 * (X1 + X1))))) = 0))).+step(add(rule(290, ((X1 + (X1 * (X2 * (X2 + X2)))) * (X2 + X2)) = 0))).+step(add(rule(291, ((X1 + X1) * (X2 * (X3 + (X3 + X3)))) = 0))).+step(add(rule(292, (X1 * (X2 + (X2 + X3))) = (X1 * ((X1 * ((X1 + X1) * X2)) + X3))))).+step(add(rule(293, ((X1 + (X1 + X1)) * (X1 * ((X1 + X1) * X2))) = 0))).+step(add(rule(294, ((X1 + (X1 + X1)) * (X1 * -(X1 + X1))) = 0))).+step(add(rule(295, (X1 * (-X2 + (-X2 + X3))) = (X1 * (-(X2 + X2) + X3))))).+step(add(rule(296, (X1 * (X1 * ((X1 + (X1 * X2)) * X3))) = ((X1 + (X1 * X2)) * X3)))).+step(add(rule(297, (((X1 * (X2 * (X3 * X3))) + X4) * X3) = (((X1 * X2) + X4) * X3)))).+step(add(rule(298, (((X1 * (X2 * (X2 + X2))) + X3) * X2) = ((X1 + (X1 + X3)) * X2)))).+step(add(rule(299, (X1 * (-(X2 + X2) + X3)) = (X1 * (X3 + -(X2 + X2)))))).+step(add(rule(300, ((X1 * -(X2 + X2)) + X3) = (X3 + ((X1 + X1) * -X2))))).+step(add(rule(301, (X1 + ((X2 + X2) * -X3)) = (X1 + (X2 * -(X3 + X3)))))).+step(add(rule(302, -(X3 + ((X1 + X1) * X2)) = -(X3 + (X1 * (X2 + X2)))))).+step(add(rule(303, (((X1 + X1) * -X2) + X3) = (X3 + (X1 * -(X2 + X2)))))).+step(add(rule(304, (((X1 * (X2 * X2)) + X3) * (X2 * X4)) = ((X1 + X3) * (X2 * X4))))).+step(add(rule(305, ((X1 + (X2 * (X3 * X3))) * (X3 * X4)) = ((X1 + X2) * (X3 * X4))))).+step(add(rule(306, (X1 * ((X1 * -X1) + X2)) = (-X1 + (X1 * X2))))).+step(add(rule(307, (X1 + (-X1 + (X1 * X2))) = (X1 * X2)))).+step(add(rule(308, (X1 * (X2 + (X1 * -X1))) = (-X1 + (X1 * X2))))).+step(add(rule(309, (X1 * (X2 * (X3 * (X4 + X4)))) = ((X1 + X1) * (X2 * (X3 * X4)))))).+step(add(rule(310, (X1 * (X2 * (X3 * (X4 + X4)))) = (X1 * ((X2 + X2) * (X3 * X4)))))).+step(add(rule(311, ((X1 + X1) * (X2 * (X3 + X3))) = (X1 * (X2 * -(X3 + X3)))))).+step(add(rule(312, ((X1 + X1) * ((X2 + X2) * X3)) = (X1 * (X2 * -(X3 + X3)))))).+step(add(rule(313, ((X1 * (X2 + X2)) + ((X3 + -X1) * X2)) = ((X1 + X3) * X2)))).+step(add(rule(314, ((X1 * (X2 + X2)) + ((-X1 + X3) * X2)) = ((X3 + X1) * X2)))).+step(add(rule(315, ((X1 + (X1 + X1)) * (X2 * X3)) = (X1 * ((X2 + (X2 + X2)) * X3))))).+step(add(rule(316, (X1 * (X2 * (X3 + (X3 + X3)))) = (X1 * ((X2 + (X2 + X2)) * X3))))).+step(add(rule(317, (((X1 + X1) * X2) + (X1 * (X3 + -X2))) = (X1 * (X2 + X3))))).+step(add(rule(318, (((X1 + X1) * X2) + (X1 * (-X2 + X3))) = (X1 * (X3 + X2))))).+step(add(rule(319, (X1 * (X2 + (X2 * (X1 * X1)))) = ((X1 + X1) * X2)))).+step(add(rule(320, (X1 + (X1 * (X2 + ((X1 * -X1) + X3)))) = (X1 * (X3 + X2))))).+step(hard(((X1 + (X1 + (X2 + X2))) * X3) = ((X1 + (X2 + (X1 + X2))) * X3))).+step(hard((X1 * (X2 + (X2 + (X3 + X3)))) = (X1 * (X2 + (X3 + (X2 + X3)))))).+step(add(rule(321, (X1 * (((X2 + X2) * X3) + X4)) = (X1 * (X4 + ((X2 + X2) * X3)))))).+step(add(rule(322, (X1 * (((X2 + X2) * X3) + X4)) = (X1 * (X4 + (X2 * (X3 + X3))))))).+step(add(rule(323, (X1 * ((X2 * (X3 + X3)) + X4)) = (X1 * (X4 + ((X2 + X2) * X3)))))).+step(add(rule(324, (X1 + (X1 * (X2 * (X3 + X3)))) = (X1 + (X1 * ((X2 + X2) * X3)))))).+step(hard((X1 * (X2 * (X3 + (X4 + X4)))) = (X1 * (X2 * (X4 + (X4 + X3)))))).+step(hard((X1 * ((X2 + (X4 + X4)) * X3)) = (X1 * ((X4 + (X4 + X2)) * X3)))).+step(add(rule(325, ((X1 * (X1 * (X2 + X1))) + X3) = (X1 + ((X1 * (X1 * X2)) + X3))))).+step(add(rule(326, (X1 + (X2 * (X2 * (X2 + X3)))) = (X2 + ((X2 * (X2 * X3)) + X1))))).+step(add(rule(327, (X1 + (X2 + (X1 * (X1 * X3)))) = (X2 + (X1 * (X1 * (X3 + X1))))))).+step(hard((X1 + (X1 * ((X1 + X1) * X2))) = (X1 * (X1 * (X2 + (X1 + X2)))))).+step(add(rule(328, ((X1 * ((X2 + X1) * X1)) + X3) = (X1 + ((X1 * (X2 * X1)) + X3))))).+step(add(rule(329, (X1 + (X2 * ((X2 + X3) * X2))) = (X2 + ((X2 * (X3 * X2)) + X1))))).+step(add(rule(330, (X1 + (X2 + (X1 * (X3 * X1)))) = (X2 + (X1 * ((X3 + X1) * X1)))))).+step(hard((X1 + (X1 * (X2 * (X1 + X1)))) = (X1 * ((X2 + (X1 + X2)) * X1)))).+step(add(rule(331, (((X1 * (X2 + X2)) + X3) * X4) = ((X3 + ((X1 + X1) * X2)) * X4)))).+step(add(rule(332, ((((X1 + X1) * X2) + X3) * X4) = ((X3 + (X1 * (X2 + X2))) * X4)))).+step(add(rule(333, ((X1 + (X1 * X2)) * (X2 * X3)) = (X1 * (X2 * (X3 + (X2 * X3))))))).+step(add(rule(334, ((X1 + X1) * (X2 + (X1 * ((X1 + X1) * X2)))) = 0))).+step(add(rule(335, (X1 * (X1 * ((X1 + X2) * X2))) = (X1 * ((X2 + X1) * (X2 * X2)))))).+step(add(rule(336, (X1 * (X2 + (X1 * (X3 * X2)))) = (X1 * (X1 * ((X3 + X1) * X2)))))).+step(add(rule(337, (X1 * ((X1 + X2) * (X1 * X2))) = (X1 * (X2 * ((X2 + X1) * X2)))))).+step(add(rule(338, (X1 * (X2 + (X3 * (X1 * X2)))) = (X1 * ((X3 + X1) * (X1 * X2)))))).+step(add(rule(339, (X1 * -(X2 + (X1 * (X1 * -X2)))) = 0))).+step(add(rule(340, ((X1 + (X1 * (X2 * X3))) * X3) = (X1 * ((X3 + X2) * (X3 * X3)))))).+step(add(rule(341, ((X1 + (X1 * (X2 * -X2))) * X2) = 0))).+step(add(rule(342, ((X1 + (X1 * (X2 * -X2))) * -X2) = 0))).+step(add(rule(343, ((X1 + (X1 * (X2 * X3))) * X2) = (X1 * (X2 * ((X2 + X3) * X2)))))).+step(add(rule(344, (X1 * -((X1 * X1) + X2)) = -(X1 + (X1 * X2))))).+step(add(rule(345, (((X1 * X1) + X2) * -X1) = -(X1 + (X2 * X1))))).+step(add(rule(346, ((X1 * X2) + ((X3 + X1) * X4)) = ((X1 * (X4 + X2)) + (X3 * X4))))).+step(hard((X1 * (X2 + (X3 + X2))) = (X1 * (X3 + (X2 + X2))))).+step(hard((X1 * (X2 + (X3 + X2))) = (X1 * (X2 + (X2 + X3))))).+step(add(rule(347, ((X1 * -X2) + ((X3 + X1) * X2)) = (X3 * X2)))).+step(add(rule(348, ((X1 * X2) + ((X3 + X1) * X4)) = ((X3 * X4) + (X1 * (X2 + X4)))))).+step(add(rule(349, (X1 * (X2 + -(X3 + X2))) = (X1 * -X3)))).+step(add(rule(350, ((X1 + -(X3 + X1)) * X2) = (X3 * -X2)))).+step(add(rule(351, (((X1 * X2) + (X4 + X1)) * X3) = ((X4 + (X1 + (X1 * X2))) * X3)))).+step(interreduce).+step(delete(rule(103, ((X1 + (X1 + X1)) * (X1 * X1)) = (X1 + (X1 + X1))))).+step(delete(rule(153, (((X1 + X1) * -X2) + X3) = ((X1 * -(X2 + X2)) + X3)))).+step(delete(rule(168, (X1 * (((X2 + X2) * X3) + X4)) = (X1 * ((X2 * (X3 + X3)) + X4))))).+step(delete(rule(171, (X1 + (X2 + (X1 * (X1 * X3)))) = (X2 + (X1 * (X1 * (X1 + X3))))))).+step(delete(rule(174, (X1 + (X2 + (X1 * (X3 * X1)))) = (X2 + (X1 * ((X1 + X3) * X1)))))).+step(delete(rule(180, (X1 * (X2 + (X1 * (X3 * X2)))) = (X1 * (X1 * ((X1 + X3) * X2)))))).+step(delete(rule(181, (X1 * (X2 + (X3 * (X1 * X2)))) = (X1 * ((X1 + X3) * (X1 * X2)))))).+step(delete(rule(189, ((X1 * X2) + (X3 * (X2 + X4))) = ((X3 * X4) + ((X1 + X3) * X2))))).+step(delete(rule(216, ((X1 + X1) * (X2 + X2)) = (X1 * ((X1 + X1) * ((X1 + X1) * X2)))))).+step(add(rule(352, (X1 * -(X2 + X2)) = (X1 * ((X1 + X1) * ((X1 + X1) * X2)))))).+step(delete(rule(217, ((X1 + X1) * ((X1 + X1) * (X2 + X2))) = (X1 * ((X1 + X1) * X2))))).+step(delete(rule(262, (X1 * (X2 + (X3 * X2))) = (X1 * (X1 * ((X1 + (X1 * X3)) * X2)))))).+step(delete(rule(270, ((X1 + X1) * (X1 + X1)) = (X1 * -(X1 + X1))))).+step(delete(rule(288, (((X1 + (X1 + X1)) * X2) + (((X1 + (X1 + X1)) * X2) + X3)) = X3))).+step(delete(rule(293, ((X1 + (X1 + X1)) * (X1 * ((X1 + X1) * X2))) = 0))).+step(delete(rule(294, ((X1 + (X1 + X1)) * (X1 * -(X1 + X1))) = 0))).+step(delete(rule(304, (((X1 * (X2 * X2)) + X3) * (X2 * X4)) = ((X1 + X3) * (X2 * X4))))).+step(delete(rule(306, (X1 * ((X1 * -X1) + X2)) = (-X1 + (X1 * X2))))).+step(delete(rule(341, ((X1 + (X1 * (X2 * -X2))) * X2) = 0))).+step(add(rule(353, (X1 * ((X1 + X1) * ((X1 + X1) * X2))) = ((X1 + X1) * -X2)))).+step(add(rule(354, (X1 + (X1 + (X1 * (X2 + X2)))) = ((X1 + X1) * (X2 + (X1 * X1)))))).+step(add(rule(355, (X1 + (X1 * ((X1 * X3) + X2))) = (X1 * (X2 + (X1 * (X3 + X1))))))).+step(add(rule(356, (X1 * (X2 + (X1 * (X2 + X1)))) = (X1 + ((X1 + (X1 * X1)) * X2))))).+step(add(rule(357, (X1 + (X1 * ((X3 * X1) + X2))) = (X1 * (X2 + ((X3 + X1) * X1)))))).+step(add(rule(358, (((X1 * -X1) + X2) * -X1) = (X1 + (X2 * -X1))))).+step(add(rule(359, ((X1 + (X2 * -X2)) * X2) = (-X2 + (X1 * X2))))).+step(hard((X1 + ((X2 * (X1 * X1)) + X3)) = (X3 + ((X2 + X1) * (X1 * X1))))).+step(add(rule(360, (X1 + ((X2 + X3) * (X2 * X2))) = (X2 + (X1 + (X3 * (X2 * X2))))))).+step(hard((X1 + ((X2 + X3) * (X3 * X3))) = (X1 + ((X3 + X2) * (X3 * X3))))).+step(add(rule(361, (X2 + (((X3 * X2) + X1) * X2)) = ((X1 + ((X2 + X3) * X2)) * X2)))).+step(add(rule(362, ((X1 + ((X2 + X1) * X2)) * X2) = (X2 + (X1 * (X2 + (X2 * X2))))))).+step(add(rule(363, ((X1 + ((X1 * X1) + X2)) * (X1 * X1)) = ((X1 + ((X1 + X2) * X1)) * X1)))).+step(add(rule(364, ((X2 + (X1 + (X1 * X1))) * (X1 * X1)) = ((X1 + ((X1 + X2) * X1)) * X1)))).+step(add(rule(365, ((X1 + (X1 * X3)) * (X2 + X2)) = ((X1 + X1) * (X2 + (X3 * X2)))))).+step(add(rule(366, (X2 + (((X2 * X3) + X1) * X2)) = ((X1 + (X2 * (X2 + X3))) * X2)))).+step(add(rule(367, ((X1 + (X1 + (X1 + X2))) * (X3 + X3)) = (X2 * (X3 + X3))))).+step(add(rule(368, ((X1 + ((X2 * X2) + X3)) * (X2 * X2)) = ((X2 + ((X1 + X3) * X2)) * X2)))).+step(add(rule(369, (X1 * ((X2 * (X3 + X3)) + X4)) = (X1 * (((X2 + X2) * X3) + X4))))).+step(hard((X1 + X2) = (X3 + (X4 + (X1 + (X2 + -(X4 + X3))))))).+step(add(rule(370, ((X3 + ((X1 * X1) + X2)) * X1) = (X1 + ((X2 + X3) * X1))))).+step(add(rule(371, (((X1 * (X1 + X1)) + X2) * X1) = (X1 + (X1 + (X2 * X1)))))).+step(add(rule(372, (X1 * (X2 + (X3 + (X3 * (X1 * -X1))))) = (X1 * X2)))).+step(add(rule(373, ((X1 + X1) * ((X2 + X2) * -X3)) = (X1 * ((X2 + X2) * X3))))).+step(add(rule(374, ((X1 + X1) * (-(X2 + X2) + X3)) = ((X1 + X1) * (X2 + X3))))).+step(add(rule(375, ((X1 + X1) * (X2 + -(X3 + X3))) = ((X1 + X1) * (X2 + X3))))).+step(add(rule(376, ((X1 + X1) * (X2 * -(X3 + X3))) = (X1 * (X2 * (X3 + X3)))))).+step(add(rule(377, ((X1 + (X1 * (X2 * (X2 + X2)))) * ((X2 + X2) * X3)) = 0))).+step(add(rule(378, ((X1 + (X1 + X1)) * (X2 + (X3 + (X2 + X3)))) = 0))).+step(add(rule(379, ((X1 + (X1 + X1)) * (X2 + (X2 + (X3 + X3)))) = 0))).+step(add(rule(380, (X1 * (-X2 + (X1 * ((X1 + X1) * X2)))) = (X1 * X2)))).+step(add(rule(381, ((X1 + (X1 + X1)) * -X2) = ((X1 + (X1 + X1)) * X2)))).+step(add(rule(382, ((-X1 + (X1 * (X2 * (X2 + X2)))) * X2) = (X1 * X2)))).+step(add(rule(383, (X1 * ((X1 * (X1 + X1)) + X2)) = (X1 + (X1 + (X1 * X2)))))).+step(hard((((X1 * X1) + (X2 + X1)) * X1) = (X1 + ((X2 + X1) * X1)))).+step(hard(((X1 + (-X1 + (X3 + X1))) * X2) = ((X3 + X1) * X2))).+step(add(rule(384, (X2 + (-(X2 + (X3 * X2)) + ((X1 + (X3 + (X1 * X3))) * X2))) = (X1 * (X2 + (X3 * X2)))))).+step(add(rule(385, (X2 + (X2 + (X2 + (X2 + (X2 + (X2 + ((X1 + (X1 + X1)) * X2))))))) = (X1 * (X2 + (X2 + X2)))))).+step(add(rule(386, ((X2 * -X3) + ((X2 + (X2 + (X1 * X2))) * X3)) = ((X2 + (X1 * X2)) * X3)))).+step(add(rule(387, (((X1 + X1) * X2) + X3) = (? + (? + (X3 + (-(? + ?) + (X1 * (X2 + X2))))))))).+step(add(rule(388, (X4 + (X5 + (X3 + (-(X4 + X5) + (X1 * (X2 + X2)))))) = (? + (? + (X3 + (-(? + ?) + (X1 * (X2 + X2))))))))).+step(add(rule(389, (((X1 + X1) * X2) + X3) = ((X1 * (X2 + X2)) + X3)))).+step(add(rule(390, ((X1 * (X2 + X2)) + X3) = (? + (? + (X3 + (-(? + ?) + ((X1 + X1) * X2)))))))).+step(add(rule(391, (X4 + (X5 + (X3 + (-(X4 + X5) + ((X1 + X1) * X2))))) = (? + (? + (X3 + (-(? + ?) + ((X1 + X1) * X2)))))))).+step(add(rule(392, (X1 * (X2 * (X3 + (X3 * (X1 * -X1))))) = 0))).+step(add(rule(393, (X1 * (X2 * (X3 + (X1 * (X1 * -X3))))) = 0))).+step(add(rule(394, ((X1 + (X1 + X1)) * (X2 * -(X3 + X3))) = 0))).+step(add(rule(395, ((X1 + (X1 * (X2 * (X2 + X2)))) * -(X2 + X2)) = 0))).+step(add(rule(396, ((X3 * -X2) + ((X3 + X1) * X2)) = (X1 * X2)))).+step(add(rule(397, ((X1 + X1) * ((X1 + X1) * X2)) = (X1 * ((X1 + X1) * -X2))))).+step(add(rule(398, ((X1 + X1) * (X2 + (X2 * (X1 * -X1)))) = 0))).+step(add(rule(399, (X1 * (X2 * (X3 + (X1 * (X2 * (X1 * X2)))))) = (X1 * (X2 + (X2 * X3)))))).+step(add(rule(400, (X1 + (X2 + (X3 * ((X1 + X2) * (X1 + X2))))) = ((X1 + (X2 + X3)) * ((X1 + X2) * (X1 + X2)))))).+step(add(rule(401, ((X1 + (X2 + (X1 + X2))) * ((X1 + X2) * (X1 + X2))) = (X1 + (X2 + (X1 + X2)))))).+step(add(rule(402, ((X1 * X2) + (X3 * (X1 * (X2 * (X1 * X2))))) = (((X1 * X2) + X3) * (X1 * (X2 * (X1 * X2))))))).+step(add(rule(403, (X1 * ((X1 + (X2 * X1)) * (X2 * (X1 * X2)))) = (X1 * (X2 + (X1 * (X2 * (X1 * X2)))))))).+step(add(rule(404, ((X1 + (X1 * (X2 * -X2))) * (X3 * X2)) = 0))).+step(add(rule(405, (X1 * (X3 * (X3 * (X2 * X3)))) = (X1 * (X2 * X3))))).+step(add(rule(406, ((X3 * X4) + (X1 * (X2 * (X3 * (X3 * X4))))) = (((X1 * X2) + X3) * (X3 * (X3 * X4)))))).+step(add(rule(407, ((X2 + -X1) * (X3 + X3)) = ((X2 + (-(X1 + X1) + X2)) * X3)))).+step(add(rule(408, ((X1 + X1) * (X3 + -X2)) = (X1 * (X3 + (-(X2 + X2) + X3)))))).+step(add(rule(409, ((X1 + (((X2 * -X2) + X1) * (X2 * -X2))) * (X2 * -X2)) = (X2 * -X2)))).+step(add(rule(410, (X1 * (X2 + (X1 * ((X1 + X1) * -X2)))) = (X1 * -X2)))).+step(add(rule(411, ((X1 + (X1 + X2)) * -(X3 + X3)) = ((X1 + -X2) * (X3 + X3))))).+step(add(rule(412, ((X1 + X1) * ((X2 + X2) * X3)) = (X1 * ((X2 + X2) * -X3))))).+step(add(rule(413, ((X1 + X1) * (X2 + (X2 + X3))) = ((X1 + X1) * (X3 + -X2))))).+step(add(rule(414, ((X1 + X1) * (X2 + (X1 * ((X1 + X1) * X3)))) = ((X1 + X1) * (X2 + -X3))))).+step(add(rule(415, ((X2 + (X2 * (X3 * -X3))) * X3) = 0))).+step(add(rule(416, ((X2 + (X2 + X1)) * (X3 + X3)) = ((X1 + -X2) * (X3 + X3))))).+step(add(rule(417, ((X1 + X1) * (X2 + (X3 + X3))) = ((X1 + X1) * (X2 + -X3))))).+step(add(rule(418, ((X1 + (X2 * -(X2 + X2))) * X2) = ((X1 * X2) + -(X2 + X2))))).+step(add(rule(419, ((X1 + (X2 * (X2 * -X1))) * -X2) = 0))).+step(add(rule(420, (X1 * (X1 * (X2 * X1))) = (X2 * X1)))).+step(add(rule(421, (X2 * (X2 * (X1 * -X2))) = (X1 * -X2)))).+step(add(rule(422, ((X1 + (X2 * (X2 * -X1))) * X2) = 0))).+step(add(rule(423, ((X1 + X2) * ((X3 + X3) * X4)) = ((X1 + (X2 + (X1 + X2))) * (X3 * X4))))).+step(add(rule(424, ((X1 + (X2 + (X1 + X2))) * (X3 + (X3 + X3))) = 0))).+step(add(rule(425, ((X1 + X2) * ((X3 + X3) * X4)) = ((X1 + (X1 + (X2 + X2))) * (X3 * X4))))).+step(hard(((X1 + X2) * ((X3 + X3) * X4)) = ((X2 + X1) * (X3 * (X4 + X4))))).+step(add(rule(426, ((X1 + -(X2 + X2)) * (X3 + X3)) = ((X1 + X2) * (X3 + X3))))).+step(add(rule(427, (X1 * ((X2 + X2) * (X3 + (X2 * X2)))) = ((X1 + X1) * (X2 + (X2 * X3)))))).+step(add(rule(428, ((X1 + X1) * ((X2 + X3) * X4)) = (X1 * ((X2 + (X3 + (X2 + X3))) * X4))))).+step(add(rule(429, (X1 * (((X2 + X2) * X3) + X4)) = (((X1 + X1) * (X2 * X3)) + (X1 * X4))))).+step(add(rule(430, (X1 + ((X1 + X1) * (X2 * X3))) = (X1 + (X1 * ((X2 + X2) * X3)))))).+step(add(rule(431, (X1 * (X2 + ((X3 + X3) * X4))) = ((X1 * X2) + ((X1 + X1) * (X3 * X4)))))).+step(add(rule(432, (X1 * (X2 + (X1 * -(X1 + X1)))) = ((X1 * X2) + -(X1 + X1))))).+step(add(rule(433, ((X1 + X1) * ((X2 + X3) * X4)) = (X1 * ((X2 + (X2 + (X3 + X3))) * X4))))).+step(hard(((X1 + X1) * ((X2 + X3) * X4)) = (X1 * ((X3 + X2) * (X4 + X4))))).+step(add(rule(434, (X1 * ((X2 + X2) * (X3 + X4))) = (X1 * (X2 * (X3 + (X4 + (X3 + X4)))))))).+step(add(rule(435, (X1 * ((X2 + X2) * (X3 + X4))) = (X1 * (X2 * (X3 + (X3 + (X4 + X4)))))))).+step(hard((X1 * ((X2 + X2) * (X3 + X4))) = (X1 * ((X2 + X2) * (X4 + X3))))).+step(add(rule(436, (X1 * ((X2 + X3) * (X4 + X4))) = (X1 * ((X2 + (X3 + (X2 + X3))) * X4))))).+step(add(rule(437, (X1 * ((X2 + X3) * (X4 + X4))) = (X1 * ((X2 + (X2 + (X3 + X3))) * X4))))).+step(interreduce).+step(delete(rule(194, (X1 + (X1 + (X1 * (X2 + X2)))) = ((X1 + X1) * ((X1 * X1) + X2))))).+step(delete(rule(207, ((X1 + (X2 + (X1 * X1))) * (X1 * X1)) = ((X1 + ((X1 + X2) * X1)) * X1)))).+step(delete(rule(240, ((X1 + X1) * ((X2 + (X1 * X1)) * X3)) = ((X1 + X1) * (X3 + (X2 * X3)))))).+step(delete(rule(241, ((X2 + ((X1 * X1) + X2)) * X1) = (X1 + (X2 * (X1 + X1)))))).+step(delete(rule(245, ((X1 + (X1 * (X2 * -X2))) * (X2 + X2)) = 0))).+step(delete(rule(278, (X1 * (X2 + (X2 + X2))) = ((X1 + (X1 + X1)) * -X2)))).+step(delete(rule(279, ((X1 + X1) * (X2 + (X2 + X2))) = 0))).+step(delete(rule(281, ((X1 + (X1 + X1)) * (X2 + X2)) = 0))).+step(delete(rule(282, ((X1 + (X1 + X1)) * -(X2 + X2)) = 0))).+step(delete(rule(290, ((X1 + (X1 * (X2 * (X2 + X2)))) * (X2 + X2)) = 0))).+step(delete(rule(312, ((X1 + X1) * ((X2 + X2) * X3)) = (X1 * (X2 * -(X3 + X3)))))).+step(delete(rule(334, ((X1 + X1) * (X2 + (X1 * ((X1 + X1) * X2)))) = 0))).+step(delete(rule(352, (X1 * -(X2 + X2)) = (X1 * ((X1 + X1) * ((X1 + X1) * X2)))))).+step(delete(rule(353, (X1 * ((X1 + X1) * ((X1 + X1) * X2))) = ((X1 + X1) * -X2)))).+step(delete(rule(363, ((X1 + ((X1 * X1) + X2)) * (X1 * X1)) = ((X1 + ((X1 + X2) * X1)) * X1)))).+step(delete(rule(367, ((X1 + (X1 + (X1 + X2))) * (X3 + X3)) = (X2 * (X3 + X3))))).+step(delete(rule(373, ((X1 + X1) * ((X2 + X2) * -X3)) = (X1 * ((X2 + X2) * X3))))).+step(delete(rule(374, ((X1 + X1) * (-(X2 + X2) + X3)) = ((X1 + X1) * (X2 + X3))))).+step(delete(rule(378, ((X1 + (X1 + X1)) * (X2 + (X3 + (X2 + X3)))) = 0))).+step(delete(rule(386, ((X2 * -X3) + ((X2 + (X2 + (X1 * X2))) * X3)) = ((X2 + (X1 * X2)) * X3)))).+step(delete(rule(397, ((X1 + X1) * ((X1 + X1) * X2)) = (X1 * ((X1 + X1) * -X2))))).+step(delete(rule(401, ((X1 + (X2 + (X1 + X2))) * ((X1 + X2) * (X1 + X2))) = (X1 + (X2 + (X1 + X2)))))).+step(add(rule(438, ((X1 + X2) * ((X1 + X2) * (X1 + (X1 + (X2 + X2))))) = (X1 + (X2 + (X1 + X2)))))).+step(delete(rule(404, ((X1 + (X1 * (X2 * -X2))) * (X3 * X2)) = 0))).+step(delete(rule(405, (X1 * (X3 * (X3 * (X2 * X3)))) = (X1 * (X2 * X3))))).+step(delete(rule(413, ((X1 + X1) * (X2 + (X2 + X3))) = ((X1 + X1) * (X3 + -X2))))).+step(delete(rule(423, ((X1 + X2) * ((X3 + X3) * X4)) = ((X1 + (X2 + (X1 + X2))) * (X3 * X4))))).+step(delete(rule(428, ((X1 + X1) * ((X2 + X3) * X4)) = (X1 * ((X2 + (X3 + (X2 + X3))) * X4))))).+step(delete(rule(434, (X1 * ((X2 + X2) * (X3 + X4))) = (X1 * (X2 * (X3 + (X4 + (X3 + X4)))))))).+step(delete(rule(436, (X1 * ((X2 + X3) * (X4 + X4))) = (X1 * ((X2 + (X3 + (X2 + X3))) * X4))))).+step(hard((X1 * ((X2 + X3) * (X4 + X4))) = (X1 * ((X3 + X2) * (X4 + X4))))).+step(add(rule(439, ((X1 * X2) + (X3 * -(X2 + X2))) = ((X1 + -(X3 + X3)) * X2)))).+step(add(rule(440, ((X1 + (X2 + X2)) * X3) = ((X1 * X3) + (X2 * (X3 + X3)))))).+step(hard((((X1 + X1) * X2) + (X1 * -(X2 + X2))) = 0)).+step(add(rule(441, ((X1 + X2) * (X3 + (X4 * X3))) = ((X1 + (X2 + ((X1 + X2) * X4))) * X3)))).+step(add(rule(442, ((X1 + ((X1 * X2) + X3)) * X4) = ((X1 * (X4 + (X2 * X4))) + (X3 * X4))))).+step(add(rule(443, ((X1 + (X2 + (X2 * X3))) * X4) = ((X1 * X4) + (X2 * (X4 + (X3 * X4))))))).+step(add(rule(444, ((X1 + X1) * (X2 + (X3 * X2))) = ((X1 + (X1 + (X1 * (X3 + X3)))) * X2)))).+step(add(rule(445, (X1 * (X2 + ((X3 + (X1 * X1)) * X2))) = ((X1 + (X1 + (X1 * X3))) * X2)))).+step(add(rule(446, ((X1 + (X1 * X2)) * (X3 + X4)) = (X1 * (X3 + (X4 + (X2 * (X3 + X4)))))))).+step(add(rule(447, (X1 * (X2 + ((X3 * X2) + X4))) = (((X1 + (X1 * X3)) * X2) + (X1 * X4))))).+step(add(rule(448, (X1 * (-X2 + (X3 * X2))) = ((-X1 + (X1 * X3)) * X2)))).+step(add(rule(449, (X1 + (X1 * (X2 + (X3 * X2)))) = (X1 + ((X1 + (X1 * X3)) * X2))))).+step(add(rule(450, (X1 * ((X2 * X3) + ((X2 * -X3) + X4))) = (X1 * X4)))).+step(add(rule(451, (X1 * (X2 * (X3 * (X1 * X1)))) = (X1 * (X2 * X3))))).+step(add(rule(452, (X1 * (X2 * (X1 * X1))) = (X1 * X2)))).+step(add(rule(453, (X1 * (X2 * (X1 * -X1))) = (X1 * -X2)))).+step(add(rule(454, (X1 * (X2 + (X3 * (X1 * X1)))) = (X1 * (X2 + X3))))).+step(add(rule(455, (X1 * (X2 * (X1 * (X1 + X1)))) = ((X1 + X1) * X2)))).+step(add(rule(456, (X1 * ((X1 + (X2 * X1)) * X1)) = (X1 + (X1 * X2))))).+step(add(rule(457, (X1 * (X2 * (X1 * X2))) = (X1 * (X2 * (X2 * X1)))))).+step(add(rule(458, ((X1 + (X2 * X1)) * X1) = (X1 * (X1 + (X1 * X2)))))).+step(add(rule(459, (X1 * (X2 + (X3 + (X4 * X3)))) = ((X1 * X2) + ((X1 + (X1 * X4)) * X3))))).+step(add(rule(460, (X1 * (X2 + (X3 + X3))) = ((X1 * X2) + ((X1 + X1) * X3))))).+step(add(rule(461, (X1 * ((X1 * X1) + (X2 + X2))) = (X1 + ((X1 + X1) * X2))))).+step(add(rule(462, ((X1 + (X2 + X1)) * (X3 + X3)) = ((X2 + -X1) * (X3 + X3))))).+step(add(rule(463, ((X2 + (X1 + X1)) * (X3 + X3)) = ((X2 + -X1) * (X3 + X3))))).+step(add(rule(464, ((X1 + X1) * (X3 + (X2 * X3))) = (X1 * (X3 + (X3 + ((X2 + X2) * X3))))))).+step(add(rule(465, (X1 * -(X2 + (X1 * (X1 * X3)))) = (X1 * -(X2 + X3))))).+step(add(rule(466, ((X3 * X5) + (X1 + (X2 + (X3 * X4)))) = (X1 + (X2 + (X3 * (X4 + X5))))))).+step(add(rule(467, (X1 + (X2 * (X3 + (X4 + X4)))) = (((X2 + X2) * X4) + (X1 + (X2 * X3)))))).+step(add(rule(468, (X1 + (X2 * (X3 + (X3 + X3)))) = (X1 + ((X2 + (X2 + X2)) * X3))))).+step(add(rule(469, (X1 + (X2 * (X3 + (X3 + X4)))) = ((X2 * X4) + (X1 + ((X2 + X2) * X3)))))).+step(add(rule(470, (X1 + (X2 + (X2 * (X3 + X3)))) = (X2 + (X1 + ((X2 + X2) * X3)))))).+step(hard((X1 * (X2 + (X3 + (X3 + X4)))) = (X1 * (X4 + (X3 + (X3 + X2)))))).+step(add(rule(471, ((X2 * X3) + ((X1 + X2) * (X1 * X1))) = (X1 + (X2 * ((X1 * X1) + X3)))))).+step(add(rule(472, ((X4 * X5) + (X1 + (X2 + (X3 * X5)))) = (X1 + (X2 + ((X3 + X4) * X5)))))).+step(add(rule(473, (X1 + ((X2 + (X3 + X3)) * X4)) = ((X3 * (X4 + X4)) + (X1 + (X2 * X4)))))).+step(add(rule(474, ((X1 + X1) * (X2 + (X3 + X2))) = ((X1 + X1) * (X3 + -X2))))).+step(add(rule(475, (X1 + ((X2 + (X2 + X3)) * X4)) = ((X3 * X4) + (X1 + (X2 * (X4 + X4))))))).+step(hard(((X1 + (X3 + (X3 + X4))) * X2) = ((X4 + (X3 + (X3 + X1))) * X2))).+step(add(rule(476, ((X1 + (X1 + X2)) * (X3 * X4)) = (((X1 * (X3 + X3)) + (X2 * X3)) * X4)))).+step(add(rule(477, (X1 * ((X2 * (X3 + X3)) + (X4 * X3))) = (X1 * ((X2 + (X2 + X4)) * X3))))).+step(add(rule(478, ((X1 * (X2 + X2)) + ((X3 + X4) * X2)) = ((X1 + (X3 + (X1 + X4))) * X2)))).+step(hard(((X1 + (X2 + (X1 + X3))) * X4) = ((X1 + (X1 + (X2 + X3))) * X4))).+step(add(rule(479, ((X1 * (X2 + X2)) + ((X3 * X2) + X4)) = (((X1 + (X1 + X3)) * X2) + X4)))).+step(hard(((X1 + (X1 + (X2 + X4))) * X3) = ((X2 + (X4 + (X1 + X1))) * X3))).+step(add(rule(480, (((X1 * X2) + ((X1 * X2) + X3)) * X4) = ((X1 * (X2 * (X4 + X4))) + (X3 * X4))))).+step(add(rule(481, (((X1 * X2) + ((X1 * X2) + X3)) * X4) = (((X1 * (X2 + X2)) + X3) * X4)))).+step(add(rule(482, ((X1 * (X2 + X2)) + (X3 + (X4 * X2))) = (X3 + ((X1 + (X1 + X4)) * X2))))).+step(hard((X1 + ((X2 + (X2 + X3)) * X4)) = (X1 + ((X3 + (X2 + X2)) * X4)))).+step(hard(((X1 + (X3 + (X3 + X4))) * X2) = ((X3 + (X3 + (X1 + X4))) * X2))).+step(add(rule(483, ((X1 * (X2 + X2)) + ((X3 + X4) * X2)) = ((X4 + (X1 + (X1 + X3))) * X2)))).+step(add(rule(484, ((-? + (X2 + (X2 + ?))) * X3) = (X2 * (X3 + X3))))).+step(add(rule(485, ((-X1 + (X2 + (X2 + X1))) * X3) = ((-? + (X2 + (X2 + ?))) * X3)))).+step(hard(((X1 + (X2 + (X2 + X3))) * X4) = ((X2 + (X2 + (X3 + X1))) * X4))).+step(hard(((X1 + (X2 + (X2 + X3))) * X4) = ((X2 + (X3 + (X2 + X1))) * X4))).+step(add(rule(486, (X1 * (((X2 + X2) * X3) + (X2 * X4))) = (X1 * (X2 * (X3 + (X3 + X4))))))).+step(add(rule(487, (X1 * ((X2 + (X2 + X3)) * X4)) = ((((X1 + X1) * X2) + (X1 * X3)) * X4)))).+step(add(rule(488, ((X1 + (X1 + X1)) * (X2 * X3)) = (X1 * (X2 * (X3 + (X3 + X3))))))).+step(add(rule(489, (((X1 + X1) * X2) + (X1 * (X3 + X4))) = (X1 * (X2 + (X3 + (X2 + X4))))))).+step(hard((X1 * (X2 + (X3 + (X2 + X4)))) = (X1 * (X2 + (X2 + (X3 + X4)))))).+step(add(rule(490, (((X1 + X1) * X2) + ((X1 * X3) + X4)) = ((X1 * (X2 + (X2 + X3))) + X4)))).+step(hard((X1 * (X2 + (X2 + (X3 + X4)))) = (X1 * (X3 + (X4 + (X2 + X2)))))).+step(add(rule(491, ((X1 * (X2 + X2)) + ((X1 * -(X2 + X2)) + X3)) = X3))).+step(add(rule(492, (((X1 + X1) * X2) + (X3 + (X1 * X4))) = (X3 + (X1 * (X2 + (X2 + X4))))))).+step(hard((X1 + (X2 * (X3 + (X3 + X4)))) = (X1 + (X2 * (X4 + (X3 + X3)))))).+step(hard((X1 * (X2 + (X3 + (X3 + X4)))) = (X1 * (X3 + (X3 + (X2 + X4)))))).+step(add(rule(493, (X1 * (X2 + (X2 + ((X3 + X3) * X4)))) = ((X1 + X1) * (X2 + (X3 * X4)))))).+step(add(rule(494, (X1 * (X2 + X2)) = ((X1 + X1) * (X2 + (? + (? + ?))))))).+step(add(rule(495, ((X1 + X1) * (X2 + (X3 + (X3 + X3)))) = ((X1 + X1) * (X2 + (? + (? + ?))))))).+step(add(rule(496, ((X1 + X1) * (X2 + -X3)) = (X1 * (X2 + (X2 + -(X3 + X3))))))).+step(add(rule(497, (X1 * (X1 * (X2 + (X2 + (X1 * X3))))) = (X1 * (((X1 + X1) * X2) + X3))))).+step(add(rule(498, (((X1 + X1) * X2) + (X1 * (X3 + X4))) = (X1 * (X4 + (X2 + (X2 + X3))))))).+step(add(rule(499, (X1 * (-? + (X3 + (X3 + ?)))) = ((X1 + X1) * X3)))).+step(add(rule(500, (X1 * (-X2 + (X3 + (X3 + X2)))) = (X1 * (-? + (X3 + (X3 + ?))))))).+step(hard((X1 * (X2 + (X3 + (X3 + X4)))) = (X1 * (X3 + (X3 + (X4 + X2)))))).+step(hard((X1 * (X2 + (X3 + (X3 + X4)))) = (X1 * (X3 + (X4 + (X3 + X2)))))).+step(add(rule(501, (X1 * (X3 + (X4 + ((X1 * X1) + X2)))) = (X1 + (X1 * (X2 + (X3 + X4))))))).+step(add(rule(502, (X1 * ((X2 + ((X1 * X1) + X3)) * X4)) = ((X1 + (X1 * (X3 + X2))) * X4)))).+step(add(rule(503, (X1 * (X2 + (X3 + (X4 + (X1 * X1))))) = (X1 + (X1 * (X2 + (X3 + X4))))))).+step(add(rule(504, (X1 * ((X2 + (X3 + (X1 * X1))) * X4)) = ((X1 + (X1 * (X2 + X3))) * X4)))).+step(hard(((X1 + (X1 * (X2 + X3))) * X4) = ((X1 + (X1 * (X3 + X2))) * X4))).+step(add(rule(505, ((X1 + (X1 * X2)) * ((X2 + (X1 * X1)) * (X2 + (X1 * X1)))) = (X1 + (X1 * X2))))).+step(interreduce).+step(delete(rule(162, (((? * X2) + ((? * X2) + ((? + X3) * -(X2 + X2)))) * X4) = (X3 * (X2 * -(X4 + X4)))))).+step(delete(rule(163, (((X1 * X2) + ((X1 * X2) + ((X3 + X1) * -(X2 + X2)))) * X4) = (((? * X2) + ((? * X2) + ((? + X3) * -(X2 + X2)))) * X4)))).+step(delete(rule(249, (X1 * (-X2 + (X2 * (X1 * X1)))) = 0))).+step(delete(rule(287, (((X1 + X1) * X2) + (((X1 + X1) * X2) + (((X1 + X1) * X2) + X3))) = X3))).+step(delete(rule(319, (X1 * (X2 + (X2 * (X1 * X1)))) = ((X1 + X1) * X2)))).+step(delete(rule(339, (X1 * -(X2 + (X1 * (X1 * -X2)))) = 0))).+step(delete(rule(364, ((X2 + (X1 + (X1 * X1))) * (X1 * X1)) = ((X1 + ((X1 + X2) * X1)) * X1)))).+step(add(rule(506, ((X2 + (X1 + (X1 * X1))) * (X1 * X1)) = (X1 * (X1 + (X1 * (X1 + X2))))))).+step(delete(rule(368, ((X1 + ((X2 * X2) + X3)) * (X2 * X2)) = ((X2 + ((X1 + X3) * X2)) * X2)))).+step(add(rule(507, ((X1 + ((X2 * X2) + X3)) * (X2 * X2)) = (X2 * (X2 + (X2 * (X1 + X3))))))).+step(delete(rule(408, ((X1 + X1) * (X3 + -X2)) = (X1 * (X3 + (-(X2 + X2) + X3)))))).+step(delete(rule(416, ((X2 + (X2 + X1)) * (X3 + X3)) = ((X1 + -X2) * (X3 + X3))))).+step(delete(rule(456, (X1 * ((X1 + (X2 * X1)) * X1)) = (X1 + (X1 * X2))))).+step(delete(rule(464, ((X1 + X1) * (X3 + (X2 * X3))) = (X1 * (X3 + (X3 + ((X2 + X2) * X3))))))).+step(delete(rule(467, (X1 + (X2 * (X3 + (X4 + X4)))) = (((X2 + X2) * X4) + (X1 + (X2 * X3)))))).+step(delete(rule(473, (X1 + ((X2 + (X3 + X3)) * X4)) = ((X3 * (X4 + X4)) + (X1 + (X2 * X4)))))).+step(delete(rule(480, (((X1 * X2) + ((X1 * X2) + X3)) * X4) = ((X1 * (X2 * (X4 + X4))) + (X3 * X4))))).+step(delete(rule(484, ((-? + (X2 + (X2 + ?))) * X3) = (X2 * (X3 + X3))))).+step(add(rule(508, ((? + (-? + (X2 + X2))) * X3) = (X2 * (X3 + X3))))).+step(delete(rule(485, ((-X1 + (X2 + (X2 + X1))) * X3) = ((-? + (X2 + (X2 + ?))) * X3)))).+step(add(rule(509, ((-X1 + (X2 + (X2 + X1))) * X3) = ((? + (-? + (X2 + X2))) * X3)))).+step(delete(rule(494, (X1 * (X2 + X2)) = ((X1 + X1) * (X2 + (? + (? + ?))))))).+step(add(rule(510, (X1 * (X2 + X2)) = ((X1 + X1) * (? + (? + (? + X2))))))).+step(delete(rule(495, ((X1 + X1) * (X2 + (X3 + (X3 + X3)))) = ((X1 + X1) * (X2 + (? + (? + ?))))))).+step(add(rule(511, ((X1 + X1) * (X2 + (X3 + (X3 + X3)))) = ((X1 + X1) * (? + (? + (? + X2))))))).+step(delete(rule(499, (X1 * (-? + (X3 + (X3 + ?)))) = ((X1 + X1) * X3)))).+step(add(rule(512, (X1 * (? + (-? + (X3 + X3)))) = ((X1 + X1) * X3)))).+step(delete(rule(500, (X1 * (-X2 + (X3 + (X3 + X2)))) = (X1 * (-? + (X3 + (X3 + ?))))))).+step(add(rule(513, (X1 * (-X2 + (X3 + (X3 + X2)))) = (X1 * (? + (-? + (X3 + X3))))))).+step(delete(rule(501, (X1 * (X3 + (X4 + ((X1 * X1) + X2)))) = (X1 + (X1 * (X2 + (X3 + X4))))))).+step(add(rule(514, ((X1 + (X3 * -X1)) * X1) = (X1 * (X1 + (X1 * -X3)))))).+step(add(rule(515, (X1 * (X1 * -X2)) = (X2 * (X1 * -X1))))).+step(add(rule(516, (X1 * (X2 * X2)) = (X2 * (X2 * X1))))).+step(add(rule(517, (X1 * (X1 * X2)) = (X1 * (X2 * X1))))).+step(add(rule(518, (X1 * X2) = (X2 * X1)))).++lemma((X1 + 0) = X1).+lemma((X1 + (-X1 + X2)) = X2).+lemma(-(-X1) = X1).+lemma((X1 + (X2 + X3)) = (X2 + (X1 + X3))).+lemma((X2 + (X1 + -X2)) = X1).+lemma((X1 * (X1 * (X1 * X2))) = (X1 * X2)).+lemma((X1 + (X2 + -(X1 + X2))) = 0).+lemma((X1 * ((X1 * X1) + X2)) = (X1 + (X1 * X2))).+lemma((X1 * 0) = 0).+lemma((X1 * (X2 + (X1 * X1))) = (X1 + (X1 * X2))).+lemma((X2 + -(X1 + X2)) = -X1).+lemma((X1 + (X2 * (X1 * X1))) = ((X1 + X2) * (X1 * X1))).+lemma((X2 + -(X2 + X1)) = -X1).+lemma(-(X1 + -X2) = (X2 + -X1)).+lemma((X1 + (X1 * (X2 * X1))) = (X1 * ((X1 + X2) * X1))).+lemma((0 * X1) = 0).+lemma(((X1 * (X2 * X4)) + (X3 * X4)) = (((X1 * X2) + X3) * X4)).+lemma((X1 * (X3 + (X2 * X3))) = ((X1 + (X1 * X2)) * X3)).+lemma(((X1 + (X1 * X2)) * X3) = (X1 * (X3 + (X2 * X3)))).+lemma(((X1 * X4) + (X2 * (X3 * X4))) = ((X1 + (X2 * X3)) * X4)).+lemma(-(X1 * X2) = (X1 * -X2)).+lemma((-X1 * X2) = (X1 * -X2)).+lemma((X1 * ((X2 + (X1 * X1)) * X3)) = ((X1 + (X1 * X2)) * X3)).+lemma(((X1 + (X2 * X3)) * (X3 * X3)) = (((X1 * X3) + X2) * X3)).+lemma((((X3 * X2) + X1) * (X2 * X2)) = (((X1 * X2) + X3) * X2)).+lemma(((X1 + -X2) * -X3) = ((X2 + -X1) * X3)).+lemma(((X1 + (X1 * X2)) * (X3 * X4)) = (X1 * ((X3 + (X2 * X3)) * X4))).+lemma(((X1 * X2) + (X3 * (X2 + X4))) = ((X3 * X4) + ((X1 + X3) * X2))).+lemma(((X1 + (X1 * (X2 * -X2))) * (X2 * X3)) = 0).+lemma((X1 * ((X2 + (X1 * (X1 * X3))) * X4)) = (X1 * ((X2 + X3) * X4))).+lemma(((X1 + (X2 * (X3 * X3))) * (X3 * X4)) = ((X1 + X2) * (X3 * X4))).+lemma((X1 * (X1 * (X2 * X1))) = (X2 * X1)).+lemma((X1 * (X2 * (X3 * (X1 * X1)))) = (X1 * (X2 * X3))).
+ misc/ring_noconn.pl view
@@ -0,0 +1,977 @@+:- module(ring_noconn, [step/1, lemma/1]).+:- discontiguous(step/1).+:- discontiguous(lemma/1).+:- style_check(-singleton).+step(add(rule(1, (X1 + X2) = (X2 + X1)))).+step(add(rule(2, ((X1 + X2) + X3) = (X1 + (X2 + X3))))).+step(add(rule(3, (0 + X1) = X1))).+step(add(rule(4, (X1 + -X1) = 0))).+step(add(rule(5, ((X1 * X2) * X3) = (X1 * (X2 * X3))))).+step(add(rule(6, ((X1 * X2) + (X1 * X3)) = (X1 * (X2 + X3))))).+step(add(rule(7, ((X1 * X3) + (X2 * X3)) = ((X1 + X2) * X3)))).+step(add(rule(8, (X1 * (X1 * X1)) = X1))).+step(add(rule(9, -0 = 0))).+step(add(rule(10, (X1 + 0) = X1))).+step(add(rule(11, (X1 + (-X1 + X2)) = X2))).+step(add(rule(12, -(-X1) = X1))).+step(add(rule(13, (X1 + (X2 + X3)) = (X3 + (X1 + X2))))).+step(add(rule(14, (X1 + (X2 + X3)) = (X2 + (X1 + X3))))).+step(hard((X1 * (X2 + X3)) = (X1 * (X3 + X2)))).+step(hard(((X1 + X2) * X3) = ((X2 + X1) * X3))).+step(add(rule(15, ((X1 + X1) * X2) = (X1 * (X2 + X2))))).+step(add(rule(16, (X2 + (X1 + -X2)) = X1))).+step(add(rule(17, (0 * (X1 + X1)) = (0 * X1)))).+step(add(rule(18, (X1 * (X1 * (X1 * X2))) = (X1 * X2)))).+step(hard((X1 + (X2 + X3)) = (X3 + (X2 + X1)))).+step(hard((X1 + (X2 + X3)) = (X1 + (X3 + X2)))).+step(add(rule(19, (X1 + (X2 + -(X1 + X2))) = 0))).+step(add(rule(20, (X1 + -(-X2 + X1)) = X2))).+step(add(rule(21, (X1 * ((X1 * X1) + X2)) = (X1 + (X1 * X2))))).+step(add(rule(22, (X1 + (X1 * 0)) = X1))).+step(add(rule(23, (X1 * 0) = 0))).+step(add(rule(24, (X1 * (X2 + (X1 * X1))) = (X1 + (X1 * X2))))).+step(add(rule(25, (X2 + -(X1 + X2)) = -X1))).+step(add(rule(26, ((X1 + X1) * (X1 * X1)) = (X1 + X1)))).+step(hard(0 = (X1 + (X2 + -(X2 + X1))))).+step(add(rule(27, (X2 + -(X2 + -X1)) = X1))).+step(add(rule(28, -(-X1 + -X2) = (X2 + X1)))).+step(add(rule(29, (X1 * (0 * X2)) = (0 * X2)))).+step(add(rule(30, (X1 + (X2 * (X1 * X1))) = ((X1 + X2) * (X1 * X1))))).+step(add(rule(31, (X2 + -(X2 + X1)) = -X1))).+step(hard((-X1 + (X2 + (X3 + X1))) = (X3 + X2))).+step(add(rule(32, (X3 + (X2 + (-X3 + X1))) = (X1 + X2)))).+step(add(rule(33, (X3 + (X1 + (X2 + -X3))) = (X1 + X2)))).+step(add(rule(34, -(X1 + -X2) = (X2 + -X1)))).+step(add(rule(35, (-X1 + -X2) = -(X2 + X1)))).+step(add(rule(36, -(-X2 + X1) = (-X1 + X2)))).+step(hard(-(X1 + X2) = -(X2 + X1))).+step(add(rule(37, (X1 + (X1 * -(X1 * X1))) = 0))).+step(add(rule(38, (-X1 * -(-X1 * -X1)) = X1))).+step(add(rule(39, (-X1 * (-X1 * X1)) = X1))).+step(add(rule(40, (X1 * -(X1 * X1)) = -X1))).+step(hard((X1 + (X2 + (X3 + X4))) = (X2 + (X3 + (X4 + X1))))).+step(hard((X1 + (X2 + (X3 + X4))) = (X3 + (X1 + (X2 + X4))))).+step(hard((X1 + (X2 + (X3 + X4))) = (X3 + (X2 + (X4 + X1))))).+step(hard((X1 + (X2 + (X3 + X4))) = (X3 + (X4 + (X1 + X2))))).+step(hard((X1 + (X2 + (X3 + X4))) = (X4 + (X3 + (X1 + X2))))).+step(hard((X1 + (X2 + (X3 + X4))) = (X4 + (X2 + (X3 + X1))))).+step(hard((X1 + (X2 + (X3 + X4))) = (X2 + (X4 + (X1 + X3))))).+step(add(rule(41, ((X1 + X1) * (X2 * X3)) = (X1 * ((X2 + X2) * X3))))).+step(add(rule(42, (X1 * (X1 * (X1 + X1))) = (X1 + X1)))).+step(add(rule(43, (X1 * (X2 * (X3 + X3))) = (X1 * ((X2 + X2) * X3))))).+step(add(rule(44, (X1 * (X2 * (X3 + X3))) = ((X1 + X1) * (X2 * X3))))).+step(add(rule(45, (X1 + (X1 * (X1 * X2))) = (X1 * (X1 * (X1 + X2)))))).+step(add(rule(46, (X1 + (X1 * (X2 * X1))) = (X1 * ((X1 + X2) * X1))))).+step(add(rule(47, (X1 + (0 * X1)) = X1))).+step(add(rule(48, (0 * X1) = 0))).+step(hard((X1 * (X1 * (X1 + X2))) = (X1 * (X1 * (X2 + X1))))).+step(hard((X1 * ((X1 + X2) * X1)) = (X1 * ((X2 + X1) * X1)))).+step(add(rule(49, (X2 + (X3 + (-(X2 + X3) + X1))) = X1))).+step(hard((X1 + (X2 + (-(X2 + X1) + X3))) = X3)).+step(add(rule(50, (X1 * (X1 * -X1)) = -X1))).+step(hard((X1 + X2) = (-X3 + (X2 + (X3 + X1))))).+step(hard((X1 + X2) = (-X3 + (X1 + (X2 + X3))))).+step(hard((X1 + X2) = (-X3 + (X2 + (X1 + X3))))).+step(add(rule(51, ((X1 * X2) + ((X1 * X3) + X4)) = ((X1 * (X2 + X3)) + X4)))).+step(hard(((X1 * (X2 + X3)) + X4) = ((X1 * (X3 + X2)) + X4))).+step(add(rule(52, ((X1 * X2) + ((X3 * X2) + X4)) = (((X1 + X3) * X2) + X4)))).+step(hard((((X1 + X2) * X3) + X4) = (((X2 + X1) * X3) + X4))).+step(add(rule(53, (((X1 + X1) * X2) + X3) = ((X1 * (X2 + X2)) + X3)))).+step(add(rule(54, ((X1 * (X2 * X4)) + (X3 * X4)) = (((X1 * X2) + X3) * X4)))).+step(add(rule(55, (((X1 * X1) + X2) * X1) = (X1 + (X2 * X1))))).+step(add(rule(56, (X1 + (-(X1 * X1) * X1)) = 0))).+step(add(rule(57, (-(X1 * X1) * X1) = -X1))).+step(add(rule(58, ((X1 + (X1 * X2)) * X3) = (X1 * (X3 + (X2 * X3)))))).+step(add(rule(59, ((X2 + (X1 * X1)) * X1) = (X1 + (X2 * X1))))).+step(add(rule(60, ((X1 * X4) + (X2 * (X3 * X4))) = ((X1 + (X2 * X3)) * X4)))).+step(add(rule(61, (X1 * (X2 * (X1 * (X2 * (X1 * X2))))) = (X1 * X2)))).+step(add(rule(62, (X3 + (X2 + -(X3 + X1))) = (-X1 + X2)))).+step(add(rule(63, (X3 + (-(X3 + X2) + X1)) = (X1 + -X2)))).+step(add(rule(64, (X1 * ((X1 * (X1 * X2)) + X3)) = (X1 * (X2 + X3))))).+step(add(rule(65, (X1 * (X2 + (X1 * (X1 * X3)))) = (X1 * (X2 + X3))))).+step(add(rule(66, (X1 * (X2 + X2)) = (X1 * (X1 * ((X1 + X1) * X2)))))).+step(add(rule(67, (X1 * (X1 * (X1 + (X1 * X2)))) = (X1 + (X1 * X2))))).+step(add(rule(68, -((X1 + X1) * X2) = -(X1 * (X2 + X2))))).+step(hard((X1 + -(X3 + X2)) = (-(X2 + X3) + X1))).+step(hard(-(X3 + (X1 + X2)) = -(X1 + (X3 + X2)))).+step(add(rule(69, (X1 + (X1 * (-(X1 * X1) + X2))) = (X1 * X2)))).+step(hard((X1 + (X2 + (X3 + X4))) = (X2 + (X4 + (X3 + X1))))).+step(add(rule(70, (-(X1 * X3) + (X1 * (X2 + X3))) = (X1 * X2)))).+step(add(rule(71, -(X1 * -X2) = (X1 * X2)))).+step(add(rule(72, -(X1 * X2) = (X1 * -X2)))).+step(add(rule(73, (X1 * (X2 * (-X2 * -X2))) = (X1 * X2)))).+step(add(rule(74, (-X1 * (X1 * -X1)) = X1))).+step(add(rule(75, (X1 * (-X1 * -X1)) = X1))).+step(add(rule(76, (-X1 * (X1 * X1)) = -X1))).+step(add(rule(77, (X1 * (-X1 * X1)) = -X1))).+step(add(rule(78, ((X2 * -X3) + ((X1 + X2) * X3)) = (X1 * X3)))).+step(add(rule(79, (-X1 * -X2) = (X1 * X2)))).+step(add(rule(80, (-X1 * X2) = (X1 * -X2)))).+step(add(rule(81, ((X1 * (X2 + X2)) + X3) = (X3 + ((X1 + X1) * X2))))).+step(add(rule(82, (X1 * -(X2 + X2)) = ((X1 + X1) * -X2)))).+step(add(rule(83, (X1 + ((X2 + X2) * X3)) = (X1 + (X2 * (X3 + X3)))))).+step(add(rule(84, (((X1 + X1) * X2) + X3) = (X3 + (X1 * (X2 + X2)))))).+step(add(rule(85, (X2 + (X3 + (X1 + -(X2 + X3)))) = X1))).+step(add(rule(86, ((X1 + (X1 * X1)) * (X1 * X1)) = (X1 + (X1 * X1))))).+step(add(rule(87, ((X1 * X2) + (X3 + (X1 * X4))) = (X3 + (X1 * (X4 + X2)))))).+step(hard((X1 + (X2 * (X3 + X4))) = ((X2 * (X4 + X3)) + X1))).+step(hard((X1 * (X2 + (X3 + X4))) = (X1 * (X4 + (X2 + X3))))).+step(hard((X1 + (X2 * (X3 + X4))) = (X1 + (X2 * (X4 + X3))))).+step(add(rule(88, ((X1 * X2) + (X3 + (X4 * X2))) = (X3 + ((X4 + X1) * X2))))).+step(hard((X1 + ((X2 + X3) * X4)) = (((X3 + X2) * X4) + X1))).+step(hard(((X1 + (X3 + X4)) * X2) = ((X4 + (X1 + X3)) * X2))).+step(hard((X1 + ((X2 + X3) * X4)) = (X1 + ((X3 + X2) * X4)))).+step(add(rule(89, ((X1 + X2) * (X3 + X3)) = ((X1 + (X2 + (X1 + X2))) * X3)))).+step(add(rule(90, ((X1 + (X1 + X2)) * X3) = ((X1 * (X3 + X3)) + (X2 * X3))))).+step(add(rule(91, ((X1 + (X1 + X1)) * X2) = (X1 * (X2 + (X2 + X2)))))).+step(add(rule(92, ((X1 + (X2 + X2)) * X3) = ((X1 * X3) + (X2 * (X3 + X3)))))).+step(add(rule(93, ((X1 + X2) * (X3 + X3)) = ((X2 + (X1 + (X2 + X1))) * X3)))).+step(add(rule(94, ((X1 + X2) * (X3 + X3)) = ((X1 + (X1 + (X2 + X2))) * X3)))).+step(add(rule(95, ((X1 + X1) * (X2 + X3)) = (X1 * (X2 + (X3 + (X2 + X3))))))).+step(add(rule(96, (X1 * (X2 + (X2 + X3))) = (((X1 + X1) * X2) + (X1 * X3))))).+step(add(rule(97, (X1 * (X2 + (X3 + X3))) = ((X1 * X2) + ((X1 + X1) * X3))))).+step(add(rule(98, ((X1 + X1) * (X2 + X3)) = (X1 * (X3 + (X2 + (X3 + X2))))))).+step(add(rule(99, ((X1 + X1) * (X2 + X3)) = (X1 * (X2 + (X2 + (X3 + X3))))))).+step(add(rule(100, (X1 * (((X1 * X1) + X2) * X3)) = ((X1 + (X1 * X2)) * X3)))).+step(add(rule(101, (X1 * (X3 + ((X1 * X1) + X2))) = (X1 + (X1 * (X2 + X3)))))).+step(add(rule(102, (X1 * (X2 + (X3 + (X1 * X1)))) = (X1 + (X1 * (X2 + X3)))))).+step(add(rule(103, (X1 * ((X2 + (X1 * X1)) * X3)) = ((X1 + (X1 * X2)) * X3)))).+step(add(rule(104, (X1 + (-(X2 + X1) + X3)) = (-X2 + X3)))).+step(add(rule(105, (X3 + -(X1 + (X2 + X3))) = -(X1 + X2)))).+step(add(rule(106, (X1 + (X2 + -(X3 + X1))) = (X2 + -X3)))).+step(add(rule(107, (((X1 * X1) + X2) * (X1 * X3)) = ((X1 + (X2 * X1)) * X3)))).+step(add(rule(108, ((X1 + (X2 * X3)) * (X3 * X3)) = (((X1 * X3) + X2) * X3)))).+step(add(rule(109, ((X1 + (X2 * X2)) * (X2 * X3)) = ((X2 + (X1 * X2)) * X3)))).+step(add(rule(110, (X1 * (X1 * -(X1 + X1))) = -(X1 + X1)))).+step(add(rule(111, (X1 * (X1 * ((X1 + X1) * X2))) = ((X1 + X1) * X2)))).+step(add(rule(112, ((X1 + (X1 + X1)) * (X1 * X1)) = (X1 + (X1 + X1))))).+step(add(rule(113, (-X1 + (X2 + -X3)) = (X2 + -(X1 + X3))))).+step(hard((X1 * -(X2 + X3)) = (X1 * -(X3 + X2)))).+step(add(rule(114, ((X1 + (X1 * (X2 * X2))) * X2) = (X1 * (X2 + X2))))).+step(hard(-(X2 + (X3 + X1)) = -(X1 + (X2 + X3)))).+step(hard(-(X3 + (X1 + X2)) = -(X3 + (X2 + X1)))).+step(add(rule(115, (((X1 * (X2 * X2)) + X3) * X2) = ((X1 + X3) * X2)))).+step(hard((X1 + -(X2 + X3)) = (X1 + -(X3 + X2)))).+step(add(rule(116, (X1 + (X1 * (X2 + (X1 * -X1)))) = (X1 * X2)))).+step(add(rule(117, ((X1 * -X3) + ((X1 + X2) * X3)) = (X2 * X3)))).+step(add(rule(118, (X1 + (((X1 * -X1) + X2) * X1)) = (X2 * X1)))).+step(add(rule(119, (X1 + ((X2 + (X1 * -X1)) * X1)) = (X2 * X1)))).+step(add(rule(120, (X1 + ((-X2 + (X1 * X1)) * -X1)) = (X2 * X1)))).+step(interreduce).+step(delete(rule(13, (X1 + (X2 + X3)) = (X3 + (X1 + X2))))).+step(delete(rule(17, (0 * (X1 + X1)) = (0 * X1)))).+step(delete(rule(19, (X1 + (X2 + -(X1 + X2))) = 0))).+step(delete(rule(20, (X1 + -(-X2 + X1)) = X2))).+step(delete(rule(22, (X1 + (X1 * 0)) = X1))).+step(delete(rule(26, ((X1 + X1) * (X1 * X1)) = (X1 + X1)))).+step(delete(rule(27, (X2 + -(X2 + -X1)) = X1))).+step(delete(rule(28, -(-X1 + -X2) = (X2 + X1)))).+step(delete(rule(29, (X1 * (0 * X2)) = (0 * X2)))).+step(delete(rule(37, (X1 + (X1 * -(X1 * X1))) = 0))).+step(delete(rule(38, (-X1 * -(-X1 * -X1)) = X1))).+step(delete(rule(39, (-X1 * (-X1 * X1)) = X1))).+step(delete(rule(40, (X1 * -(X1 * X1)) = -X1))).+step(delete(rule(47, (X1 + (0 * X1)) = X1))).+step(delete(rule(49, (X2 + (X3 + (-(X2 + X3) + X1))) = X1))).+step(delete(rule(56, (X1 + (-(X1 * X1) * X1)) = 0))).+step(delete(rule(57, (-(X1 * X1) * X1) = -X1))).+step(delete(rule(66, (X1 * (X2 + X2)) = (X1 * (X1 * ((X1 + X1) * X2)))))).+step(delete(rule(68, -((X1 + X1) * X2) = -(X1 * (X2 + X2))))).+step(delete(rule(69, (X1 + (X1 * (-(X1 * X1) + X2))) = (X1 * X2)))).+step(add(rule(121, (X1 + (X1 * ((X1 * -X1) + X2))) = (X1 * X2)))).+step(delete(rule(70, (-(X1 * X3) + (X1 * (X2 + X3))) = (X1 * X2)))).+step(delete(rule(71, -(X1 * -X2) = (X1 * X2)))).+step(delete(rule(73, (X1 * (X2 * (-X2 * -X2))) = (X1 * X2)))).+step(delete(rule(74, (-X1 * (X1 * -X1)) = X1))).+step(delete(rule(75, (X1 * (-X1 * -X1)) = X1))).+step(delete(rule(76, (-X1 * (X1 * X1)) = -X1))).+step(delete(rule(77, (X1 * (-X1 * X1)) = -X1))).+step(delete(rule(79, (-X1 * -X2) = (X1 * X2)))).+step(delete(rule(85, (X2 + (X3 + (X1 + -(X2 + X3)))) = X1))).+step(delete(rule(86, ((X1 + (X1 * X1)) * (X1 * X1)) = (X1 + (X1 * X1))))).+step(delete(rule(89, ((X1 + X2) * (X3 + X3)) = ((X1 + (X2 + (X1 + X2))) * X3)))).+step(delete(rule(93, ((X1 + X2) * (X3 + X3)) = ((X2 + (X1 + (X2 + X1))) * X3)))).+step(delete(rule(95, ((X1 + X1) * (X2 + X3)) = (X1 * (X2 + (X3 + (X2 + X3))))))).+step(delete(rule(98, ((X1 + X1) * (X2 + X3)) = (X1 * (X3 + (X2 + (X3 + X2))))))).+step(add(rule(122, ((X1 + (X1 * (X2 * -X2))) * X2) = 0))).+step(add(rule(123, ((X3 * X2) + ((X1 + X3) * -X2)) = (X1 * -X2)))).+step(add(rule(124, ((X1 + (X1 + (X1 + X1))) * X2) = (X1 * (X2 + (X2 + (X2 + X2))))))).+step(add(rule(125, ((X1 * X3) + (X2 * (X1 * (X1 * X3)))) = ((X1 + X2) * (X1 * (X1 * X3)))))).+step(add(rule(126, (X1 * ((X1 + X1) * ((X1 + X1) * (X2 + X2)))) = ((X1 + X1) * X2)))).+step(add(rule(127, (((X1 + X2) * (X1 * X1)) + X3) = (X1 + ((X2 * (X1 * X1)) + X3))))).+step(add(rule(128, (X1 + (X2 * (X3 * (X1 * X1)))) = ((X1 + (X2 * X3)) * (X1 * X1))))).+step(add(rule(129, (X1 + (X2 + (X3 * (X1 * X1)))) = (X2 + ((X1 + X3) * (X1 * X1)))))).+step(add(rule(130, (X1 * (X1 * (X1 + (X1 + X1)))) = (X1 + (X1 + X1))))).+step(add(rule(131, ((X1 + (X2 + X2)) * (X1 * X1)) = (X1 + (X2 * (X1 * (X1 + X1))))))).+step(add(rule(132, ((X1 * (X2 + X3)) + (X4 * X3)) = ((X1 * X2) + ((X1 + X4) * X3))))).+step(add(rule(133, ((X1 * X2) + ((X1 + X3) * -X2)) = (X3 * -X2)))).+step(add(rule(134, (X1 + (X1 * ((X1 * X2) + X3))) = (X1 * ((X1 * (X1 + X2)) + X3))))).+step(add(rule(135, (((X1 + X2) * X3) + (X2 * X4)) = ((X1 * X3) + (X2 * (X3 + X4)))))).+step(add(rule(136, (((X1 + X2) * (X2 * X2)) + X3) = (X2 + ((X1 * (X2 * X2)) + X3))))).+step(add(rule(137, (X1 + (X1 * ((X2 * X1) + X3))) = (X1 * (((X1 + X2) * X1) + X3))))).+step(add(rule(138, (((X1 * X2) + X3) * (X2 * X2)) = ((X1 + (X3 * X2)) * X2)))).+step(add(rule(139, ((X1 + (X2 * (X3 * X3))) * X3) = ((X1 + X2) * X3)))).+step(add(rule(140, (X1 + (X1 * (X2 * (X3 * X1)))) = (X1 * (((X2 * X3) + X1) * X1))))).+step(add(rule(141, ((X1 * -X3) + (X2 * X3)) = ((-X1 + X2) * X3)))).+step(hard(((-X1 + (X2 + X1)) * X3) = (X2 * X3))).+step(hard((X1 * X2) = ((-X3 + (X1 + X3)) * X2))).+step(add(rule(142, (((X1 * -X1) + X2) * -X1) = (X1 + (X2 * -X1))))).+step(add(rule(143, ((X1 + (X2 * -X2)) * -X2) = (X2 + (X1 * -X2))))).+step(add(rule(144, (((X1 * -X1) + X2) * X1) = (-X1 + (X2 * X1))))).+step(add(rule(145, (-X1 + (-X1 + X2)) = (-(X1 + X1) + X2)))).+step(add(rule(146, (X1 * -((X1 * -X1) + X2)) = (X1 + (X1 * -X2))))).+step(add(rule(147, (X1 * ((X1 * -X1) + X2)) = (-X1 + (X1 * X2))))).+step(add(rule(148, (X3 + -(X1 + (X3 + X2))) = -(X1 + X2)))).+step(hard(X1 = (-X3 + (X1 + X3)))).+step(add(rule(149, ((X2 + ((X1 * X1) + X3)) * X1) = (X1 + ((X2 + X3) * X1))))).+step(add(rule(150, (X1 * (X1 * ((X1 * X2) + X3))) = (X1 * (X2 + (X1 * X3)))))).+step(add(rule(151, (X1 * (X1 * (X2 + (X1 * X3)))) = (X1 * ((X1 * X2) + X3))))).+step(hard(((X1 * (X2 + X2)) + (X3 * X2)) = ((X1 + (X3 + X1)) * X2))).+step(add(rule(152, ((X1 + (X1 + X2)) * X3) = ((X2 * X3) + (X1 * (X3 + X3)))))).+step(hard(((X1 * X2) + (X3 * (X2 + X2))) = ((X3 + (X1 + X3)) * X2))).+step(hard(((X1 + (X2 + X2)) * X3) = ((X2 * (X3 + X3)) + (X1 * X3)))).+step(hard(((X1 + (X1 + (X2 + X2))) * X3) = ((X2 + X1) * (X3 + X3)))).+step(hard(((X1 + X2) * (X3 + X3)) = ((X1 + (X2 + (X2 + X1))) * X3))).+step(hard(((X1 + X2) * (X3 + X3)) = ((X1 + (X2 + (X1 + X2))) * X3))).+step(hard((((X1 + X1) * X2) + (X1 * X3)) = (X1 * (X2 + (X3 + X2))))).+step(add(rule(153, (X1 * (X2 + (X2 + X3))) = ((X1 * X3) + ((X1 + X1) * X2))))).+step(hard(((X1 * X2) + ((X1 + X1) * X3)) = (X1 * (X3 + (X2 + X3))))).+step(hard((X1 * (X2 + (X3 + X3))) = (((X1 + X1) * X3) + (X1 * X2)))).+step(hard((X1 * (X2 + (X2 + (X3 + X3)))) = ((X1 + X1) * (X3 + X2)))).+step(hard(((X1 + X1) * (X2 + X3)) = (X1 * (X2 + (X3 + (X3 + X2)))))).+step(hard(((X1 + X1) * (X2 + X3)) = (X1 * (X2 + (X3 + (X2 + X3)))))).+step(add(rule(154, (X1 * ((X1 + X1) * (X1 + (X1 + (X1 + X1))))) = (X1 + X1)))).+step(add(rule(155, (X1 * ((X1 * (X1 + X1)) + X2)) = (X1 + (X1 + (X1 * X2)))))).+step(add(rule(156, (X4 + (X2 + (X3 + (-X4 + X1)))) = (X1 + (X2 + X3))))).+step(hard((X1 + (X2 + X3)) = (X2 + (X3 + X1)))).+step(hard((X1 + (-X2 + (X3 + X2))) = (X1 + X3))).+step(hard((-X1 + (X2 + (X1 + X3))) = (X2 + X3))).+step(hard((-(X1 + X2) + (X3 + X1)) = (X3 + -X2))).+step(hard((X4 + (X5 + (X2 + X3))) = (X4 + (X2 + (X3 + X5))))).+step(hard((-(X1 + X2) + (X3 + X2)) = (-X1 + X3))).+step(add(rule(157, -(X1 + (-X2 + X3)) = (X2 + -(X3 + X1))))).+step(hard(-X1 = (-X2 + (-X1 + X2)))).+step(add(rule(158, (X4 + (X1 + (X2 + (X3 + -X4)))) = (X1 + (X2 + X3))))).+step(add(rule(159, -(X1 + (X2 + -X3)) = (X3 + -(X1 + X2))))).+step(add(rule(160, (-X1 + (-X2 + X3)) = (-(X2 + X1) + X3)))).+step(add(rule(161, -(X3 + (X1 * -X2)) = ((X1 * X2) + -X3)))).+step(add(rule(162, ((X2 * -X3) + -X1) = -(X1 + (X2 * X3))))).+step(add(rule(163, (-X3 + (X1 * -X2)) = -((X1 * X2) + X3)))).+step(add(rule(164, -((X2 * -X3) + X1) = (-X1 + (X2 * X3))))).+step(add(rule(165, ((X1 + -X2) * -X3) = ((X2 + -X1) * X3)))).+step(add(rule(166, ((-X1 + X2) * -X3) = ((-X2 + X1) * X3)))).+step(hard((X1 + (X1 * (-X2 + (X3 + X2)))) = (X1 + (X1 * X3)))).+step(interreduce).+step(delete(rule(67, (X1 * (X1 * (X1 + (X1 * X2)))) = (X1 + (X1 * X2))))).+step(delete(rule(78, ((X2 * -X3) + ((X1 + X2) * X3)) = (X1 * X3)))).+step(delete(rule(114, ((X1 + (X1 * (X2 * X2))) * X2) = (X1 * (X2 + X2))))).+step(delete(rule(117, ((X1 * -X3) + ((X1 + X2) * X3)) = (X2 * X3)))).+step(delete(rule(118, (X1 + (((X1 * -X1) + X2) * X1)) = (X2 * X1)))).+step(delete(rule(120, (X1 + ((-X2 + (X1 * X1)) * -X1)) = (X2 * X1)))).+step(delete(rule(121, (X1 + (X1 * ((X1 * -X1) + X2))) = (X1 * X2)))).+step(delete(rule(145, (-X1 + (-X1 + X2)) = (-(X1 + X1) + X2)))).+step(delete(rule(146, (X1 * -((X1 * -X1) + X2)) = (X1 + (X1 * -X2))))).+step(add(rule(167, ((X1 + X1) * (X1 + (X1 + (X1 + X1)))) = (X1 * (X1 + X1))))).+step(hard((-(X1 + X2) + X3) = (-(X2 + X1) + X3))).+step(add(rule(168, ((X1 * (X2 + X2)) + ((X1 + X1) * -X2)) = 0))).+step(add(rule(169, (((X1 + X1) * X2) + (X1 * -(X2 + X2))) = 0))).+step(add(rule(170, ((X1 * X3) + (X2 * -X3)) = ((-X2 + X1) * X3)))).+step(add(rule(171, ((X1 + (X1 * (X2 * -X2))) * -X2) = 0))).+step(add(rule(172, ((X1 + (X1 * (X2 * -X2))) * (X2 * -X2)) = 0))).+step(hard((X1 + (-X3 + (X2 + X3))) = (X2 + X1))).+step(hard((X1 * X2) = ((-X4 + (X1 + X4)) * X2))).+step(add(rule(173, ((X1 * (X2 + X2)) + ((X1 + X1) * X3)) = ((X1 + X1) * (X2 + X3))))).+step(add(rule(174, (((X1 + X1) * X2) + (X1 * (X3 + X3))) = ((X1 + X1) * (X2 + X3))))).+step(add(rule(175, (X1 + (X1 + ((X1 + X1) * X2))) = ((X1 + X1) * (X2 + (X1 * X1)))))).+step(add(rule(176, (X1 * ((X1 + X1) * (X1 + X1))) = (X1 + (X1 + (X1 + X1)))))).+step(add(rule(177, (((X1 + X1) * X3) + (X2 * (X3 + X3))) = ((X1 + X2) * (X3 + X3))))).+step(add(rule(178, ((X1 * (X3 + X3)) + ((X2 + X2) * X3)) = ((X1 + X2) * (X3 + X3))))).+step(add(rule(179, (X1 + (X1 * -(X2 + (X1 * X1)))) = (X1 * -X2)))).+step(add(rule(180, (X1 + ((X2 + (X1 * X1)) * -X1)) = (X2 * -X1)))).+step(add(rule(181, (X2 + (X3 + (-X1 + X4))) = (X2 + (X4 + (-X1 + X3)))))).+step(hard((X1 + (X2 + (X3 + X4))) = (X1 + (X4 + (X3 + X2))))).+step(add(rule(182, (((X1 + X1) * -X2) + X3) = ((X1 * -(X2 + X2)) + X3)))).+step(add(rule(183, (X1 + ((X2 + X2) * -X3)) = (X1 + (X2 * -(X3 + X3)))))).+step(add(rule(184, (X1 + ((X2 + X2) * -X3)) = ((X2 * -(X3 + X3)) + X1)))).+step(add(rule(185, (X3 * ((X2 + X2) * -X4)) = (X3 * (X2 * -(X4 + X4)))))).+step(add(rule(186, (X1 * (X4 * -(X3 + X3))) = ((X1 + X1) * (X4 * -X3))))).+step(add(rule(187, (X2 + (((X2 * X2) + X1) * -X2)) = (X1 * -X2)))).+step(add(rule(188, ((X1 + (X1 + X1)) * -X2) = (X1 * -(X2 + (X2 + X2)))))).+step(hard((-(X1 + X2) + (X3 + X4)) = (X3 + (X4 + -(X2 + X1))))).+step(add(rule(189, (X1 + (X2 * -(X3 + X3))) = (((X2 + X2) * -X3) + X1)))).+step(add(rule(190, (X1 * (X2 * ((X3 + X3) * X4))) = ((X1 + X1) * (X2 * (X3 * X4)))))).+step(add(rule(191, (X1 * (X2 * ((X3 + X3) * X4))) = (X1 * ((X2 + X2) * (X3 * X4)))))).+step(add(rule(192, ((X1 + X1) * (X2 + (X2 + (X2 + X2)))) = (X1 * (X2 + X2))))).+step(add(rule(193, (X1 * (X2 * ((X3 + X3) * X4))) = (X1 * (X2 * (X3 * (X4 + X4))))))).+step(add(rule(194, (X1 * ((X2 * (X3 + X3)) + X4)) = (X1 * (((X2 + X2) * X3) + X4))))).+step(add(rule(195, (X1 * ((X2 + X2) * (X3 * X4))) = (X1 * (X2 * (X3 * (X4 + X4))))))).+step(add(rule(196, (X1 * (X2 + (X3 * (X4 + X4)))) = (X1 * (X2 + ((X3 + X3) * X4)))))).+step(add(rule(197, ((X1 + X1) * (X2 * (X3 * X4))) = (X1 * (X2 * (X3 * (X4 + X4))))))).+step(interreduce).+step(delete(rule(123, ((X3 * X2) + ((X1 + X3) * -X2)) = (X1 * -X2)))).+step(delete(rule(133, ((X1 * X2) + ((X1 + X3) * -X2)) = (X3 * -X2)))).+step(delete(rule(154, (X1 * ((X1 + X1) * (X1 + (X1 + (X1 + X1))))) = (X1 + X1)))).+step(delete(rule(167, ((X1 + X1) * (X1 + (X1 + (X1 + X1)))) = (X1 * (X1 + X1))))).+step(delete(rule(168, ((X1 * (X2 + X2)) + ((X1 + X1) * -X2)) = 0))).+step(add(rule(198, ((X1 * (X1 * (X1 + X2))) + X3) = (X1 + ((X1 * (X1 * X2)) + X3))))).+step(add(rule(199, (X1 + (X2 + (X1 * (X1 * X3)))) = (X2 + (X1 * (X1 * (X1 + X3))))))).+step(add(rule(200, (X1 * (X1 * (X1 + (X2 + X2)))) = (X1 + (X1 * ((X1 + X1) * X2)))))).+step(add(rule(201, ((X1 * ((X1 + X2) * X1)) + X3) = (X1 + ((X1 * (X2 * X1)) + X3))))).+step(add(rule(202, (X1 + (X2 + (X1 * (X3 * X1)))) = (X2 + (X1 * ((X1 + X3) * X1)))))).+step(add(rule(203, (X1 * ((X1 + (X2 + X2)) * X1)) = (X1 + (X1 * (X2 * (X1 + X1))))))).+step(add(rule(204, ((X2 * -X3) + (((X1 + X2) * X3) + X4)) = ((X1 * X3) + X4)))).+step(hard(((X1 + X3) * X2) = ((-X4 + (X1 + (X4 + X3))) * X2))).+step(hard(((X1 * X2) + X3) = (((-X4 + (X1 + X4)) * X2) + X3))).+step(hard(((-X3 + X1) * X2) = ((-(X3 + X4) + (X1 + X4)) * X2))).+step(add(rule(205, ((X1 * (X2 * (X3 + X3))) + X4) = ((X1 * ((X2 + X2) * X3)) + X4)))).+step(add(rule(206, ((X1 * (X2 * (X3 + X3))) + X4) = (((X1 + X1) * (X2 * X3)) + X4)))).+step(add(rule(207, ((X1 * (X2 + X2)) + (X3 + X4)) = (X3 + (((X1 + X1) * X2) + X4))))).+step(add(rule(208, (((X1 + X1) * X2) + (X3 + X4)) = (X3 + ((X1 * (X2 + X2)) + X4))))).+step(add(rule(209, (X1 + (X1 * ((X2 + X2) * X3))) = (X1 + (X1 * (X2 * (X3 + X3))))))).+step(add(rule(210, (((X1 + X1) * (X2 * X3)) + X4) = ((X1 * ((X2 + X2) * X3)) + X4)))).+step(add(rule(211, ((((X1 + X1) * X2) + X3) * X4) = (((X1 * (X2 + X2)) + X3) * X4)))).+step(add(rule(212, (X1 + ((X1 + (X2 * X1)) * X1)) = ((X1 + ((X1 + X2) * X1)) * X1)))).+step(simplify_queue).+step(interreduce).+step(hard((X1 + X2) = (X2 + (-X4 + (X1 + X4))))).+step(hard((X1 + ((X1 * (X3 + X2)) + X4)) = (X1 + ((X1 * (X2 + X3)) + X4)))).+step(hard((X4 + (X1 * (-X3 + (X2 + X3)))) = ((X1 * X2) + X4))).+step(add(rule(213, (X1 + (X1 * (X1 + (X1 * X2)))) = (X1 * (X1 + (X1 * (X2 + X1))))))).+step(hard((X1 * (X1 + (X1 * (X1 + X2)))) = (X1 * (X1 + (X1 * (X2 + X1)))))).+step(add(rule(214, ((X1 + (X1 * X2)) * (X1 * X1)) = (X1 * ((X1 + (X2 * X1)) * X1))))).+step(add(rule(215, (X1 + (X1 * (X1 + (X2 * X1)))) = (X1 * (X1 + ((X1 + X2) * X1)))))).+step(add(rule(216, (X1 + (((X1 * X2) + X3) * X1)) = (((X1 * (X1 + X2)) + X3) * X1)))).+step(add(rule(217, (X1 + (((X2 * X1) + X3) * X1)) = ((((X1 + X2) * X1) + X3) * X1)))).+step(hard(((-X2 + (X1 + X2)) * (X1 * X1)) = X1)).+step(add(rule(218, ((X1 + (X1 * X2)) * (X3 * X4)) = (X1 * ((X3 + (X2 * X3)) * X4))))).+step(add(rule(219, (X1 * (X2 * (X3 + (X4 * X3)))) = (X1 * ((X2 + (X2 * X4)) * X3))))).+step(add(rule(220, (X1 * (X2 * (X3 + (X2 * X3)))) = ((X1 + (X1 * X2)) * (X2 * X3))))).+step(add(rule(221, (X1 * (X2 + ((X3 + X3) * X2))) = ((X1 + ((X1 + X1) * X3)) * X2)))).+step(add(rule(222, (X1 * (X2 + (X1 * (X3 * X2)))) = (X1 * (X1 * ((X1 + X3) * X2)))))).+step(add(rule(223, (X1 * (X2 + (X3 * (X1 * X2)))) = (X1 * ((X1 + X3) * (X1 * X2)))))).+step(add(rule(224, ((X1 + (X1 * (X2 * X3))) * X4) = (X1 * (X4 + (X2 * (X3 * X4))))))).+step(add(rule(225, ((X1 + (X1 * (X2 + X2))) * X3) = (X1 * (X3 + (X2 * (X3 + X3))))))).+step(add(rule(226, ((X1 + ((X2 + X2) * X3)) * X4) = ((X1 + (X2 * (X3 + X3))) * X4)))).+step(add(rule(227, (X1 * (X3 + (X2 * (X1 * X3)))) = (X1 * ((X2 + X1) * (X1 * X3)))))).+step(add(rule(228, (X1 * -(X2 + (X1 * (X1 * -X2)))) = 0))).+step(add(rule(229, (X1 * -((X1 * X1) + X2)) = -(X1 + (X1 * X2))))).+step(add(rule(230, (X1 * -(X2 + (X1 * X1))) = -(X1 + (X1 * X2))))).+step(add(rule(231, (((X1 * X1) + X2) * -X1) = -(X1 + (X2 * X1))))).+step(interreduce).+step(delete(rule(179, (X1 + (X1 * -(X2 + (X1 * X1)))) = (X1 * -X2)))).+step(delete(rule(187, (X2 + (((X2 * X2) + X1) * -X2)) = (X1 * -X2)))).+step(delete(rule(214, ((X1 + (X1 * X2)) * (X1 * X1)) = (X1 * ((X1 + (X2 * X1)) * X1))))).+step(add(rule(232, ((X1 + (X2 * X2)) * -X2) = -(X2 + (X1 * X2))))).+step(add(rule(233, ((X1 * X2) + (X3 * (X2 + X4))) = ((X3 * X4) + ((X1 + X3) * X2))))).+step(hard((X1 + (X2 + (X2 * (X4 + X3)))) = (X2 + (X1 + (X2 * (X3 + X4)))))).+step(add(rule(234, (X1 + (X1 * (X2 + (X1 * X3)))) = (X1 * (X2 + (X1 * (X3 + X1))))))).+step(hard((X4 + (X1 * (X5 + (X2 + X3)))) = (X4 + (X1 * (X5 + (X3 + X2)))))).+step(add(rule(235, ((X1 * X2) + (X3 * (X4 + X2))) = (((X3 + X1) * X2) + (X3 * X4))))).+step(hard((X1 * (-X2 + (X3 + X2))) = (X1 * X3))).+step(add(rule(236, (X1 + ((X2 + (X1 * X3)) * X1)) = ((X2 + (X1 * (X3 + X1))) * X1)))).+step(add(rule(237, ((X1 * X2) + ((X1 + X3) * X4)) = ((X3 * X4) + (X1 * (X2 + X4)))))).+step(add(rule(238, (X1 + ((X2 + X3) * (X3 * X3))) = (X3 + (X1 + (X2 * (X3 * X3))))))).+step(add(rule(239, (X1 + ((X2 + X3) * (X2 * X2))) = ((X3 * (X2 * X2)) + (X1 + X2))))).+step(add(rule(240, (X1 + (X1 * (X2 + (X3 * X1)))) = (X1 * (X2 + ((X3 + X1) * X1)))))).+step(add(rule(241, ((X1 * X2) + ((X3 + X1) * X4)) = ((X1 * (X4 + X2)) + (X3 * X4))))).+step(hard((X4 + ((X5 + (X1 + X2)) * X3)) = (X4 + ((X5 + (X2 + X1)) * X3)))).+step(add(rule(242, (X1 + ((X2 + (X3 * X1)) * X1)) = ((X2 + ((X3 + X1) * X1)) * X1)))).+step(hard(((X1 + (X1 + X2)) * (X2 * X2)) = (X2 + (X1 * (X2 * (X2 + X2)))))).+step(hard((X1 + (X1 * (X2 * (X1 + X1)))) = (X1 * ((X2 + (X2 + X1)) * X1)))).+step(hard(((X1 + (X1 + (X2 + X2))) * X3) = ((X1 + (X2 + (X1 + X2))) * X3))).+step(add(rule(243, (((X1 * (X1 + X1)) + (X2 + X2)) * X1) = (((X1 * X1) + X2) * (X1 + X1))))).+step(hard((X1 + (X1 * ((X1 + X1) * X2))) = (X1 * (X1 * (X2 + (X2 + X1)))))).+step(add(rule(244, (X1 * (X3 + (X2 * (X3 + X3)))) = ((X1 + ((X1 + X1) * X2)) * X3)))).+step(add(rule(245, (X1 * (X2 + (X2 + (X3 * X2)))) = ((X1 + (X1 + (X1 * X3))) * X2)))).+step(hard((X1 * (X1 * (X2 + (X1 + X1)))) = (X1 * (X1 * (X1 + (X1 + X2)))))).+step(hard((X1 * (X2 + (X2 + (X3 + X3)))) = (X1 * (X2 + (X3 + (X2 + X3)))))).+step(add(rule(246, ((X1 + X1) * ((X1 * X1) + X2)) = (X1 + (X1 + (X1 * (X2 + X2))))))).+step(hard((X1 * (X1 + ((X1 + X2) * X1))) = (X1 * (X1 + ((X2 + X1) * X1))))).+step(add(rule(247, (X1 * (((X1 * (X1 + X1)) + X2) * X3)) = (X1 * (X3 + (X3 + (X2 * X3))))))).+step(interreduce).+step(delete(rule(116, (X1 + (X1 * (X2 + (X1 * -X1)))) = (X1 * X2)))).+step(delete(rule(119, (X1 + ((X2 + (X1 * -X1)) * X1)) = (X2 * X1)))).+step(delete(rule(180, (X1 + ((X2 + (X1 * X1)) * -X1)) = (X2 * -X1)))).+step(delete(rule(212, (X1 + ((X1 + (X2 * X1)) * X1)) = ((X1 + ((X1 + X2) * X1)) * X1)))).+step(delete(rule(213, (X1 + (X1 * (X1 + (X1 * X2)))) = (X1 * (X1 + (X1 * (X2 + X1))))))).+step(delete(rule(215, (X1 + (X1 * (X1 + (X2 * X1)))) = (X1 * (X1 + ((X1 + X2) * X1)))))).+step(add(rule(248, (X1 * (X2 + (X2 + (X1 * (X1 + X1))))) = ((X1 + X1) * ((X1 * X1) + X2))))).+step(add(rule(249, (X1 + (X1 + (X1 * (X2 + X2)))) = ((X1 + X1) * (X2 + (X1 * X1)))))).+step(hard((X1 * (X1 * ((X1 + X2) * X3))) = (X1 * (X1 * ((X2 + X1) * X3))))).+step(hard((X1 * ((X1 + X2) * (X1 * X3))) = (X1 * ((X2 + X1) * (X1 * X3))))).+step(add(rule(250, ((X1 + ((X1 * X1) + X2)) * (X1 * X1)) = ((X1 + ((X2 + X1) * X1)) * X1)))).+step(add(rule(251, ((X1 + (X1 * (X2 * X3))) * X3) = (X1 * ((X2 + X3) * (X3 * X3)))))).+step(hard((X1 * ((X2 + X1) * X2)) = (X1 * ((X1 + X2) * X2)))).+step(add(rule(252, ((X1 + (X2 + (X1 * X1))) * (X1 * X1)) = ((X1 + ((X2 + X1) * X1)) * X1)))).+step(add(rule(253, (X1 * ((X1 + (X2 * (X1 * X2))) * (X1 * X2))) = ((X1 + X1) * X2)))).+step(hard((X1 + ((X2 * (X1 * X1)) + X3)) = (X3 + ((X1 + X2) * (X1 * X1))))).+step(hard(((X1 + ((X2 + X1) * X1)) * X1) = ((X1 + ((X1 + X2) * X1)) * X1))).+step(hard(((X1 + (X2 + X3)) * (X1 * X1)) = ((X2 + (X1 + X3)) * (X1 * X1)))).+step(hard(((X2 + ((X3 + X1) * X1)) * X1) = ((X2 + ((X1 + X3) * X1)) * X1))).+step(hard((X1 + (X2 * (X1 * (X1 + X1)))) = ((X2 + (X1 + X2)) * (X1 * X1)))).+step(add(rule(254, ((X1 * X2) + ((X1 + X3) * X4)) = ((X1 * (X4 + X2)) + (X3 * X4))))).+step(add(rule(255, ((X1 * (X2 + X3)) + (X4 * X3)) = (((X1 + X4) * X3) + (X1 * X2))))).+step(add(rule(256, ((X1 * (X2 + X3)) + (X4 * X3)) = ((X1 * X2) + ((X4 + X1) * X3))))).+step(hard((X1 * ((X1 * (X1 + X2)) + X3)) = (X1 * (X3 + (X1 * (X2 + X1)))))).+step(add(rule(257, ((X1 * X2) + (X3 * (X2 + X4))) = (((X3 + X1) * X2) + (X3 * X4))))).+step(hard((((X1 + X2) * X3) + (X2 * X4)) = ((X2 * (X3 + X4)) + (X1 * X3)))).+step(add(rule(258, (((X1 + X2) * X3) + (X2 * X4)) = ((X1 * X3) + (X2 * (X4 + X3)))))).+step(hard((X1 + ((X2 * (X1 * X1)) + X3)) = (X3 + ((X2 + X1) * (X1 * X1))))).+step(hard(((((X1 + X2) * X1) + X3) * X1) = ((((X2 + X1) * X1) + X3) * X1))).+step(hard((X1 * (((X1 + X2) * X1) + X3)) = (X1 * (X3 + ((X2 + X1) * X1))))).+step(add(rule(259, ((X1 + (X1 * (X2 * X3))) * X3) = (X1 * ((X3 + X2) * (X3 * X3)))))).+step(add(rule(260, ((X2 + (X1 * -X1)) * X1) = (-X1 + (X2 * X1))))).+step(add(rule(261, (X1 * (X2 + (X1 * -X1))) = (-X1 + (X1 * X2))))).+step(add(rule(262, ((X1 + X1) * (X2 + (X2 + X2))) = ((X1 + (X1 + X1)) * (X2 + X2))))).+step(interreduce).+step(delete(rule(241, ((X1 * X2) + ((X3 + X1) * X4)) = ((X1 * (X4 + X2)) + (X3 * X4))))).+step(delete(rule(255, ((X1 * (X2 + X3)) + (X4 * X3)) = (((X1 + X4) * X3) + (X1 * X2))))).+step(add(rule(263, (X1 + (X1 + (X2 * (X1 + X1)))) = (((X1 * X1) + X2) * (X1 + X1))))).+step(add(rule(264, (X2 + (X2 + (X1 * (X2 * (X2 + X2))))) = ((X1 + X2) * (X2 * (X2 + X2)))))).+step(add(rule(265, (X3 + (X4 + (X2 + (-(X3 + X4) + X1)))) = (X1 + X2)))).+step(hard((X1 + -X2) = (-(X2 + X3) + (X1 + X3)))).+step(hard((X1 + (X2 + (X3 + X4))) = (X1 + (X2 + (X4 + X3))))).+step(hard((X3 + (X4 + (X5 + X2))) = (X3 + (X5 + (X4 + X2))))).+step(hard((X1 + X2) = (X2 + (-(X4 + X5) + (X1 + (X4 + X5)))))).+step(add(rule(266, (X3 + (X4 + (X1 + (X2 + -(X3 + X4))))) = (X1 + X2)))).+step(add(rule(267, (X1 * (X2 + (X1 * (X1 + X1)))) = (X1 + (X1 + (X1 * X2)))))).+step(add(rule(268, ((X2 + (X3 + (X1 * X1))) * X1) = (X1 + ((X2 + X3) * X1))))).+step(add(rule(269, (X1 * (X2 + ((X1 * (X1 * -X2)) + X3))) = (X1 * X3)))).+step(hard((X1 * X2) = (X1 * (-X3 + (X2 + X3))))).+step(add(rule(270, (X1 * (X2 + (X3 + (X1 * (X1 * -X2))))) = (X1 * X3)))).+step(hard((X1 + -X2) = (-X3 + (X1 + (X3 + -X2))))).+step(add(rule(271, ((X1 + X1) * (X2 + X2)) = (X1 * ((X1 + X1) * ((X1 + X1) * X2)))))).+step(add(rule(272, ((X1 + X1) * ((X1 + X1) * (X2 + X2))) = (X1 * ((X1 + X1) * X2))))).+step(hard((-X2 + X1) = (-(X2 + X3) + (X1 + X3)))).+step(add(rule(273, (((X1 * (X1 + X1)) + X2) * X1) = (X1 + (X1 + (X2 * X1)))))).+step(hard(((X1 + (X3 + (X3 + X1))) * X2) = ((X3 + X1) * (X2 + X2)))).+step(add(rule(274, ((X1 + (X2 * (X2 + X2))) * X2) = (X2 + (X2 + (X1 * X2)))))).+step(hard((X1 * (X2 + (X3 + (X3 + X2)))) = ((X1 + X1) * (X3 + X2)))).+step(hard((X1 + (X2 + X3)) = (-X4 + (X2 + (X3 + (X4 + X1)))))).+step(hard((X1 + (-X2 + (X3 + (X4 + X2)))) = (X1 + (X4 + X3)))).+step(hard((X1 + (X2 + X3)) = (-X4 + (X1 + (X2 + (X3 + X4)))))).+step(hard((X1 + (X2 + (-X3 + (X4 + X3)))) = (X1 + (X2 + X4)))).+step(hard(((X1 * X2) + X3) = (((-X5 + (X1 + X5)) * X2) + X3))).+step(hard((X1 + ((-X2 + (X4 + X2)) * X3)) = (X1 + (X4 * X3)))).+step(hard((X1 + (X3 + (-X2 + (X4 + X2)))) = (X3 + (X4 + X1)))).+step(hard((X1 * (X2 * X3)) = (X1 * (X2 * (-X4 + (X3 + X4)))))).+step(hard((X1 * (X2 * X3)) = (X1 * ((-X4 + (X2 + X4)) * X3)))).+step(add(rule(275, (X1 * (X2 + (X1 * (X1 + (X1 * -X2))))) = X1))).+step(hard(((X1 * -(X2 + X2)) + ((X1 + X1) * X2)) = 0)).+step(add(rule(276, (X1 * (X2 * (X1 * (X2 * (X1 * (X2 * X3)))))) = (X1 * (X2 * X3))))).+step(interreduce).+step(delete(rule(126, (X1 * ((X1 + X1) * ((X1 + X1) * (X2 + X2)))) = ((X1 + X1) * X2)))).+step(delete(rule(243, (((X1 * (X1 + X1)) + (X2 + X2)) * X1) = (((X1 * X1) + X2) * (X1 + X1))))).+step(add(rule(277, (X1 + (X1 + ((X2 + X2) * X1))) = (((X1 * X1) + X2) * (X1 + X1))))).+step(add(rule(278, ((X1 * X2) + (X3 + ((X1 * X4) + X5))) = (X3 + ((X1 * (X2 + X4)) + X5))))).+step(hard((X1 + (X2 * (X3 + (X4 + X5)))) = (X1 + (X2 * (X4 + (X5 + X3)))))).+step(hard(((X1 * (X2 + (X3 + X4))) + X5) = ((X1 * (X3 + (X2 + X4))) + X5))).+step(add(rule(279, ((X1 * (X2 + (X2 + X3))) + X4) = (((X1 + X1) * X2) + ((X1 * X3) + X4))))).+step(add(rule(280, (X4 + ((X1 * (X2 + X2)) + X5)) = (((X1 + X1) * X2) + (X5 + X4))))).+step(add(rule(281, ((X1 * (X2 + (X2 + X2))) + X3) = (((X1 + (X1 + X1)) * X2) + X3)))).+step(add(rule(282, (-? + ((X2 * (X3 + X3)) + ?)) = ((X2 + X2) * X3)))).+step(add(rule(283, (-X1 + ((X2 * (X3 + X3)) + X1)) = (-? + ((X2 * (X3 + X3)) + ?))))).+step(add(rule(284, ((X1 * (X2 + (X3 + X3))) + X4) = ((X1 * X2) + (((X1 + X1) * X3) + X4))))).+step(add(rule(285, (X1 + (((X1 + X1) * X2) + X3)) = (X1 + ((X1 * (X2 + X2)) + X3))))).+step(add(rule(286, ((X1 * (X2 * X4)) + ((X3 * X4) + X5)) = ((((X1 * X2) + X3) * X4) + X5)))).+step(add(rule(287, ((-X3 + ((X1 * X2) + X3)) * X4) = (X1 * (X2 * X4))))).+step(add(rule(288, ((X1 * X3) + ((X2 * (X1 * X3)) + X4)) = (((X1 + (X2 * X1)) * X3) + X4)))).+step(add(rule(289, (((X1 + (X1 * X2)) * X3) + X4) = ((X1 * (X3 + (X2 * X3))) + X4)))).+step(add(rule(290, ((X1 + (X1 * X2)) * -X3) = (X1 * -(X3 + (X2 * X3)))))).+step(hard(((X1 + X1) * X2) = ((-X3 + (X1 + (X1 + X3))) * X2))).+step(add(rule(291, ((X1 * X4) + ((X2 * (X3 * X4)) + X5)) = (((X1 + (X2 * X3)) * X4) + X5)))).+step(add(rule(292, ((X1 * X2) + (X3 + ((X4 * X2) + X5))) = (X3 + (((X1 + X4) * X2) + X5))))).+step(hard((X1 + ((-X3 + (X2 + X3)) * X4)) = ((X2 * X4) + X1))).+step(hard((X1 + ((X2 + (X3 + X5)) * X4)) = (X1 + ((X3 + (X5 + X2)) * X4)))).+step(hard((((X1 + (X3 + X4)) * X2) + X5) = (((X3 + (X1 + X4)) * X2) + X5))).+step(add(rule(293, (X1 + (((X2 + X2) * X3) + X4)) = (X1 + ((X2 * (X3 + X3)) + X4))))).+step(add(rule(294, (((X1 + (X1 + X2)) * X3) + X4) = ((X1 * (X3 + X3)) + ((X2 * X3) + X4))))).+step(hard(((-X2 + (X1 + (X1 + X2))) * X3) = (X1 * (X3 + X3)))).+step(add(rule(295, (((X1 + (X2 + X2)) * X3) + X4) = ((X1 * X3) + ((X2 * (X3 + X3)) + X4))))).+step(add(rule(296, ((X1 * (X2 * (X3 * X5))) + (X4 * X5)) = (((X1 * (X2 * X3)) + X4) * X5)))).+step(add(rule(297, ((X1 * (X2 * X5)) + (X3 * (X4 * X5))) = (((X1 * X2) + (X3 * X4)) * X5)))).+step(add(rule(298, ((X1 * X4) + (X2 * (X3 * (X1 * X4)))) = ((X1 + (X2 * (X3 * X1))) * X4)))).+step(add(rule(299, ((X1 * (X2 * X3)) + (X4 + (X5 * X3))) = (X4 + (((X1 * X2) + X5) * X3))))).+step(add(rule(300, ((X1 + ((X3 * X4) + X5)) * X2) = (((X3 * X4) + (X1 + X5)) * X2)))).+step(hard(((X1 + (X2 + X3)) * X4) = ((X2 + (X1 + X3)) * X4))).+step(add(rule(301, ((X2 * X4) + (X1 + (X3 * (X2 * X4)))) = (X1 + ((X2 + (X3 * X2)) * X4))))).+step(hard(((((X1 + X4) * X2) + X5) * X3) = ((((X4 + X1) * X2) + X5) * X3))).+step(add(rule(302, (X1 + ((X2 + (X2 * X3)) * X4)) = (X1 + (X2 * (X4 + (X3 * X4))))))).+step(add(rule(303, ((((X1 + X1) * X2) + X3) * X4) = ((X1 * (X2 * (X4 + X4))) + (X3 * X4))))).+step(add(rule(304, ((X1 + X1) * ((X2 + (X1 * X1)) * X3)) = (X1 * (((X3 * X3) + X2) * (X3 + X3)))))).+step(add(rule(305, ((X1 + X1) * (-X2 + (X1 * (X1 * X2)))) = 0))).+step(add(rule(306, (((X1 * (X2 + X2)) + X3) * X4) = ((X1 * (X2 * (X4 + X4))) + (X3 * X4))))).+step(add(rule(307, (((X1 * X2) + (X3 + X3)) * X4) = ((X1 * (X2 * X4)) + (X3 * (X4 + X4)))))).+step(interreduce).+step(delete(rule(125, ((X1 * X3) + (X2 * (X1 * (X1 * X3)))) = ((X1 + X2) * (X1 * (X1 * X3)))))).+step(delete(rule(282, (-? + ((X2 * (X3 + X3)) + ?)) = ((X2 + X2) * X3)))).+step(delete(rule(283, (-X1 + ((X2 * (X3 + X3)) + X1)) = (-? + ((X2 * (X3 + X3)) + ?))))).+step(add(rule(308, (-X1 + ((X2 * (X3 + X3)) + X1)) = (X2 * (X3 + X3))))).+step(delete(rule(285, (X1 + (((X1 + X1) * X2) + X3)) = (X1 + ((X1 * (X2 + X2)) + X3))))).+step(delete(rule(288, ((X1 * X3) + ((X2 * (X1 * X3)) + X4)) = (((X1 + (X2 * X1)) * X3) + X4)))).+step(hard((X1 + X1) = (-X2 + (X1 + (X1 + X2))))).+step(hard((X1 + X2) = (-X3 + (X1 + (X3 + X2))))).+step(add(rule(309, ((X1 + X1) * ((X2 + (X1 * X1)) * X3)) = ((X1 + X1) * (X3 + (X2 * X3)))))).+step(add(rule(310, (((X1 * X2) + X3) * (X2 * (X2 * X4))) = ((X1 + (X3 * X2)) * (X2 * X4))))).+step(add(rule(311, ((X1 + (X1 * (X2 * -X2))) * (X2 * X3)) = 0))).+step(add(rule(312, (X1 * (X2 + (X2 * (X1 * -X1)))) = 0))).+step(hard((X1 * ((-X2 + (X1 + X2)) * X1)) = X1)).+step(add(rule(313, ((X1 + (X1 * (X2 * -X2))) * (X2 + X2)) = 0))).+step(add(rule(314, (X1 * ((X2 + (X1 * (X1 * -X2))) * X3)) = 0))).+step(add(rule(315, ((X1 + (X2 * (X2 * -X1))) * X2) = 0))).+step(add(rule(316, (X1 * ((X2 + (X2 * (X1 * -X1))) * X3)) = 0))).+step(add(rule(317, (X1 * -(X2 + (X2 * (X1 * -X1)))) = 0))).+step(add(rule(318, ((-X1 + (X2 * (X2 * X1))) * X2) = 0))).+step(add(rule(319, ((X1 * X5) + (X2 * (X3 * (X4 * X5)))) = ((X1 + (X2 * (X3 * X4))) * X5)))).+step(add(rule(320, ((X1 * X2) + (X3 + (X4 * (X5 * X2)))) = (X3 + ((X1 + (X4 * X5)) * X2))))).+step(hard(((X4 + ((X5 + X1) * X2)) * X3) = ((X4 + ((X1 + X5) * X2)) * X3))).+step(hard(((X2 + (X1 * (X3 + X1))) * X1) = ((X2 + (X1 * (X1 + X3))) * X1))).+step(add(rule(321, ((X1 + (X1 + (X2 * X3))) * X4) = ((X1 * (X4 + X4)) + (X2 * (X3 * X4)))))).+step(add(rule(322, ((X1 + ((X2 + X2) * X3)) * X4) = ((X1 * X4) + (X2 * (X3 * (X4 + X4))))))).+step(add(rule(323, (X1 + (X2 * (X3 * (X1 + X1)))) = (X1 + ((X2 + X2) * (X3 * X1)))))).+step(add(rule(324, ((X1 + (X2 * (X3 + X3))) * X4) = ((X1 * X4) + (X2 * (X3 * (X4 + X4))))))).+step(add(rule(325, (X1 + (X2 * (X3 * (X1 + X1)))) = (X1 + (X2 * ((X3 + X3) * X1)))))).+step(add(rule(326, ((X1 + (X2 * X3)) * (X3 * (X3 * X4))) = (((X1 * X3) + X2) * (X3 * X4))))).+step(add(rule(327, (X1 * ((X2 * (X1 * (X2 * (X1 * X2)))) + X3)) = (X1 * (X2 + X3))))).+step(add(rule(328, (X1 * (X2 + (X3 * (X1 * (X3 * (X1 * X3)))))) = (X1 * (X2 + X3))))).+step(add(rule(329, (X1 + (X2 + (-(X1 + X3) + X4))) = (-X3 + (X2 + X4))))).+step(hard(-(X3 + (X2 + X1)) = -(X1 + (X2 + X3)))).+step(add(rule(330, (X4 + (X2 + (X3 + -(X4 + X1)))) = (-X1 + (X2 + X3))))).+step(hard((-(X1 + X2) + (X3 + X1)) = (-X2 + X3))).+step(add(rule(331, (X4 + (X3 + -(X1 + (X4 + X2)))) = (-(X1 + X2) + X3)))).+step(hard((X1 + X2) = (-X4 + (X1 + (X4 + X2))))).+step(add(rule(332, (X4 + (-(X2 + (X4 + X3)) + X1)) = (X1 + -(X2 + X3))))).+step(hard((X1 + X2) = (-X4 + (X2 + (X4 + X1))))).+step(add(rule(333, (X2 + ((X2 + X1) * (X2 * -X2))) = (X1 * (X2 * -X2))))).+step(add(rule(334, (X2 + (X1 * (X2 * -X2))) = ((-X1 + X2) * (X2 * X2))))).+step(add(rule(335, (X1 + (X1 * (X2 * -X1))) = (X1 * ((-X2 + X1) * X1))))).+step(add(rule(336, (((X1 * (X2 * (X1 * X2))) + X3) * (X1 * X2)) = ((X1 + (X3 * X1)) * X2)))).+step(add(rule(337, (X1 * (X2 + (X3 * X2))) = (X1 * (X1 * ((X1 + (X1 * X3)) * X2)))))).+step(add(rule(338, (X1 * (((X1 * (X1 * X2)) + X3) * X4)) = (X1 * ((X2 + X3) * X4))))).+step(add(rule(339, (X1 * (X2 + ((X1 * (X1 * X3)) + X4))) = (X1 * (X2 + (X3 + X4)))))).+step(hard((X1 * (X2 + (X3 + X4))) = (X1 * (X3 + (X2 + X4))))).+step(add(rule(340, (X1 * (X2 + (X2 + X3))) = (X1 * ((X1 * ((X1 + X1) * X2)) + X3))))).+step(interreduce).+step(delete(rule(172, ((X1 + (X1 * (X2 * -X2))) * (X2 * -X2)) = 0))).+step(delete(rule(269, (X1 * (X2 + ((X1 * (X1 * -X2)) + X3))) = (X1 * X3)))).+step(delete(rule(298, ((X1 * X4) + (X2 * (X3 * (X1 * X4)))) = ((X1 + (X2 * (X3 * X1))) * X4)))).+step(delete(rule(301, ((X2 * X4) + (X1 + (X3 * (X2 * X4)))) = (X1 + ((X2 + (X3 * X2)) * X4))))).+step(delete(rule(333, (X2 + ((X2 + X1) * (X2 * -X2))) = (X1 * (X2 * -X2))))).+step(add(rule(341, (X1 * ((X1 * (X1 + (X1 * X2))) + X3)) = (X1 + (X1 * (X2 + X3)))))).+step(add(rule(342, (X1 * (X2 + (X3 + (X1 * (X1 * X4))))) = (X1 * (X2 + (X3 + X4)))))).+step(hard((X1 * (X2 + (X3 + X4))) = (X1 * (X2 + (X4 + X3))))).+step(add(rule(343, (X1 * ((X2 + (X1 * (X1 * X3))) * X4)) = (X1 * ((X2 + X3) * X4))))).+step(hard((X1 * ((X2 + X3) * X4)) = (X1 * ((X3 + X2) * X4)))).+step(add(rule(344, (X1 * (X2 + (X3 + X3))) = (X1 * (X2 + (X1 * ((X1 + X1) * X3))))))).+step(add(rule(345, (X1 * (X2 + (X1 * (X1 + (X1 * X3))))) = (X1 + (X1 * (X3 + X2)))))).+step(add(rule(346, (-X1 + (X2 * (X1 * X1))) = ((-X1 + X2) * (X1 * X1))))).+step(add(rule(347, (X1 * (X1 * (-X1 + X2))) = (X1 * (X1 * (X2 + -X1)))))).+step(hard(((X1 * -(X2 + X3)) + X4) = ((X1 * -(X3 + X2)) + X4))).+step(add(rule(348, ((X1 + (X1 * -X2)) * X3) = (X1 * (X3 + (X2 * -X3)))))).+step(hard((X1 + (X2 * -(X3 + X4))) = (X1 + (X2 * -(X4 + X3))))).+step(add(rule(349, (X1 * (X1 * ((X1 + (X1 * X2)) * X3))) = ((X1 + (X1 * X2)) * X3)))).+step(add(rule(350, -(((X1 + X1) * X2) + X3) = -((X1 * (X2 + X2)) + X3)))).+step(add(rule(351, -(X1 + ((X2 + X2) * X3)) = -(X1 + (X2 * (X3 + X3)))))).+step(add(rule(352, -((X1 * (X2 + X2)) + X3) = -(X3 + ((X1 + X1) * X2))))).+step(add(rule(353, -(((X1 + X1) * X2) + X3) = -(X3 + (X1 * (X2 + X2)))))).+step(add(rule(354, (((X1 * (X2 * (X3 * X3))) + X4) * X3) = (((X1 * X2) + X4) * X3)))).+step(add(rule(355, (((X1 * (X2 * (X2 + X2))) + X3) * X2) = ((X1 + (X1 + X3)) * X2)))).+step(hard((X1 + (X3 + -(X4 + X2))) = (X3 + (X1 + -(X2 + X4))))).+step(add(rule(356, ((X1 + (X2 * (X3 * X1))) * (X1 * X1)) = (X1 + (X2 * (X3 * X1)))))).+step(add(rule(357, ((X1 + (X2 * (X3 * (X4 * X4)))) * X4) = ((X1 + (X2 * X3)) * X4)))).+step(add(rule(358, ((X1 + (X2 * (X3 * (X3 + X3)))) * X3) = ((X1 + (X2 + X2)) * X3)))).+step(hard(((-(X1 + X2) + X4) * X3) = ((-(X2 + X1) + X4) * X3))).+step(add(rule(359, ((-X1 + X2) * (X1 * -X1)) = ((-X2 + X1) * (X1 * X1))))).+step(add(rule(360, (-X1 + (X1 * (X2 * X1))) = (X1 * ((-X1 + X2) * X1))))).+step(add(rule(361, (-X1 + (X2 * (X1 * -X1))) = ((X1 + X2) * (X1 * -X1))))).+step(add(rule(362, (-X1 + (X1 * (X1 * X2))) = (X1 * (X1 * (-X1 + X2)))))).+step(add(rule(363, (-X1 + (X1 * (X2 * -X1))) = (X1 * ((X1 + X2) * -X1))))).+step(add(rule(364, ((X1 + X1) * ((X1 * (X1 * X2)) + X3)) = ((X1 + X1) * (X2 + X3))))).+step(add(rule(365, ((X1 + X1) * (X2 + (X1 * (X1 * -X2)))) = 0))).+step(add(rule(366, ((X1 + X1) * (X2 + (X1 * (X1 * X3)))) = ((X1 + X1) * (X2 + X3))))).+step(add(rule(367, (X1 * ((X1 + X1) * -(X1 + X1))) = -(X1 + (X1 + (X1 + X1)))))).+step(add(rule(368, ((X1 + X1) * (X1 + (X1 + X1))) = 0))).+step(interreduce).+step(delete(rule(270, (X1 * (X2 + (X3 + (X1 * (X1 * -X2))))) = (X1 * X3)))).+step(delete(rule(275, (X1 * (X2 + (X1 * (X1 + (X1 * -X2))))) = X1))).+step(delete(rule(305, ((X1 + X1) * (-X2 + (X1 * (X1 * X2)))) = 0))).+step(delete(rule(314, (X1 * ((X2 + (X1 * (X1 * -X2))) * X3)) = 0))).+step(delete(rule(337, (X1 * (X2 + (X3 * X2))) = (X1 * (X1 * ((X1 + (X1 * X3)) * X2)))))).+step(delete(rule(365, ((X1 + X1) * (X2 + (X1 * (X1 * -X2)))) = 0))).+step(add(rule(369, ((X1 + (X1 + X1)) * -(X1 + X1)) = 0))).+step(add(rule(370, ((X1 + X1) * -(X1 + (X1 + X1))) = 0))).+step(add(rule(371, ((X1 + (X1 + X1)) * ((X1 + X1) * -X2)) = 0))).+step(add(rule(372, ((X1 + (X1 + X1)) * -(X1 + (X1 + (X1 + X1)))) = 0))).+step(add(rule(373, ((X1 + X1) * ((X1 + (X1 + X1)) * -X2)) = 0))).+step(add(rule(374, ((X1 + X1) * ((X1 + (X1 + X1)) * X2)) = 0))).+step(add(rule(375, ((X1 + (X1 + (X1 + X1))) * (X1 + (X1 + X1))) = 0))).+step(add(rule(376, ((X1 + (X1 + X1)) * ((X1 + X1) * X2)) = 0))).+step(add(rule(377, ((X1 + (X1 + X1)) * (X1 + (X1 + (X1 + X1)))) = 0))).+step(add(rule(378, ((X1 + X1) * (X2 * (X1 + (X1 + X1)))) = 0))).+step(add(rule(379, ((X1 + (X1 + X1)) * (X2 * (X1 + X1))) = 0))).+step(hard((X1 + (X2 + (-X3 + X4))) = (X4 + (-X3 + (X2 + X1))))).+step(add(rule(380, (X1 + (-X2 + (X3 + X4))) = (X3 + (-X2 + (X1 + X4)))))).+step(hard((X2 + -X1) = (-(X1 + X4) + (X2 + X4)))).+step(hard((X1 + (X2 + (X3 + X4))) = (X3 + (X2 + (X1 + X4))))).+step(hard((X1 + (-(X3 + X2) + X4)) = (X1 + (X4 + -(X2 + X3))))).+step(hard((X2 + (-(X3 + X1) + X4)) = (X2 + (-(X1 + X3) + X4)))).+step(hard((X1 + (X3 + -(X4 + X2))) = (X1 + (X3 + -(X2 + X4))))).+step(hard((X1 + -(X4 + (X3 + X2))) = (X1 + -(X4 + (X2 + X3))))).+step(add(rule(381, (-X1 + (X2 + (X1 * -X1))) = (X2 + -(X1 + (X1 * X1)))))).+step(hard(-(((X1 + X2) * X3) + X4) = -(X4 + ((X2 + X1) * X3)))).+step(add(rule(382, ((X1 + (X1 * X2)) * (X2 * -X2)) = (X1 * -(X2 + (X2 * X2)))))).+step(add(rule(383, (((X1 * (X2 * X2)) + X3) * (X2 * X4)) = ((X1 + X3) * (X2 * X4))))).+step(add(rule(384, ((X1 + (X2 * (X3 * X3))) * (X3 * X4)) = ((X1 + X2) * (X3 * X4))))).+step(hard((-(X2 + (X3 + X1)) + X4) = (X4 + -(X2 + (X1 + X3))))).+step(hard((-(X2 + (X3 + X1)) + X4) = (-(X3 + (X1 + X2)) + X4))).+step(hard((-(X2 + (X3 + X1)) + X4) = (X4 + -(X3 + (X2 + X1))))).+step(hard((X2 + -(X1 + (X3 + X4))) = (X2 + -(X4 + (X3 + X1))))).+step(hard((X1 + (X3 + -(X4 + X2))) = (X3 + (-(X2 + X4) + X1)))).+step(hard(-(X3 + (X4 + (X1 + X2))) = -(X4 + (X1 + (X3 + X2))))).+step(hard(-(X3 + (X4 + (X1 + X2))) = -(X1 + (X4 + (X2 + X3))))).+step(hard((X2 + -(X1 + (X3 + X4))) = (X2 + -(X3 + (X1 + X4))))).+step(hard(-(X3 + (X4 + (X1 + X2))) = -(X3 + (X1 + (X4 + X2))))).+step(hard(-(X3 + (X4 + (X1 + X2))) = -(X1 + (X3 + (X2 + X4))))).+step(hard((X2 + -(X1 + (X3 + X4))) = (-(X3 + (X4 + X1)) + X2))).+step(hard((X1 + (-(X3 + X5) + X4)) = (X4 + (-(X5 + X3) + X1)))).+step(add(rule(385, (X1 * (X1 * (-X1 + ((X1 + X1) * X2)))) = (-X1 + (X1 * (X2 + X2)))))).+step(add(rule(386, (X1 + (X1 * (X2 + ((X1 * -X1) + X3)))) = (X1 * (X3 + X2))))).+step(add(rule(387, -(X1 + (X1 + (X1 + X1))) = (X1 + X1)))).+step(add(rule(388, -(X1 + (X1 + X1)) = (X1 + (X1 + X1))))).+step(add(rule(389, (X1 + (X1 + (X1 + X1))) = -(X1 + X1)))).+step(add(rule(390, ((X1 + X1) * -(X2 + X2)) = (X1 * (X2 + X2))))).+step(add(rule(391, ((X1 + X1) * (X2 + (X2 + X2))) = 0))).+step(add(rule(392, ((X1 + (X1 + X1)) * (X2 + X2)) = 0))).+step(add(rule(393, ((X1 + X1) * (X2 + X2)) = (X1 * -(X2 + X2))))).+step(hard((X1 * (X2 + (-X3 + (X4 + X3)))) = (X1 * (X2 + X4)))).+step(add(rule(394, (X1 + (X1 * (X2 + (X3 + (X1 * -X1))))) = (X1 * (X2 + X3))))).+step(add(rule(395, (((X1 + X2) * X3) + (X4 + (X2 * -X3))) = ((X1 * X3) + X4)))).+step(hard(((X1 * X2) + X3) = (X3 + ((-X4 + (X1 + X4)) * X2)))).+step(hard(-(X1 + ((X2 + X3) * X4)) = -(X1 + ((X3 + X2) * X4)))).+step(add(rule(396, ((X1 * -X3) + (((X1 + X2) * X3) + X4)) = (X4 + (X2 * X3))))).+step(add(rule(397, (((X1 + X2) * X3) + (X4 + (X1 * -X3))) = ((X2 * X3) + X4)))).+step(hard(((-X1 + (X3 + (X4 + X1))) * X2) = ((X3 + X4) * X2))).+step(hard(((X1 + X3) * X2) = ((-X4 + (X1 + (X3 + X4))) * X2))).+step(add(rule(398, ((X1 * (X2 + X2)) + (((X1 + X1) * -X2) + X3)) = X3))).+step(hard(X1 = (-(X2 + X2) + (X1 + (X2 + X2))))).+step(hard(((X1 * X2) + X3) = ((X1 * (-X4 + (X2 + X4))) + X3))).+step(add(rule(399, ((X1 * (X2 + X2)) + (X3 + ((X1 + X1) * -X2))) = X3))).+step(add(rule(400, (((X1 + X1) * X2) + ((X1 * -(X2 + X2)) + X3)) = X3))).+step(hard(X1 = (-X2 + (X1 + X2)))).+step(add(rule(401, (((X1 + X1) * X2) + (X3 + (X1 * -(X2 + X2)))) = X3))).+step(add(rule(402, (X1 + ((X2 + ((X1 * -X1) + X3)) * X1)) = ((X3 + X2) * X1)))).+step(hard(((X1 + (-X2 + (X3 + X2))) * X4) = ((X1 + X3) * X4))).+step(add(rule(403, (X1 + ((X2 + (X3 + (X1 * -X1))) * X1)) = ((X2 + X3) * X1)))).+step(interreduce).+step(delete(rule(124, ((X1 + (X1 + (X1 + X1))) * X2) = (X1 * (X2 + (X2 + (X2 + X2))))))).+step(delete(rule(176, (X1 * ((X1 + X1) * (X1 + X1))) = (X1 + (X1 + (X1 + X1)))))).+step(delete(rule(188, ((X1 + (X1 + X1)) * -X2) = (X1 * -(X2 + (X2 + X2)))))).+step(add(rule(404, ((X1 + (X1 + X1)) * -X2) = (X1 * (X2 + (X2 + X2)))))).+step(delete(rule(192, ((X1 + X1) * (X2 + (X2 + (X2 + X2)))) = (X1 * (X2 + X2))))).+step(delete(rule(262, ((X1 + X1) * (X2 + (X2 + X2))) = ((X1 + (X1 + X1)) * (X2 + X2))))).+step(delete(rule(271, ((X1 + X1) * (X2 + X2)) = (X1 * ((X1 + X1) * ((X1 + X1) * X2)))))).+step(add(rule(405, (X1 * -(X2 + X2)) = (X1 * ((X1 + X1) * ((X1 + X1) * X2)))))).+step(delete(rule(272, ((X1 + X1) * ((X1 + X1) * (X2 + X2))) = (X1 * ((X1 + X1) * X2))))).+step(delete(rule(367, (X1 * ((X1 + X1) * -(X1 + X1))) = -(X1 + (X1 + (X1 + X1)))))).+step(delete(rule(368, ((X1 + X1) * (X1 + (X1 + X1))) = 0))).+step(delete(rule(370, ((X1 + X1) * -(X1 + (X1 + X1))) = 0))).+step(delete(rule(371, ((X1 + (X1 + X1)) * ((X1 + X1) * -X2)) = 0))).+step(delete(rule(372, ((X1 + (X1 + X1)) * -(X1 + (X1 + (X1 + X1)))) = 0))).+step(delete(rule(373, ((X1 + X1) * ((X1 + (X1 + X1)) * -X2)) = 0))).+step(delete(rule(375, ((X1 + (X1 + (X1 + X1))) * (X1 + (X1 + X1))) = 0))).+step(delete(rule(377, ((X1 + (X1 + X1)) * (X1 + (X1 + (X1 + X1)))) = 0))).+step(delete(rule(387, -(X1 + (X1 + (X1 + X1))) = (X1 + X1)))).+step(add(rule(406, ((X1 + (X1 + X1)) * -(X2 + X2)) = 0))).+step(add(rule(407, ((X1 + (X1 + X1)) * (X1 * -(X1 + X1))) = 0))).+step(add(rule(408, ((X1 + X1) * (X2 * (X3 + (X3 + X3)))) = 0))).+step(add(rule(409, ((X1 + X1) * ((X2 + (X2 + X2)) * X3)) = 0))).+step(add(rule(410, ((X1 + (X1 + X1)) * -X2) = ((X1 + (X1 + X1)) * X2)))).+step(add(rule(411, ((X1 + (X1 + X1)) * (X2 * -(X3 + X3))) = 0))).+step(add(rule(412, ((X1 + X1) * ((X1 + X1) * X2)) = (X1 * (X1 * -(X2 + X2)))))).+step(add(rule(413, (X1 * ((X1 + X1) * ((X1 + X1) * X2))) = ((X1 + X1) * -X2)))).+step(add(rule(414, (X1 + ((X2 + X2) * (X3 * X1))) = (X1 + (X2 * ((X3 + X3) * X1)))))).+step(add(rule(415, (X1 + (X2 * ((X3 + X3) * X4))) = ((X2 * (X3 * (X4 + X4))) + X1)))).+step(add(rule(416, (X1 + ((X2 + X2) * (X3 * X4))) = ((X2 * (X3 * (X4 + X4))) + X1)))).+step(add(rule(417, (X1 + ((X2 + X2) * (X3 * X4))) = ((X2 * ((X3 + X3) * X4)) + X1)))).+step(add(rule(418, (X1 + (X2 + ((X3 + X3) * X4))) = (X1 + ((X3 * (X4 + X4)) + X2))))).+step(add(rule(419, ((X1 + (X1 + X1)) * ((X2 + X2) * X3)) = 0))).+step(add(rule(420, ((X1 + (X1 + X1)) * (X2 * (X3 + X3))) = 0))).+step(add(rule(421, ((X1 * (X2 + X2)) + (X3 + X4)) = (X3 + (X4 + ((X1 + X1) * X2)))))).+step(add(rule(422, (X1 * (X2 * -(X3 + X3))) = ((X1 + X1) * ((X2 + X2) * X3))))).+step(add(rule(423, (X1 + (X1 + (X2 + (X1 + X1)))) = (X2 + -(X1 + X1))))).+step(add(rule(424, ((X1 + X1) * (X2 * (X3 + X3))) = (X1 * (X2 * -(X3 + X3)))))).+step(add(rule(425, (X1 + (X1 + (X1 + (X1 + X2)))) = (-(X1 + X1) + X2)))).+step(add(rule(426, (X1 * ((X2 * (X3 + X3)) + X4)) = (X1 * (X4 + ((X2 + X2) * X3)))))).+step(add(rule(427, (X1 + (X2 + ((X3 + X3) * X4))) = (X2 + ((X3 * (X4 + X4)) + X1))))).+step(add(rule(428, (X1 + (X2 + (X3 * (X4 + X4)))) = (X1 + (X2 + ((X3 + X3) * X4)))))).+step(add(rule(429, (X1 + (X2 * (X3 * (X4 + X4)))) = (X1 + (X2 * ((X3 + X3) * X4)))))).+step(add(rule(430, (X1 + (X2 * (X3 * (X4 + X4)))) = (X1 + ((X2 + X2) * (X3 * X4)))))).+step(hard((X1 + (X2 + ((X3 + X3) * X4))) = (X2 + (X1 + (X3 * (X4 + X4)))))).+step(add(rule(431, (X1 + ((X2 + X2) * (X3 * X4))) = (X1 + (X2 * ((X3 + X3) * X4)))))).+step(add(rule(432, (X1 + (X2 * (X3 * (X4 + X4)))) = ((X2 * ((X3 + X3) * X4)) + X1)))).+step(add(rule(433, (X1 + (X2 * (X3 * (X4 + X4)))) = (((X2 + X2) * (X3 * X4)) + X1)))).+step(add(rule(434, (X1 + (X2 + (X3 * (X4 + X4)))) = (X1 + (((X3 + X3) * X4) + X2))))).+step(add(rule(435, (((X1 + X1) * X2) + (X3 + X4)) = (X3 + (X4 + (X1 * (X2 + X2))))))).+step(add(rule(436, (X1 * (((X2 + X2) * X3) + X4)) = (X1 * (X4 + (X2 * (X3 + X3))))))).+step(add(rule(437, (((X1 + X1) * (X2 * X3)) + X4) = (X4 + (X1 * ((X2 + X2) * X3)))))).+step(add(rule(438, (X1 + (X2 + (X3 * (X4 + X4)))) = (X2 + (((X3 + X3) * X4) + X1))))).+step(add(rule(439, ((X1 * (X2 + X2)) + ((-X1 + X3) * X2)) = ((X1 + X3) * X2)))).+step(hard(((X1 + (X4 + X2)) * X3) = ((X1 + (X2 + X4)) * X3))).+step(hard(((X1 + X2) * X3) = ((-X1 + (X2 + (X1 + X1))) * X3))).+step(add(rule(440, ((X1 * (X2 + X2)) + ((X3 + -X1) * X2)) = ((X1 + X3) * X2)))).+step(add(rule(441, ((X1 + (X1 + X1)) * (X2 * X3)) = (X1 * ((X2 + (X2 + X2)) * X3))))).+step(add(rule(442, ((X1 + (X1 * (X2 * (X2 + X2)))) * (X2 + X2)) = 0))).+step(add(rule(443, (X1 * (X2 * (X3 + (X3 + X3)))) = (X1 * ((X2 + (X2 + X2)) * X3))))).+step(add(rule(444, (X1 * (X2 * (X3 + (X3 + X3)))) = ((X1 + (X1 + X1)) * (X2 * X3))))).+step(add(rule(445, ((X1 + X1) * (X2 + (X1 * ((X1 + X1) * X2)))) = 0))).+step(add(rule(446, (((X1 + X1) * X2) + (X1 * (-X2 + X3))) = (X1 * (X2 + X3))))).+step(hard((X1 * (X2 * (X4 + X3))) = (X1 * (X2 * (X3 + X4))))).+step(hard((X1 * (X2 + X3)) = (X1 * (-X2 + (X3 + (X2 + X2)))))).+step(add(rule(447, (X1 * (X2 + (X2 * (X1 * X1)))) = ((X1 + X1) * X2)))).+step(hard((X1 * (X1 * -(X1 + X2))) = (X1 * (X1 * -(X2 + X1))))).+step(add(rule(448, (((X1 + X1) * X2) + (X1 * (X3 + -X2))) = (X1 * (X2 + X3))))).+step(add(rule(449, ((X1 + ((X2 + X2) * X3)) * X4) = (((X2 * (X3 + X3)) + X1) * X4)))).+step(add(rule(450, ((X1 + (X2 * (X3 + X3))) * X4) = ((((X2 + X2) * X3) + X1) * X4)))).+step(hard((X1 * (X3 + (X1 * (-X2 + (X1 + X2))))) = (X1 + (X1 * X3)))).+step(add(rule(451, ((X1 + (((X1 * -X2) + X3) * X2)) * X2) = (X3 * (X2 * X2))))).+step(hard((X1 * X2) = ((-X2 + (X1 + X2)) * X2))).+step(add(rule(452, (X1 * (X1 * (X2 * X1))) = (X2 * X1)))).+step(add(rule(453, ((X1 + ((X2 + (X1 * -X3)) * X3)) * X3) = (X2 * (X3 * X3))))).+step(add(rule(454, (X1 * (X1 * (X1 + (X2 * X1)))) = (X1 + (X2 * X1))))).+step(hard((((X1 * (X1 + X2)) + X3) * X1) = (((X1 * (X2 + X1)) + X3) * X1))).+step(hard((X1 + (X2 * ((X3 + X4) * X1))) = (X1 + (X2 * ((X4 + X3) * X1))))).+step(add(rule(455, (X1 * (X3 + (X1 * (X2 * X3)))) = (X1 * (X1 * ((X2 + X1) * X3)))))).+step(hard((X1 + (X2 + (X3 + (X4 + X5)))) = (X3 + (X5 + (X4 + (X1 + X2)))))).+step(interreduce).+step(delete(rule(112, ((X1 + (X1 + X1)) * (X1 * X1)) = (X1 + (X1 + X1))))).+step(delete(rule(209, (X1 + (X1 * ((X2 + X2) * X3))) = (X1 + (X1 * (X2 * (X3 + X3))))))).+step(delete(rule(323, (X1 + (X2 * (X3 * (X1 + X1)))) = (X1 + ((X2 + X2) * (X3 * X1)))))).+step(delete(rule(325, (X1 + (X2 * (X3 * (X1 + X1)))) = (X1 + (X2 * ((X3 + X3) * X1)))))).+step(delete(rule(369, ((X1 + (X1 + X1)) * -(X1 + X1)) = 0))).+step(delete(rule(374, ((X1 + X1) * ((X1 + (X1 + X1)) * X2)) = 0))).+step(delete(rule(376, ((X1 + (X1 + X1)) * ((X1 + X1) * X2)) = 0))).+step(delete(rule(378, ((X1 + X1) * (X2 * (X1 + (X1 + X1)))) = 0))).+step(delete(rule(379, ((X1 + (X1 + X1)) * (X2 * (X1 + X1))) = 0))).+step(delete(rule(404, ((X1 + (X1 + X1)) * -X2) = (X1 * (X2 + (X2 + X2)))))).+step(delete(rule(405, (X1 * -(X2 + X2)) = (X1 * ((X1 + X1) * ((X1 + X1) * X2)))))).+step(delete(rule(406, ((X1 + (X1 + X1)) * -(X2 + X2)) = 0))).+step(delete(rule(407, ((X1 + (X1 + X1)) * (X1 * -(X1 + X1))) = 0))).+step(delete(rule(412, ((X1 + X1) * ((X1 + X1) * X2)) = (X1 * (X1 * -(X2 + X2)))))).+step(delete(rule(414, (X1 + ((X2 + X2) * (X3 * X1))) = (X1 + (X2 * ((X3 + X3) * X1)))))).+step(delete(rule(423, (X1 + (X1 + (X2 + (X1 + X1)))) = (X2 + -(X1 + X1))))).+step(hard((X1 + (X2 + (X3 + (X4 + X5)))) = (X2 + (X4 + (X5 + (X3 + X1)))))).+step(hard((X1 + (X2 + (X3 + (X4 + X5)))) = (X3 + (X4 + (X5 + (X1 + X2)))))).+step(add(rule(456, ((X1 + X1) * ((X1 * (X1 + X1)) + X2)) = (-(X1 + X1) + ((X1 + X1) * X2))))).+step(hard((X1 * ((X2 + (X4 + X4)) * X3)) = (X1 * ((X4 + (X4 + X2)) * X3)))).+step(hard((X1 * (X2 * (X3 + (X4 + X4)))) = (X1 * (X2 * (X4 + (X4 + X3)))))).+step(hard((X1 + ((X1 * (X1 * X2)) + X3)) = (X3 + (X1 * (X1 * (X1 + X2)))))).+step(add(rule(457, ((X1 * (X1 * (X2 + X1))) + X3) = (X1 + ((X1 * (X1 * X2)) + X3))))).+step(add(rule(458, (X1 + (X2 + (X1 * (X1 * X3)))) = (X2 + (X1 * (X1 * (X3 + X1))))))).+step(hard((X1 + -(X2 + X2)) = (X2 + (X1 + (X2 + (X2 + X2)))))).+step(hard((X1 + (X1 + (X2 + (X1 + X1)))) = (X2 + -(X1 + X1)))).+step(hard((X1 * (X2 + (X1 * (X3 + X1)))) = (X1 * (X2 + (X1 * (X1 + X3)))))).+step(hard((X1 + (X1 * ((X1 + X1) * X2))) = (X1 * (X1 * (X2 + (X1 + X2)))))).+step(hard((X1 + ((X1 * (X2 * X1)) + X3)) = (X3 + (X1 * ((X1 + X2) * X1))))).+step(add(rule(459, ((X1 * ((X2 + X1) * X1)) + X3) = (X1 + ((X1 * (X2 * X1)) + X3))))).+step(add(rule(460, (X1 + (X2 + (X1 * (X3 * X1)))) = (X2 + (X1 * ((X3 + X1) * X1)))))).+step(hard((X1 * (X2 + ((X3 + X1) * X1))) = (X1 * (X2 + ((X1 + X3) * X1))))).+step(hard((X1 + (X1 * (X2 * (X1 + X1)))) = (X1 * ((X2 + (X1 + X2)) * X1)))).+step(add(rule(461, ((X4 * -X2) + (X3 + ((X1 + X4) * X2))) = ((X1 * X2) + X3)))).+step(hard(((X1 + X3) * X2) = ((-X4 + (X3 + (X1 + X4))) * X2))).+step(hard(((X1 * X2) + X3) = (-X2 + (X3 + (X2 + (X1 * X2)))))).+step(hard(((X1 * X2) + X3) = (X3 + ((-X5 + (X1 + X5)) * X2)))).+step(hard(((-X3 + X1) * X2) = ((-(X4 + X3) + (X1 + X4)) * X2))).+step(add(rule(462, (X1 + (((X2 + X2) * X3) + X4)) = ((X2 * (X3 + X3)) + (X4 + X1))))).+step(hard(((X1 * (X2 + X2)) + (X3 + X4)) = (((X1 + X1) * X2) + (X4 + X3)))).+step(hard((((X1 * (X1 + X2)) + X3) * X1) = ((X3 + (X1 * (X2 + X1))) * X1))).+step(hard(((((X1 + X2) * X1) + X3) * X1) = ((X3 + ((X2 + X1) * X1)) * X1))).+step(add(rule(463, (X1 * (X1 * ((X1 + X2) * X2))) = (X1 * ((X2 + X1) * (X2 * X2)))))).+step(add(rule(464, (X1 * ((X1 + X2) * (X1 * X2))) = (X1 * (X2 * ((X2 + X1) * X2)))))).+step(add(rule(465, ((X1 + (X1 * (X2 * X3))) * X2) = (X1 * (X2 * ((X2 + X3) * X2)))))).+step(add(rule(466, (X1 * (X2 + (X3 * (X2 + X2)))) = (X1 * ((X3 + (X1 * (X1 + (X1 * X3)))) * X2))))).+step(add(rule(467, (X1 * ((X2 + X1) * (X1 * X2))) = (X1 * (X2 * ((X2 + X1) * X2)))))).+step(hard(((X1 * X2) + ((X3 + X1) * X4)) = ((X1 * (X4 + X2)) + (X3 * X4)))).+step(add(rule(468, ((X1 * X2) + ((X3 + X1) * X4)) = ((X3 * X4) + (X1 * (X2 + X4)))))).+step(interreduce).+step(delete(rule(235, ((X1 * X2) + (X3 * (X4 + X2))) = (((X3 + X1) * X2) + (X3 * X4))))).+step(delete(rule(256, ((X1 * (X2 + X3)) + (X4 * X3)) = ((X1 * X2) + ((X4 + X1) * X3))))).+step(delete(rule(258, (((X1 + X2) * X3) + (X2 * X4)) = ((X1 * X3) + (X2 * (X4 + X3)))))).+step(hard((X1 * ((X2 + (X4 + X4)) * X3)) = (X1 * ((X4 + (X2 + X4)) * X3)))).+step(add(rule(469, ((X1 * X2) + (X3 * (X2 + X4))) = ((X3 * X4) + ((X3 + X1) * X2))))).+step(hard((X1 * (X1 * (X2 + (X3 + X1)))) = (X1 * (X1 * (X1 + (X2 + X3)))))).+step(add(rule(470, (X1 * (X2 + (X1 * (X2 + X1)))) = (X1 + ((X1 + (X1 * X1)) * X2))))).+step(hard((X1 * ((X2 + (X3 + X1)) * X1)) = (X1 * ((X1 + (X2 + X3)) * X1)))).+step(add(rule(471, ((X1 + (X2 + (X2 * X2))) * (X2 * X2)) = ((X2 + ((X1 + X2) * X2)) * X2)))).+step(hard(((X1 * X2) + (X3 * (X4 + X2))) = (((X3 + X1) * X2) + (X3 * X4)))).+step(hard((X1 * (X2 * (X3 + (X4 + X4)))) = (X1 * (X2 * (X4 + (X3 + X4)))))).+step(hard(((X1 * (X2 * X2)) + (X3 + X2)) = (X3 + ((X1 + X2) * (X2 * X2))))).+step(hard(((X1 * (X2 * X1)) + (X3 + X1)) = (X3 + (X1 * ((X1 + X2) * X1))))).+step(add(rule(472, ((X1 + ((X1 + X2) * X2)) * X2) = (X2 + (X1 * (X2 + (X2 * X2))))))).+step(add(rule(473, (X1 * (X1 * (X1 + (X1 + (X1 * (X2 + X2)))))) = ((X1 + X1) * (X2 + (X1 * X1)))))).+step(add(rule(474, (X1 * ((X1 + X2) * (X2 * X2))) = (X1 * (X1 * ((X1 + X2) * X2)))))).+step(hard(((X1 * (X2 + X3)) + (X4 * X2)) = (((X1 + X4) * X2) + (X1 * X3)))).+step(add(rule(475, ((X1 + (X1 * X1)) * (X1 + X1)) = ((X1 + X1) * (X1 + (X1 * X1)))))).+step(hard((X1 + (X2 + (X3 + (X4 + X5)))) = (X2 + (X3 + (X5 + (X4 + X1)))))).+step(hard((X3 + (X4 + (X5 + (X6 + X2)))) = (X3 + (X5 + (X6 + (X4 + X2)))))).+step(hard((X3 + (X4 + (X5 + (X6 + X2)))) = (X3 + (X4 + (X6 + (X5 + X2)))))).+step(add(rule(476, (X1 + (X1 + ((X2 + X2) * X1))) = ((X2 + (X1 * X1)) * (X1 + X1))))).+step(hard(((X1 * (X2 + (X2 + X3))) + X4) = ((X1 * (X3 + (X2 + X2))) + X4))).+step(hard((((X1 + X1) * X2) + (X3 + X4)) = (X4 + (X3 + (X1 * (X2 + X2)))))).+step(add(rule(477, (X1 + ((X2 * (X3 + X3)) + X4)) = (X4 + (((X2 + X2) * X3) + X1))))).+step(add(rule(478, (((X1 + (X1 + X1)) * X2) + X3) = (X3 + (X1 * (X2 + (X2 + X2))))))).+step(add(rule(479, (X1 + (X2 * (X3 + (X3 + X3)))) = (X1 + ((X2 + (X2 + X2)) * X3))))).+step(add(rule(480, ((X1 * (X2 + (X2 + X2))) + X3) = (X3 + ((X1 + (X1 + X1)) * X2))))).+step(hard(((X1 * (X2 + (X3 + X3))) + X4) = (X4 + (X1 * (X3 + (X3 + X2)))))).+step(add(rule(481, ((X1 * (X2 + (X3 * X2))) + X4) = (X4 + ((X1 + (X1 * X3)) * X2))))).+step(add(rule(482, (((X1 + (X1 * X2)) * X3) + X4) = (X4 + (X1 * (X3 + (X2 * X3))))))).+step(hard((((X1 + (X1 + X2)) * X3) + X4) = (((X2 + (X1 + X1)) * X3) + X4))).+step(hard((((X1 + (X2 + X2)) * X3) + X4) = (X4 + ((X2 + (X2 + X1)) * X3)))).+step(hard(((X3 + (X1 * (X4 + X2))) * X5) = ((X3 + (X1 * (X2 + X4))) * X5))).+step(hard(((X1 + (X1 + (X2 + X3))) * X4) = ((X2 + (X1 + (X1 + X3))) * X4))).+step(hard((((X1 * (X2 + X3)) + X4) * X5) = (((X1 * (X3 + X2)) + X4) * X5))).+step(add(rule(483, ((X1 + (X1 * X2)) * (X1 + X1)) = ((X1 + X1) * (X1 + (X2 * X1)))))).+step(add(rule(484, ((X1 + (X1 * X3)) * (X2 + X2)) = ((X1 + X1) * (X2 + (X3 * X2)))))).+step(add(rule(485, ((X1 + (X2 + (X3 * X3))) * (X3 * X3)) = ((X3 + ((X1 + X2) * X3)) * X3)))).+step(hard((X1 + (X1 * (X3 + (X4 + X2)))) = (X1 + (X1 * (X4 + (X3 + X2)))))).+step(hard((X1 * (X1 * (X3 + (X1 + X2)))) = (X1 * (X1 * (X1 + (X3 + X2)))))).+step(hard((X1 * ((X3 + (X1 + X2)) * X1)) = (X1 * ((X1 + (X3 + X2)) * X1)))).+step(hard((X1 * (((X2 + X1) * X1) + X3)) = (X1 * (((X1 + X2) * X1) + X3)))).+step(hard((X1 + (X4 + ((X5 + X2) * X3))) = (X4 + (((X2 + X5) * X3) + X1)))).+step(add(rule(486, ((X1 + X1) * (X2 + (X1 * (X1 + (X1 + X1))))) = ((X1 + X1) * X2)))).+step(interreduce).+step(delete(rule(252, ((X1 + (X2 + (X1 * X1))) * (X1 * X1)) = ((X1 + ((X2 + X1) * X1)) * X1)))).+step(delete(rule(313, ((X1 + (X1 * (X2 * -X2))) * (X2 + X2)) = 0))).+step(delete(rule(442, ((X1 + (X1 * (X2 * (X2 + X2)))) * (X2 + X2)) = 0))).+step(delete(rule(471, ((X1 + (X2 + (X2 * X2))) * (X2 * X2)) = ((X2 + ((X1 + X2) * X2)) * X2)))).+step(delete(rule(475, ((X1 + (X1 * X1)) * (X1 + X1)) = ((X1 + X1) * (X1 + (X1 * X1)))))).+step(delete(rule(483, ((X1 + (X1 * X2)) * (X1 + X1)) = ((X1 + X1) * (X1 + (X2 * X1)))))).+step(add(rule(487, ((X1 + X1) * (X2 * (X3 * (X1 + (X1 + X1))))) = 0))).+step(add(rule(488, (((X1 * (X1 + (X1 + X1))) + X2) * (X1 + X1)) = (X2 * (X1 + X1))))).+step(add(rule(489, ((X2 + (X1 * (X1 + (X1 + X1)))) * (X1 + X1)) = (X2 * (X1 + X1))))).+step(add(rule(490, (X1 * (X2 + X2)) = ((X1 + X1) * (? + (? + (? + X2))))))).+step(add(rule(491, ((X1 + X1) * (X3 + (X3 + (X3 + X2)))) = ((X1 + X1) * (? + (? + (? + X2))))))).+step(add(rule(492, (X1 * (X2 + X2)) = ((X1 + X1) * (X2 + (? + (? + ?))))))).+step(add(rule(493, ((X1 + X1) * (X2 + (X3 + (X3 + X3)))) = ((X1 + X1) * (X2 + (? + (? + ?))))))).+step(hard((X2 + ((X1 + (X3 + X4)) * X2)) = (X2 + ((X4 + (X3 + X1)) * X2)))).+step(hard(((X2 + X3) * ((X1 + X1) * X4)) = ((X3 + X2) * (X1 * (X4 + X4))))).+step(hard((X1 * ((X3 + X4) * (X2 + X2))) = ((X1 + X1) * ((X4 + X3) * X2)))).+step(hard((X3 + ((X4 + (X5 + X2)) * X3)) = (X3 + ((X5 + (X4 + X2)) * X3)))).+step(add(rule(494, ((X1 + ((X1 * (X2 * -X2)) + X3)) * X2) = (X3 * X2)))).+step(add(rule(495, ((X1 + (-X2 + X3)) * X4) = ((X3 + (-X2 + X1)) * X4)))).+step(hard(((X1 + (X2 + X3)) * X4) = ((X3 + (X2 + X1)) * X4))).+step(add(rule(496, ((X1 + (X2 + (X1 * (X3 * -X3)))) * X3) = (X2 * X3)))).+step(hard((X1 + X2) = (-X4 + (X2 + (X1 + X4))))).+step(hard((X1 + X2) = (-X5 + (X2 + (X1 + X5))))).+step(add(rule(497, ((X1 + (X2 + (X2 * (X3 * -X3)))) * X3) = (X1 * X3)))).+step(add(rule(498, (X1 * (X2 + (X2 * (X1 * (X2 * (X1 * -X2)))))) = 0))).+step(add(rule(499, (X1 * (X2 + ((X2 * (X1 * -X1)) + X3))) = (X1 * X3)))).+step(add(rule(500, (X1 * (X2 * (X1 * X1))) = (X1 * X2)))).+step(add(rule(501, (X1 * (X2 * (X1 * -X1))) = (X1 * -X2)))).+step(add(rule(502, (X1 * ((X2 * (X1 * X1)) + X3)) = (X1 * (X2 + X3))))).+step(add(rule(503, (X1 * (X2 + (X3 * (X1 * X1)))) = (X1 * (X3 + X2))))).+step(add(rule(504, (X1 * (X2 * (X1 * (X1 + X1)))) = (X1 * (X2 + X2))))).+step(add(rule(505, (X1 * (X2 * (X1 * X2))) = (X1 * (X2 * (X2 * X1)))))).+step(add(rule(506, (X1 * (X2 + (-X3 + X4))) = (X1 * (X4 + (-X3 + X2)))))).+step(hard((X1 * (X2 + (X3 + X4))) = (X1 * (X4 + (X3 + X2))))).+step(add(rule(507, (X1 * (X2 + (X3 + (X3 * (X1 * -X1))))) = (X1 * X2)))).+step(add(rule(508, (X1 * (-X2 + (X1 * ((X1 + X1) * X2)))) = (X1 * X2)))).+step(add(rule(509, ((-X1 + (X1 * (X2 * (X2 + X2)))) * X2) = (X1 * X2)))).+step(add(rule(510, ((X5 * -X4) + (X2 + (X1 + (X5 * X4)))) = (X1 + X2)))).+step(hard((X1 + X2) = (-(X3 + X3) + (X2 + (X1 + (X3 + X3)))))).+step(add(rule(511, (X1 * (X1 * (X2 * -X1))) = (X2 * -X1)))).+step(add(rule(512, (X3 * (X2 * X2)) = (X2 * (X2 * X3))))).+step(hard(((X1 + X1) * (X2 + X1)) = (X1 * (X1 + (X2 + (X1 + X2)))))).+step(hard((-X1 + (X2 + (X1 + (X3 + X4)))) = (X3 + (X4 + X2)))).+step(hard((X1 + (X2 * X3)) = (X1 + ((-X4 + (X2 + X4)) * X3)))).+step(hard((-X1 + (X2 + (X3 + (X1 + X4)))) = (X3 + (X2 + X4)))).+step(hard((-X1 + (X2 + (X3 + (X4 + X1)))) = (X4 + (X2 + X3)))).+step(hard((X1 + (X2 + X3)) = (-X4 + (X2 + (X1 + (X4 + X3)))))).+step(hard((-X1 + (X4 + (X1 + (X3 + X5)))) = (X4 + (X5 + X3)))).+step(hard((X1 + (X2 + X3)) = (-X4 + (X2 + (X3 + (X1 + X4)))))).+step(hard((X1 + (X2 + (-X5 + (X4 + X5)))) = (X4 + (X1 + X2)))).+step(hard(((X1 * X2) + X3) = (X3 + ((-X6 + (X1 + X6)) * X2)))).+step(hard(((X1 + X3) * X2) = ((-X4 + (X3 + (X4 + X1))) * X2))).+step(add(rule(513, (-? + (((X2 + X2) * X3) + ?)) = (X2 * (X3 + X3))))).+step(add(rule(514, (-X1 + (((X2 + X2) * X3) + X1)) = (-? + (((X2 + X2) * X3) + ?))))).+step(add(rule(515, ((X1 + (X2 * (X2 * X1))) * X2) = (X1 * (X2 + X2))))).+step(hard((X1 * (X2 * X2)) = (X2 * (X2 * (-X2 + (X1 + X2)))))).+step(add(rule(516, ((X2 + (X1 * (X1 + (X1 * -X2)))) * X1) = X1))).+step(interreduce).+step(delete(rule(30, (X1 + (X2 * (X1 * X1))) = ((X1 + X2) * (X1 * X1))))).+step(add(rule(517, (X1 + (X2 * (X1 * X1))) = (X1 * (X1 * (X1 + X2)))))).+step(delete(rule(108, ((X1 + (X2 * X3)) * (X3 * X3)) = (((X1 * X3) + X2) * X3)))).+step(add(rule(518, (X3 * (X3 * (X1 + (X2 * X3)))) = (((X1 * X3) + X2) * X3)))).+step(delete(rule(127, (((X1 + X2) * (X1 * X1)) + X3) = (X1 + ((X2 * (X1 * X1)) + X3))))).+step(delete(rule(128, (X1 + (X2 * (X3 * (X1 * X1)))) = ((X1 + (X2 * X3)) * (X1 * X1))))).+step(add(rule(519, (X1 + (X2 * (X3 * (X1 * X1)))) = (X1 * (X1 * (X1 + (X2 * X3))))))).+step(delete(rule(129, (X1 + (X2 + (X3 * (X1 * X1)))) = (X2 + ((X1 + X3) * (X1 * X1)))))).+step(delete(rule(131, ((X1 + (X2 + X2)) * (X1 * X1)) = (X1 + (X2 * (X1 * (X1 + X1))))))).+step(add(rule(520, (X1 * (X1 * (X1 + (X2 + X2)))) = (X1 + (X2 * (X1 * (X1 + X1))))))).+step(delete(rule(136, (((X1 + X2) * (X2 * X2)) + X3) = (X2 + ((X1 * (X2 * X2)) + X3))))).+step(delete(rule(138, (((X1 * X2) + X3) * (X2 * X2)) = ((X1 + (X3 * X2)) * X2)))).+step(add(rule(521, (X2 * (X2 * ((X1 * X2) + X3))) = ((X1 + (X3 * X2)) * X2)))).+step(delete(rule(238, (X1 + ((X2 + X3) * (X3 * X3))) = (X3 + (X1 + (X2 * (X3 * X3))))))).+step(add(rule(522, (X1 + (X3 * (X3 * (X2 + X3)))) = (X3 + (X1 + (X2 * (X3 * X3))))))).+step(delete(rule(239, (X1 + ((X2 + X3) * (X2 * X2))) = ((X3 * (X2 * X2)) + (X1 + X2))))).+step(add(rule(523, (X1 + (X2 * (X2 * (X2 + X3)))) = ((X3 * (X2 * X2)) + (X1 + X2))))).+step(delete(rule(250, ((X1 + ((X1 * X1) + X2)) * (X1 * X1)) = ((X1 + ((X2 + X1) * X1)) * X1)))).+step(add(rule(524, ((X1 + ((X2 + X1) * X1)) * X1) = (X1 * (X1 + (X1 * (X2 + X1))))))).+step(delete(rule(251, ((X1 + (X1 * (X2 * X3))) * X3) = (X1 * ((X2 + X3) * (X3 * X3)))))).+step(add(rule(525, ((X1 + (X1 * (X2 * X3))) * X3) = (X1 * (X3 * (X3 * (X2 + X3))))))).+step(delete(rule(259, ((X1 + (X1 * (X2 * X3))) * X3) = (X1 * ((X3 + X2) * (X3 * X3)))))).+step(add(rule(526, ((X1 + (X1 * (X2 * X3))) * X3) = (X1 * (X3 * (X3 * (X3 + X2))))))).+step(delete(rule(334, (X2 + (X1 * (X2 * -X2))) = ((-X1 + X2) * (X2 * X2))))).+step(add(rule(527, (X2 + (X1 * (X2 * -X2))) = (X2 * (X2 * (-X1 + X2)))))).+step(delete(rule(346, (-X1 + (X2 * (X1 * X1))) = ((-X1 + X2) * (X1 * X1))))).+step(add(rule(528, (-X1 + (X2 * (X1 * X1))) = (X1 * (X1 * (-X1 + X2)))))).+step(delete(rule(356, ((X1 + (X2 * (X3 * X1))) * (X1 * X1)) = (X1 + (X2 * (X3 * X1)))))).+step(add(rule(529, (X1 * (X1 * (X1 + (X2 * (X3 * X1))))) = (X1 + (X2 * (X3 * X1)))))).+step(delete(rule(359, ((-X1 + X2) * (X1 * -X1)) = ((-X2 + X1) * (X1 * X1))))).+step(add(rule(530, ((-X1 + X2) * (X1 * -X1)) = (X1 * (X1 * (-X2 + X1)))))).+step(delete(rule(447, (X1 * (X2 + (X2 * (X1 * X1)))) = ((X1 + X1) * X2)))).+step(delete(rule(454, (X1 * (X1 * (X1 + (X2 * X1)))) = (X1 + (X2 * X1))))).+step(delete(rule(458, (X1 + (X2 + (X1 * (X1 * X3)))) = (X2 + (X1 * (X1 * (X3 + X1))))))).+step(delete(rule(463, (X1 * (X1 * ((X1 + X2) * X2))) = (X1 * ((X2 + X1) * (X2 * X2)))))).+step(add(rule(531, (X1 * (X1 * ((X1 + X2) * X2))) = (X1 * (X2 * (X2 * (X2 + X1))))))).+step(delete(rule(474, (X1 * ((X1 + X2) * (X2 * X2))) = (X1 * (X1 * ((X1 + X2) * X2)))))).+step(add(rule(532, (X1 * (X2 * (X2 * (X1 + X2)))) = (X1 * (X1 * ((X1 + X2) * X2)))))).+step(delete(rule(485, ((X1 + (X2 + (X3 * X3))) * (X3 * X3)) = ((X3 + ((X1 + X2) * X3)) * X3)))).+step(add(rule(533, ((X3 + ((X1 + X2) * X3)) * X3) = (X3 * (X3 + (X3 * (X1 + X2))))))).+step(delete(rule(492, (X1 * (X2 + X2)) = ((X1 + X1) * (X2 + (? + (? + ?))))))).+step(delete(rule(493, ((X1 + X1) * (X2 + (X3 + (X3 + X3)))) = ((X1 + X1) * (X2 + (? + (? + ?))))))).+step(add(rule(534, ((X1 + X1) * (X2 + (X3 + (X3 + X3)))) = ((X1 + X1) * (? + (? + (? + X2))))))).+step(delete(rule(513, (-? + (((X2 + X2) * X3) + ?)) = (X2 * (X3 + X3))))).+step(delete(rule(514, (-X1 + (((X2 + X2) * X3) + X1)) = (-? + (((X2 + X2) * X3) + ?))))).+step(add(rule(535, (-X1 + (((X2 + X2) * X3) + X1)) = ((X2 + X2) * X3)))).+step(simplify_queue).+step(add(rule(536, (X1 * ((X1 + (X2 * X1)) * X1)) = (X1 + (X1 * X2))))).+step(add(rule(537, ((X2 + (X1 * X2)) * X2) = (X2 * (X2 + (X2 * X1)))))).+step(add(rule(538, (X1 * (X2 * (X3 * X3))) = (X3 * (X3 * (X1 * X2)))))).+step(add(rule(539, (X1 * (X2 * (X2 + X2))) = (X2 * (X2 * (X1 + X1)))))).+step(hard((X1 * X2) = (X1 * (-X1 + (X2 + X1))))).+step(add(rule(540, (X1 * (X2 * -X2)) = (X2 * (X2 * -X1))))).+step(add(rule(541, ((X1 + X1) * X2) = (X2 * (X2 * (X1 * (X2 + X2))))))).+step(add(rule(542, (X1 * (X1 * (X2 * X3))) = (X2 * (X1 * (X1 * X3)))))).+step(add(rule(543, (X2 * X1) = (X1 * X2)))).++lemma((X1 + 0) = X1).+lemma((X1 + (-X1 + X2)) = X2).+lemma(-(-X1) = X1).+lemma((X2 + (X1 + -X2)) = X1).+lemma((X1 * (X1 * (X1 * X2))) = (X1 * X2)).+lemma((X1 + (X2 + -(X1 + X2))) = 0).+lemma((X1 * ((X1 * X1) + X2)) = (X1 + (X1 * X2))).+lemma((X1 * 0) = 0).+lemma((-X1 * -(-X1 * -X1)) = X1).+lemma((X1 + (X1 * (X1 * X2))) = (X1 * (X1 * (X1 + X2)))).+lemma((0 * X1) = 0).+lemma(((X1 * (X2 * X4)) + (X3 * X4)) = (((X1 * X2) + X3) * X4)).+lemma(((X1 * X4) + (X2 * (X3 * X4))) = ((X1 + (X2 * X3)) * X4)).+lemma((X1 * (X2 * (X1 * (X2 * (X1 * X2))))) = (X1 * X2)).+lemma(-(X1 * X2) = (X1 * -X2)).+lemma((-X1 * X2) = (X1 * -X2)).+lemma(((X1 + (X1 * (X2 * -X2))) * (X2 * X3)) = 0).+lemma(((X1 + (((X1 * -X2) + X3) * X2)) * X2) = (X3 * (X2 * X2))).+lemma((X1 * (X1 * (X2 * X1))) = (X2 * X1)).+lemma((X1 * (X2 * (X1 * X1))) = (X1 * X2)).+lemma((X1 * (X2 * (X3 * X3))) = (X3 * (X3 * (X1 * X2)))).
+ misc/test.hs view
@@ -0,0 +1,161 @@+{-# LANGUAGE TemplateHaskell, FlexibleInstances, FlexibleContexts, UndecidableInstances, StandaloneDeriving, ScopedTypeVariables, TupleSections, DeriveGeneric #-}+import Twee.Constraints+import Twee.Term hiding (subst, canonicalise, F)+import Twee.Term.Core hiding (F)+import Test.QuickCheck hiding (Function, Fun)+import Test.QuickCheck.All+import Twee.Pretty+import Twee.CP+import Twee.Proof+import qualified Twee.KBO as Ord+import Text.PrettyPrint+import Twee.Base hiding (F)+import Twee.Rule+import Twee.Equation+import Control.Monad+import qualified Data.Map as Map+import Data.Maybe+import Data.Ord+import Data.List+import Data.Typeable+import qualified Twee.Index as Index+import Data.Int+import GHC.Generics++newtype Func = F Int deriving (Eq, Ord, Show)++instance Pretty Func where pPrint (F f) = text "f" <> int f+instance PrettyTerm Func+instance Arbitrary (Subst Func) where+  arbitrary = fmap fromJust (fmap listToSubst (liftM2 zip (fmap nub arbitrary) (infiniteListOf arbitrary)))+instance Arbitrary Func where+  arbitrary = F <$> choose (1, 1)+instance Minimal Func where+  minimal = fun (F 0)+instance Sized Func where size _ = 1+instance Arity Func where+  arity (F 0) = 0+  arity (F 1) = 2+instance Skolem Func+instance EqualsBonus Func++instance Arbitrary Var where arbitrary = fmap V (choose (0, 3))+instance (Ord f, Typeable f, Arbitrary f) => Arbitrary (Fun f) where+  arbitrary = fmap fun arbitrary++instance (Ord f, Typeable f, Arbitrary f, Sized f, Arity f) => Arbitrary (Term f) where+  arbitrary =+    sized $ \n ->+      oneof $+        [ build <$> var <$> arbitrary ] +++        [ do { f <- arbitrary; build <$> app f <$> vectorOf (arity f) (resize ((n-1) `div` arity f) arbitrary :: Gen (Term f)) } | n > 0 ]+  shrink (App f ts0) =+    ts ++ (build <$> app f <$> shrinkOne ts)+    where+      ts = unpack ts0+      shrinkOne [] = []+      shrinkOne (x:xs) =+        [ y:xs | y <- shrink x ] +++        [ x:ys | ys <- shrinkOne xs ]+  shrink _ = []++data Pair f = Pair (Term f) (Term f) deriving Show++instance (Ord f, Typeable f, Arbitrary f, Arity f, Sized f) => Arbitrary (Pair f) where+  arbitrary = liftM2 Pair arbitrary arbitrary+  shrink (Pair x y) =+    [ Pair x' y  | x' <- shrink x ] +++    [ Pair x y'  | y' <- shrink y ] +++    [ Pair x' y' | x' <- shrink x, y' <- shrink y ]++instance Ordered Func where+  lessIn = Ord.lessIn+  lessEq = Ord.lessEq++instance Function f => Arbitrary (Model f) where+  arbitrary = fmap (modelFromOrder . map Variable . nub) arbitrary+  shrink = weakenModel++prop_1 :: Model Func -> Pair Func -> Subst Func -> Property+prop_1 model (Pair t u) sub =+  counterexample ("Model: " ++ prettyShow model) $+  counterexample ("Subst: " ++ prettyShow sub) $+  conjoin $ do+    let cp = CriticalPair (t :=: u) 0 Nothing (axiom (Axiom 0 "dummy" (t :=: u)))+    r@(Rule _ t' u') <- map orient (map cp_eqn (split cp))+    return $+      counterexample ("LHS:   " ++ prettyShow t') $+      counterexample ("RHS:   " ++ prettyShow u') $+      counterexample ("Rule:  " ++ prettyShow r) $+      counterexample ("Inst:  " ++ prettyShow (Rule Oriented (subst sub t') (subst sub u'))) $+      counterexample ("Res:   " ++ show (lessIn model (subst sub u') (subst sub t'))) $+      not (reducesInModel model r sub) || isJust (lessIn model (subst sub u') (subst sub t'))++prop_2 :: Model Func -> Pair Func -> Bool+prop_2 model (Pair t u) =+  not (lessIn model t u == Just Strict && isJust (lessIn model u t))++prop_3 :: Pair Func -> Bool+prop_3 (Pair t u) =+  not (lessThan t u && lessEq u t)++prop_4 :: Pair Func -> Property+prop_4 (Pair t u) =+  t /= u ==> +  not (lessEq t u && lessEq u t)++prop_5 :: Term Func -> Property+prop_5 t =+  lessEq t t .&&. not (lessThan t t)++prop_paths :: Term Func -> Property+prop_paths t =+  forAllShrink (choose (0, len t-1)) shrink $ \n ->+    counterexample (show (positionToPath t n)) $+    pathToPosition t (positionToPath t n) === n++deriving instance Ord f => Ord (Subst f)++prop_index :: [Term Func] -> Term Func -> Property+prop_index ts u =+  counterexample (show ts) $+  counterexample (show idx) $+  sort (catMaybes [fmap (,t) (match t u) | t <- ts]) ===+  sort (Index.matches u idx)+  where+    idx = foldr (\t -> Index.insert t t) Index.empty ts++deriving instance Eq Symbol+deriving instance Generic Symbol++instance Arbitrary Symbol where+  arbitrary =+    Symbol <$>+      arbitrary <*>+      fmap getLarge arbitrary <*>+      (fmap (fromIntegral . getLarge) (arbitrary :: Gen (Large Int32)) `suchThat` (> 0) `suchThat` (< 2^31))+  shrink s =+    filter ok (genericShrink s)+    where+      ok s = Twee.Term.Core.size s > 0++prop_symbol_1 :: Symbol -> Property+prop_symbol_1 s =+  withMaxSuccess 100000 $+  counterexample ("fun/index/size = " ++ show (isFun s, index s, Twee.Term.Core.size s)) $+  counterexample ("n = " ++ show (fromSymbol s)) $+  toSymbol (fromSymbol s) === twiddle s+  where+    twiddle s =+      s { index = fromIntegral (fromIntegral (index s) :: Int32) }++prop_symbol_2 :: Int64 -> Property+prop_symbol_2 n =+  withMaxSuccess 100000 $+  fromSymbol (toSymbol n) === n++return []+main = $forAllProperties (quickCheckWithResult stdArgs { maxSuccess = 1000000 })++t :: Term Func+t = build (app (fun (F 0)) [app (fun (F 1)) [var (V 0), var (V 1)], var (V 2)])
+ tests/BOO067-1.p view
@@ -0,0 +1,32 @@+%--------------------------------------------------------------------------+% File     : BOO067-1 : TPTP v6.3.0. Released v2.6.0.+% Domain   : Boolean Algebra (Ternary)+% Problem  : Ternary Boolean Algebra Single axiom is complete, part 1+% Version  : [MP96] (equality) axioms.+% English  :++% Refs     : [McC98] McCune (1998), Email to G. Sutcliffe+%          : [MP96]  McCune & Padmanabhan (1996), Automated Deduction in Eq+% Source   : [TPTP]+% Names    :++% Status   : Unsatisfiable+% Rating   : 0.42 v6.3.0, 0.35 v6.2.0, 0.29 v6.1.0, 0.31 v6.0.0, 0.48 v5.5.0, 0.47 v5.4.0, 0.33 v5.3.0, 0.25 v5.2.0, 0.29 v5.1.0, 0.33 v5.0.0, 0.29 v4.1.0, 0.18 v4.0.1, 0.36 v4.0.0, 0.38 v3.7.0, 0.11 v3.4.0, 0.12 v3.3.0, 0.21 v3.1.0, 0.33 v2.7.0, 0.27 v2.6.0+% Syntax   : Number of clauses     :    2 (   0 non-Horn;   2 unit;   1 RR)+%            Number of atoms       :    2 (   2 equality)+%            Maximal clause size   :    1 (   1 average)+%            Number of predicates  :    1 (   0 propositional; 2-2 arity)+%            Number of functors    :    7 (   5 constant; 0-3 arity)+%            Number of variables   :    7 (   0 singleton)+%            Maximal term depth    :    5 (   3 average)+% SPC      : CNF_UNS_RFO_PEQ_UEQ++% Comments : A UEQ part of BOO035-1+%--------------------------------------------------------------------------+cnf(single_axiom,axiom,+    ( multiply(multiply(A,inverse(A),B),inverse(multiply(multiply(C,D,E),F,multiply(C,D,G))),multiply(D,multiply(G,F,E),C)) = B )).++cnf(prove_tba_axioms_1,negated_conjecture,+    (  multiply(multiply(d,e,a),b,multiply(d,e,c)) != multiply(d,e,multiply(a,b,c)) )).++%--------------------------------------------------------------------------
+ tests/LAT072-1.p view
@@ -0,0 +1,37 @@+%--------------------------------------------------------------------------+% File     : LAT072-1 : TPTP v6.3.0. Released v2.6.0.+% Domain   : Lattice Theory (Ortholattices)+% Problem  : Given single axiom OML-23A, prove associativity+% Version  : [MRV03] (equality) axioms.+% English  : Given a single axiom candidate OML-23A for orthomodular lattices+%            (OML) in terms of the Sheffer Stroke, prove a Sheffer stroke form+%            of associativity.++% Refs     : [MRV03] McCune et al. (2003), Sheffer Stroke Bases for Ortholatt+% Source   : [MRV03]+% Names    : OML-23A-associativity [MRV03]++% Status   : Unsatisfiable+% Rating   : 0.95 v6.3.0, 0.94 v6.2.0, 0.93 v6.1.0, 0.94 v6.0.0, 0.95 v5.4.0, 1.00 v2.6.0+% Syntax   : Number of clauses     :    2 (   0 non-Horn;   2 unit;   1 RR)+%            Number of atoms       :    2 (   2 equality)+%            Maximal clause size   :    1 (   1 average)+%            Number of predicates  :    1 (   0 propositional; 2-2 arity)+%            Number of functors    :    4 (   3 constant; 0-2 arity)+%            Number of variables   :    4 (   2 singleton)+%            Maximal term depth    :    7 (   4 average)+% SPC      : CNF_UNS_RFO_PEQ_UEQ++% Comments :+%--------------------------------------------------------------------------+%----Single axiom OML-23A+cnf(oml_23A,axiom,+    ( f(f(f(f(B,A),f(A,C)),D),f(A,f(f(C,f(f(A,A),C)),C))) = A )).++cnf(a, axiom, f(X,Y) = f(Y, X)).++%----Denial of Sheffer stroke associativity+cnf(associativity,negated_conjecture,+    (  f(a,f(f(b,c),f(b,c))) != f(c,f(f(b,a),f(b,a))) )).++%--------------------------------------------------------------------------
+ tests/ROB010-1.p view
@@ -0,0 +1,11 @@+cnf(condition,hypothesis,+    ( negate(add(a,negate(b))) = c )).++cnf(prove_result,negated_conjecture,+    (  negate(add(c,negate(add(b,a)))) != a )).++cnf(commutativity_of_add,axiom,+    ( add(X,Y) = add(Y,X) )).++cnf(robbins_axiom,axiom,+    ( negate(add(negate(add(X,Y)),negate(add(X,negate(Y))))) = X )).
+ tests/append-rev.p view
@@ -0,0 +1,4 @@+cnf(rev_rev, axiom, rev(rev(X)) = X).+cnf(app_assoc, axiom, '++'(X,'++'(Y,Z)) = '++'('++'(X,Y),Z)).+cnf(rev_app, axiom, '++'(rev(X),rev(Y)) = rev('++'(Y,X))).+cnf(conjecture, negated_conjecture, '++'(a,rev(b)) != rev('++'(b, rev(a)))).
+ tests/db.p view
@@ -0,0 +1,17 @@+% http://www.dcs.bbk.ac.uk/~szabolcs/rellat-jlamp-second-submission-2.pdf+% appendix b. theorem 3.4, clause 8.+cnf(a, axiom, '^'(X, Y) = '^'(Y, X)).+cnf(a, axiom, '^'(X, '^'(Y, Z)) = '^'(Y, '^'(X, Z))).+cnf(a, axiom, '^'('^'(X, Y), Z) = '^'(X, '^'(Y, Z))).+cnf(a, axiom, v(X, Y) = v(Y, X)).+cnf(a, axiom, v(X, v(Y, Z)) = v(Y, v(X, Z))).+cnf(a, axiom, v(v(X, Y), Z) = v(X, v(Y, Z))).+cnf(a, axiom, v(X, '^'(X, Y)) = X).+cnf(a, axiom, '^'(X, v(X, Y)) = X).+cnf(a, axiom, upme(X,Y,Z) = '^'(X, v(Y, Z))).+cnf(a, axiom, lome(X,Y,Z) = v('^'(X, Y), '^'(X, Z))).+cnf(a, axiom, upjo(X,Y,Z) = '^'(v(X, Y), v(X, Z))).+cnf(a, axiom, lojo(X,Y,Z) = v(X, '^'(Y, Z))).+cnf(a, axiom, v(upme('^'(a, X1),Y1,Z1), '^'(Y1, Z1)) = '^'(v('^'('^'(a, X1), Y1), Z1), v('^'('^'(a, X1), Z1), Y1))).+cnf(a, axiom, upme(X,Y,Z) = v(upme(X,Y,'^'(a, Z)), upme(X,Z,'^'(a, Y)))).+fof(a, conjecture, (upme(a,x2,y2) = upme(a,x2,z2) => upme(x2,y2,z2) = lome(x2,y2,z2))).
+ tests/deriv.p view
@@ -0,0 +1,39 @@+% Axioms about arithmetic.++cnf('commutativity of +', axiom,+	'+'(X, Y) = '+'(Y, X)).+cnf('associativity of +', axiom,+	'+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf('commutativity of *', axiom,+	'*'(X, Y) = '*'(Y, X)).+cnf('associativity of *', axiom,+	'*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).+cnf('plus 0', axiom,+	'+'('0', X) = X).+cnf('times 0', axiom,+	'*'('0', X) = '0').+cnf('times 1', axiom,+	'*'('1', X) = X).+cnf('distributivity', axiom,+	'*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).+cnf('minus', axiom,+    '+'(X, '-'(X)) = '0').++cnf('derivative of 0', axiom,+	d('0') = '0').+cnf('derivative of 1', axiom,+	d('1') = '0').+cnf('derivative of x', axiom,+	d(x) = '1').+cnf('derivative of +', axiom,+	d('+'(T,U)) = '+'(d(T), d(U))).+cnf('derivative of *', axiom,+	d('*'(T, U)) = '+'('*'(T, d(U)), '*'(U, d(T)))).+cnf('derivative of sin', axiom,+    d(sin(T)) = '*'(cos(T), d(T))).+cnf('derivative of cos', axiom,+    d(cos(T)) = '-'('*'(sin(T), d(T)))).++fof(goal, conjecture,+	?[T]: d(T) = '*'(x, cos(x))).+
+ tests/diff.p view
@@ -0,0 +1,4 @@+cnf('x\\(y\\x)=x', axiom, '\\'(X, '\\'(Y, X)) = X).+cnf('x\\(x\\y)=y\\(y\\x)', axiom, '\\'(X, '\\'(X, Y)) = '\\'(Y, '\\'(Y, X))).+cnf('(x\\y)\\z=(x\\z)\\(y\\z)', axiom, '\\'('\\'(X, Y), Z) = '\\'('\\'(X, Z), '\\'(Y, Z))).+cnf(conjecture, negated_conjecture, '\\'('\\'(a, c), b) != '\\'('\\'(a, b), c)).
+ tests/group.p view
@@ -0,0 +1,15 @@+fof(identity, axiom,+    ![X]: f(X, e) = X).+fof(right_inverse, axiom,+    ![X]: f(X, i(X)) = e).+fof(associativity, axiom,+    ![X, Y, Z]: f(X, f(Y, Z)) = f(f(X, Y), Z)).+%fof(left_inverse, conjecture,+%    ![X]: f(i(X),X) = e).+%fof(left_identity, conjecture,+%    ![X]: f(e, X) = X).++fof(inverse_distrib, axiom,+    ![X,Y]: f(i(X),i(Y)) = i(f(X,Y))).+fof(commutativity, conjecture,+    ![X,Y]: f(X,Y) = f(Y,X)).
+ tests/lat.p view
@@ -0,0 +1,16 @@+cnf(idempotence_of_meet, axiom, meet(X, X)=X).+cnf(idempotence_of_join, axiom, join(X, X)=X).+cnf(absorption1, axiom, meet(X, join(X, Y))=X).+cnf(absorption2, axiom, join(X, meet(X, Y))=X).+cnf(commutativity_of_meet, axiom, meet(X, Y)=meet(Y, X)).+cnf(commutativity_of_join, axiom, join(X, Y)=join(Y, X)).+cnf(associativity_of_meet, axiom,+    meet(meet(X, Y), Z)=meet(X, meet(Y, Z))).+cnf(associativity_of_join, axiom,+    join(join(X, Y), Z)=join(X, join(Y, Z))).+cnf(equation_H34, axiom,+    meet(X, join(Y, meet(Z, U)))=meet(X,+                                      join(Y, meet(Z, join(Y, meet(U, join(Y, Z))))))).+cnf(prove_H28, negated_conjecture,+    meet(a, join(b, meet(a, meet(c, d))))!=meet(a,+                                                join(b, meet(c, meet(d, join(a, meet(b, d))))))).
+ tests/lcl.p view
@@ -0,0 +1,7 @@+cnf(wajsberg_1, axiom, implies(truth, X)=X).+cnf(wajsberg_3, axiom,+    implies(implies(X, Y), Y)=implies(implies(Y, X), X)).+cnf(wajsberg_4, axiom,+    implies(implies(not(X), not(Y)), implies(Y, X))=truth).+cnf(lemma_antecedent, axiom, implies(X, Y)=implies(Y, X)).+cnf(prove_wajsberg_lemma, negated_conjecture, x!=y).
+ tests/loop.p view
@@ -0,0 +1,6 @@+cnf(mult_ld, axiom, '*'(X, '^'(X, Y)) = Y).+cnf(ld_mult, axiom, '^'(X, '*'(X, Y)) = Y).+cnf(mult_rd, axiom, '*'('/'(X, Y), Y) = X).+cnf(rd_mult, axiom, '/'('*'(X, Y), Y) = X).+cnf(moufang, axiom, '*'(X, '*'(Y, '*'(X, Z))) = '*'('*'('*'(X, Y), X), Z)).+cnf(conjecture, negated_conjecture, '^'(a,a) != '/'(a,a)).
+ tests/loop2.p view
@@ -0,0 +1,6 @@+cnf('*-\\', axiom, '*'(X, '\\'(X, Y)) = Y).+cnf('\\-*', axiom, '\\'(X, '*'(X, Y)) = Y).+cnf('*-/', axiom, '*'('/'(X, Y), Y) = X).+cnf('/-*', axiom, '/'('*'(X, Y), Y) = X).+cnf(moufang, axiom, '*'(X, '*'(Y, '*'(X, Z))) = '*'('*'('*'(X, Y), X), Z)).+cnf(conjecture, negated_conjecture, '*'(a,'/'(b,b)) != a).
+ tests/lukasiewicz.p view
@@ -0,0 +1,6 @@+cnf(imp_true, axiom, implies(true, X) = X).+cnf(imp_compose, axiom, implies(implies(X, Y), implies(implies(Y, Z), implies(X, Z))) = true).+cnf(imp_not, axiom, implies(implies(not(X), not(Y)), implies(Y, X)) = true).+cnf(imp_switch, axiom, implies(implies(X, Y), Y) = implies(implies(Y, X), X)).+cnf(or_def, axiom, or(X, Y) = implies(not(X), Y)).+cnf(conjecture, negated_conjecture, or(a,or(b,c)) != or(or(a,b),c)).
+ tests/minus.p view
@@ -0,0 +1,12 @@+cnf(plus_zero, axiom,+	'+'('0', X) = X).+cnf(plus_zero, axiom,+	'+'(X, '0') = X).+cnf(minus_minus, axiom,+	'-'('-'(X)) = X).+cnf(minus_plus, axiom,+	'-'('+'(X, Y)) = '+'('-'(X), '-'(Y))).++cnf(goal, conjecture,+    '-'('0') = '0').+	%% ?[Y]: d(Y) = '+'(x, x)).
+ tests/nand.p view
@@ -0,0 +1,37 @@+%--------------------------------------------------------------------------+% File     : LAT071-1 : TPTP v6.2.0. Released v2.6.0.+% Domain   : Lattice Theory (Orthomodularlattices)+% Problem  : Given single axiom OML-21C, prove associativity+% Version  : [MRV03] (equality) axioms.+% English  : Given a single axiom candidate OML-21C for orthomodular lattices+%            (OML) in terms of the Sheffer Stroke, prove a Sheffer stroke form+%            of associativity.++% Refs     : [MRV03] McCune et al. (2003), Sheffer Stroke Bases for Ortholatt+% Source   : [MRV03]+% Names    : OML-21C-associativity [MRV03]++% Status   : Open+% Rating   : 1.00 v2.6.0+% Syntax   : Number of clauses     :    2 (   0 non-Horn;   2 unit;   1 RR)+%            Number of atoms       :    2 (   2 equality)+%            Maximal clause size   :    1 (   1 average)+%            Number of predicates  :    1 (   0 propositional; 2-2 arity)+%            Number of functors    :    4 (   3 constant; 0-2 arity)+%            Number of variables   :    4 (   2 singleton)+%            Maximal term depth    :    6 (   4 average)+% SPC      : CNF_UNK_UEQ++% Comments :+%--------------------------------------------------------------------------+%----Single axiom OML-21C+cnf(oml_21C,axiom,+    ( f(f(B,A),f(f(f(f(B,A),A),f(C,A)),f(f(A,A),D))) = A )).++cnf(a, axiom, f(z, f(z, z)) = k).++%----Denial of Sheffer stroke associativity+cnf(associativity,negated_conjecture,+    (  f(a,f(f(b,c),f(b,c))) != f(c,f(f(b,a),f(b,a))) )).++%--------------------------------------------------------------------------
+ tests/nicomachus.p view
@@ -0,0 +1,18 @@+cnf(plus_comm, axiom, plus(X, Y) = plus(Y, X)).+cnf(plus_assoc, axiom, plus(X, plus(Y, Z)) = plus(plus(X, Y), Z)).+cnf(times_comm, axiom, times(X, Y) = times(Y, X)).+cnf(times_assoc, axiom, times(X, times(Y, Z)) = times(times(X, Y), Z)).+cnf(plus_zero, axiom, plus(X, zero) = X).+cnf(times_zero, axiom, times(X, zero) = zero).+cnf(times_one, axiom, times(X, one) = X).+cnf(distr, axiom, times(X, plus(Y, Z)) = plus(times(X, Y), times(X, Z))).+cnf(distr, axiom, times(plus(X, Y), Z) = plus(times(X, Z), times(Y, Z))).+cnf(plus_s, axiom, plus(s(X), Y) = s(plus(X, Y))).+cnf(times_s, axiom, times(s(X), Y) = plus(Y, times(X, Y))).+cnf(sum_zero, axiom, sum(zero) = zero).+cnf(sum_s, axiom, sum(s(N)) = plus(s(N), sum(N))).+cnf(cubes_zero, axiom, cubes(zero) = zero).+cnf(cubes_s, axiom, cubes(s(N)) = plus(times(s(N), times(s(N), s(N))), cubes(N))).+cnf(plus_sum, axiom, plus(sum(N), sum(N)) = times(N, s(N))).+cnf(ih, axiom, times(sum(a), sum(a)) = cubes(a)).+cnf(conjecture, negated_conjecture, times(sum(s(a)), sum(s(a))) != cubes(s(a))).
+ tests/ring.p view
@@ -0,0 +1,9 @@+cnf(plus_comm, axiom, '+'(X, Y) = '+'(Y, X)).+cnf(plus_assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf(plus_zero, axiom, '+'('0', X) = X).+cnf(plus_inv, axiom, '+'(X, '-'(X)) = '0').+cnf(times_assoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).+cnf(distrib, axiom, '*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).+cnf(distrib, axiom, '*'('+'(X, Y), Z) = '+'('*'(X, Z), '*'(Y, Z))).+cnf(cube, axiom, X = '*'(X, '*'(X, X))).+cnf(conjecture, negated_conjecture, '*'(a, b) != '*'(b, a)).
+ tests/ring2.p view
@@ -0,0 +1,9 @@+cnf(plus_comm, axiom, '+'(X, Y) = '+'(Y, X)).+cnf(plus_assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf(plus_zero, axiom, '+'('0', X) = X).+cnf(plus_inv, axiom, '+'(X, '-'(X)) = '0').+cnf(times_assoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).+cnf(distrib, axiom, '*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).+cnf(distrib, axiom, '*'('+'(X, Y), Z) = '+'('*'(X, Z), '*'(Y, Z))).+cnf(power_six, axiom, X = '*'(X, '*'(X, '*'(X, '*'(X, '*'(X, X)))))).+cnf(conjecture, negated_conjecture, '*'(a, b) != '*'(b, a)).
+ tests/ring3.p view
@@ -0,0 +1,9 @@+cnf(plus_comm, axiom, '+'(X, Y) = '+'(Y, X)).+cnf(plus_assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf(plus_zero, axiom, '+'('0', X) = X).+cnf(plus_neg, axiom, '+'(X, '-'(X)) = '0').+cnf(times_assoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).+cnf(distrib, axiom, '*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).+cnf(distrib, axiom, '*'('+'(X, Y), Z) = '+'('*'(X, Z), '*'(Y, Z))).+cnf(power_four, axiom, X = '*'(X, '*'(X, '*'(X, X)))).+cnf(conjecture, negated_conjecture, '*'(a, b) != '*'(b, a)).
+ tests/ring4.p view
@@ -0,0 +1,9 @@+cnf(plus_comm, axiom, '+'(X, Y) = '+'(Y, X)).+cnf(plus_assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf(plus_zero, axiom, '+'('0', X) = X).+cnf(plus_inv, axiom, '+'(X, '-'(X)) = '0').+cnf(times_ssoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).+cnf(distrib, axiom, '*'(X, '+'(Y, Z)) = '+'('*'(X, Y), '*'(X, Z))).+cnf(distrib, axiom, '*'('+'(X, Y), Z) = '+'('*'(X, Z), '*'(Y, Z))).+cnf(power_five, axiom, X = '*'(X, '*'(X, '*'(X, '*'(X, X))))).+cnf(conjecture, negated_conjecture, '*'(a, b) != '*'(b, a)).
+ tests/robbins-easy.p view
@@ -0,0 +1,4 @@+cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).+cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf(funny, axiom, '+'('-'('+'('-'(X), Y)), '-'('+'('-'(X), '-'(Y)))) = X).+cnf(conjecture, negated_conjecture, '-'('+'('-'('+'(a, b)), '-'('+'(a, '-'(b))))) != a).
+ tests/robbins.p view
@@ -0,0 +1,4 @@+cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).+cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf(funny, axiom, '-'('+'('-'('+'(X, Y)), '-'('+'(X, '-'(Y))))) = X).+cnf(conjecture, negated_conjecture, '-'('-'(a)) != a).
+ tests/sam.p view
@@ -0,0 +1,38 @@+cnf(f_assoc, axiom,+    meet(X,meet(Y,Z)) = meet(meet(X,Y),Z)).+cnf(f_comm, axiom,+    meet(X,Y) = meet(Y,X)).+cnf(f_idem, axiom,+    meet(X,X) = X).+cnf(g_assoc, axiom,+    join(X,join(Y,Z)) = join(join(X,Y),Z)).+cnf(g_comm, axiom,+    join(X,Y) = join(Y,X)).+cnf(g_idem, axiom,+    join(X,X) = X).++cnf(ax31, axiom,+    meet(X, join(X,Y)) = X).+cnf(ax32, axiom,+    meet(zero, X) = zero).+cnf(ax33, axiom,+    join(zero, X) = X).+cnf(ax34, axiom,+    join(X, meet(X, Y)) = X).+cnf(ax35, axiom,+    meet(one, X) = X).+cnf(ax36, axiom,+    join(one, X) = one).+cnf(ax37, axiom,+    meet(X,Z) = X =>+    meet(join(X,Y),Z) = join(X,meet(Y,Z))).++cnf(comp, definition,+    comp(X,Y) <=> (meet(X,Y) = zero & join(X,Y) = one)).++cnf(premise1, assumption,+    comp(a, join(c,d))).+cnf(premise2, assumption,+    comp(b, join(c,d))).+cnf(goal, conjecture,+    meet(join(a,meet(b,c)),join(a,meet(b,d)))=a).
+ tests/semigroup.p view
@@ -0,0 +1,4 @@+cnf(assoc, axiom, '*'(X, '*'(Y, Z)) = '*'('*'(X, Y), Z)).+cnf(two_three, axiom, '*'(X, X) = '*'(X, '*'(X, X))).+cnf(twiddle, axiom, '*'('*'(X, X), Y) = '*'(Y, '*'(X, X))).+cnf(conjecture, negated_conjecture, '*'('*'(a, b), '*'(a, b)) != '*'('*'(a, a), '*'(b, b))).
+ tests/semigroup2.p view
@@ -0,0 +1,26 @@+% File     : GRP196-1 : TPTP v6.1.0. Released v2.2.0.+% Domain   : Group Theory (Semigroups)+% Problem  : In semigroups, xyyy=yyyx -> (uy)^9 = u^9v^9.+% Version  : [MP96] (equality) axioms.+% English  :+% Refs     : [McC98] McCune (1998), Email to G. Sutcliffe+%          : [MP96]  McCune & Padmanabhan (1996), Automated Deduction in Eq+%          : [McC95] McCune (1995), Four Challenge Problems in Equational L+% Source   : [McC98]+% Names    : CS-3 [MP96]+%          : Problem B [McC95]+% Status   : Unsatisfiable+% Rating   : 1.00 v4.0.1, 0.93 v4.0.0, 0.92 v3.7.0, 0.89 v3.4.0, 1.00 v3.3.0, 0.93 v3.1.0, 1.00 v2.2.1+% Syntax   : Number of clauses     :    3 (   0 non-Horn;   3 unit;   1 RR)+%            Number of atoms       :    3 (   3 equality)+%            Maximal clause size   :    1 (   1 average)+%            Number of predicates  :    1 (   0 propositional; 2-2 arity)+%            Number of functors    :    3 (   2 constant; 0-2 arity)+%            Number of variables   :    5 (   0 singleton)+%            Maximal term depth    :   18 (   8 average)+% SPC      : CNF_UNS_RFO_PEQ_UEQ+% Comments : The problem was originally posed for cancellative semigroups,+%            Otter does this with a nonstandard representation [MP96].+cnf(assoc, axiom, '*'('*'(A,B),C)='*'(A,'*'(B,C))).+cnf(twiddle, axiom, '*'(A,'*'(B,'*'(B,B)))='*'(B,'*'(B,'*'(B,A)))).+cnf(conjecture, negated_conjecture, '*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,'*'(b,'*'(a,b))))))))))))))))) != '*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(a,'*'(b,'*'(b,'*'(b,'*'(b,'*'(b,'*'(b,'*'(b,'*'(b,b)))))))))))))))))).
+ tests/veroff.p view
@@ -0,0 +1,10 @@+cnf(majority, axiom,+    f(X,X,Y) = X).+cnf('2a', axiom,+    f(X,Y,Z) = f(Z,X,Y)).+cnf('2b', axiom,+    f(X,Y,Z) = f(X,Z,Y)).+cnf(associativity, axiom,+    f(f(X,W,Y),W,Z) = f(X,W,f(Y,W,Z))).++cnf(goal, axiom, f(f(a1,a2,a3),a4,a5) != f(f(a1,a4,a5),f(a2,a4,a5),f(a3,a4,a5))).
+ tests/winkler-easy.p view
@@ -0,0 +1,6 @@+% Needs case split on X < c.+cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).+cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf(idem, axiom, '+'(X, X) = X).+cnf(funny, axiom, '-'('+'('-'('+'(X, Y)), '-'('+'(X, '-'(Y))))) = X).+cnf(conjecture, negated_conjecture, '+'('-'('+'('-'(a), b)), '-'('+'('-'(a), '-'(b)))) != a).
+ tests/winkler.p view
@@ -0,0 +1,6 @@+% Needs case split on X < c.+cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).+cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf(idem_c, axiom, '+'(c, c) = c).+cnf(funny, axiom, '-'('+'('-'('+'(X, Y)), '-'('+'(X, '-'(Y))))) = X).+cnf(conjecture, negated_conjecture, '+'('-'('+'('-'(a), b)), '-'('+'('-'(a), '-'(b)))) != a).
+ tests/winkler2.p view
@@ -0,0 +1,6 @@+% Needs case split on X < c.+cnf(comm, axiom, '+'(X, Y) = '+'(Y, X)).+cnf(assoc, axiom, '+'(X, '+'(Y, Z)) = '+'('+'(X, Y), Z)).+cnf(plus_c_d, axiom, '+'(c, d) = c).+cnf(funny, axiom, '-'('+'('-'('+'(X, Y)), '-'('+'(X, '-'(Y))))) = X).+cnf(conjecture, negated_conjecture, '+'('-'('+'('-'(a), b)), '-'('+'('-'(a), '-'(b)))) != a).
+ tests/y.p view
@@ -0,0 +1,3 @@+fof(k_def, axiom, ![X, Y]: '@'('@'(k, X), Y) = X).+fof(s_def, axiom, ![X, Y, Z]: '@'('@'('@'(s, X), Y), Z) = '@'('@'(X, Z), '@'(Y, Z))).+fof(conjecture, conjecture, ?[Y]: ![F]: '@'(Y, F) = '@'(F, '@'(Y, F))).
twee.cabal view
@@ -1,5 +1,5 @@ name:                twee-version:             2.1+version:             2.1.1 synopsis:            An equational theorem prover homepage:            http://github.com/nick8325/twee license:             BSD3@@ -9,7 +9,7 @@ category:            Theorem Provers build-type:          Simple cabal-version:       >=1.10-extra-source-files:  misc/static-libstdc+++extra-source-files:  README.md tests/*.p misc/*.hs misc/*.pl misc/static-libstdc++ description:    Twee is an experimental equational theorem prover based on    Knuth-Bendix completion.@@ -41,10 +41,10 @@   default: False  executable twee-  main-is:             Main.hs+  main-is:             executable/Main.hs   default-language:    Haskell2010   build-depends:       base < 5,-                       twee-lib == 2.1,+                       twee-lib == 2.1.1,                        containers,                        pretty,                        split,