itp-interface 1.0.0__py3-none-any.whl

itp_interface/tools/repl/REPL/Snapshots.lean

@@ -0,0 +1,306 @@
+/-
+Copyright (c) 2023 Lean FRO, LLC. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Scott Morrison
+-/
+import Lean.Replay
+import Lean.Elab.Command
+import REPL.Util.Pickle
+
+open Lean Elab
+
+namespace Lean.Elab.Command
+
+@[inline] def CommandElabM.run (x : CommandElabM α) (ctx : Context) (s : State) : EIO Exception (α × State) :=
+  (x ctx).run s
+
+@[inline] def CommandElabM.run' (x : CommandElabM α) (ctx : Context) (s : State) : EIO Exception α :=
+  Prod.fst <$> x.run ctx s
+
+@[inline] def CommandElabM.toIO (x : CommandElabM α) (ctx : Context) (s : State) : IO (α × State) := do
+  match (← (x.run ctx s).toIO') with
+  | Except.error (Exception.error _ msg)   => throw <| IO.userError (← msg.toString)
+  | Except.error (Exception.internal id _) => throw <| IO.userError <| "internal exception #" ++ toString id.idx
+  | Except.ok a                            => return a
+
+end Lean.Elab.Command
+
+namespace REPL
+
+/--
+Bundled structure for the `State` and `Context` objects
+for the `CommandElabM` monad.
+-/
+structure CommandSnapshot where
+  cmdState     : Command.State
+  cmdContext   : Command.Context
+
+namespace CommandSnapshot
+
+open Lean.Elab.Command
+
+/-- A copy of `Command.State` with the `Environment`, caches, and logging omitted. -/
+structure CompactableCommandSnapshot where
+  -- env         : Environment
+  scopes         : List Scope := [{ header := "" }]
+  nextMacroScope : Nat     := firstFrontendMacroScope + 1
+  maxRecDepth    : Nat
+  nextInstIdx    : Nat := 1 -- for generating anonymous instance names
+  ngen           : NameGenerator  := {}
+  -- infoState   : InfoState := {}
+  -- traceState  : TraceState := {}
+  -- messages    : MessageLog := {}
+
+open System (FilePath)
+
+/--
+Run a `CommandElabM` monadic function in the current `ProofSnapshot`,
+updating the `Command.State`.
+-/
+def runCommandElabM (p : CommandSnapshot) (t : CommandElabM α) : IO (α × CommandSnapshot) := do
+  let (a, cmdState) ← (CommandElabM.toIO · p.cmdContext p.cmdState) do t
+  return (a, { p with cmdState })
+
+
+/--
+Pickle a `CommandSnapshot`, discarding closures and non-essential caches.
+
+When pickling the `Environment`, we do so relative to its imports.
+-/
+def pickle (p : CommandSnapshot) (path : FilePath) : IO Unit := do
+  let env := p.cmdState.env
+  let p' := { p with cmdState := { p.cmdState with env := ← mkEmptyEnvironment }}
+  _root_.pickle path
+    (env.header.imports,
+     env.constants.map₂,
+     ({ p'.cmdState with } : CompactableCommandSnapshot),
+     p'.cmdContext)
+
+/--
+Unpickle a `CommandSnapshot`.
+-/
+def unpickle (path : FilePath) : IO (CommandSnapshot × CompactedRegion) := unsafe do
+  let ((imports, map₂, cmdState, cmdContext), region) ←
+    _root_.unpickle (Array Import × PHashMap Name ConstantInfo × CompactableCommandSnapshot ×
+      Command.Context) path
+  let env ← (← importModules imports {} 0).replay (HashMap.ofList map₂.toList)
+  let p' : CommandSnapshot :=
+  { cmdState := { cmdState with env }
+    cmdContext }
+  let (_, p'') ← p'.runCommandElabM do
+    for o in ← getOpenDecls do
+      if let .simple ns _ := o then do
+        activateScoped ns
+  return (p'', region)
+
+end CommandSnapshot
+
+/--
+Bundled structure for the `State` and `Context` objects
+for the `CoreM`, `MetaM`, `TermElabM`, and `TacticM` monads.
+-/
+structure ProofSnapshot where
+  coreState     : Core.State
+  coreContext   : Core.Context
+  metaState     : Meta.State
+  metaContext   : Meta.Context
+  termState     : Term.State
+  termContext   : Term.Context
+  tacticState   : Tactic.State
+  tacticContext : Tactic.Context
+
+namespace ProofSnapshot
+
+open Lean Elab Tactic
+
+/-- New messages in a `ProofSnapshot`, relative to an optional previous `ProofSnapshot`. -/
+def newMessages (new : ProofSnapshot) (old? : Option ProofSnapshot := none) : List Lean.Message :=
+  match old? with
+  | none => new.coreState.messages.msgs.toList
+  | some old => new.coreState.messages.msgs.toList.drop (old.coreState.messages.msgs.size)
+
+/-- New info trees in a `ProofSnapshot`, relative to an optional previous `ProofSnapshot`. -/
+def newInfoTrees (new : ProofSnapshot) (old? : Option ProofSnapshot := none) : List InfoTree :=
+  let infoState := new.coreState.infoState
+  let trees := match old? with
+  | none => infoState.trees.toList
+  | some old => infoState.trees.toList.drop (old.coreState.infoState.trees.size)
+  trees.map fun t => t.substitute infoState.assignment
+
+/-- Run a `CoreM` monadic function in the current `ProofSnapshot`, updating the `Core.State`. -/
+def runCoreM (p : ProofSnapshot) (t : CoreM α) : IO (α × ProofSnapshot) := do
+  let (a, coreState) ← (Lean.Core.CoreM.toIO · p.coreContext p.coreState) do t
+  return (a, { p with coreState })
+
+/-- Run a `MetaM` monadic function in the current `ProofSnapshot`, updating the `Meta.State`. -/
+def runMetaM (p : ProofSnapshot) (t : MetaM α) : IO (α × ProofSnapshot) := do
+  let ((a, metaState), p') ←
+    p.runCoreM (Lean.Meta.MetaM.run (ctx := p.metaContext) (s := p.metaState) do t)
+  return (a, { p' with metaState })
+
+/-- Run a `TermElabM` monadic function in the current `ProofSnapshot`, updating the `Term.State`. -/
+def runTermElabM (p : ProofSnapshot) (t : TermElabM α) : IO (α × ProofSnapshot) := do
+  let ((a, termState), p') ← p.runMetaM (Lean.Elab.Term.TermElabM.run (s := p.termState)
+    (do let r ← t; Term.synthesizeSyntheticMVarsNoPostponing; pure r))
+  return (a, { p' with termState })
+
+/-- Run a `TacticM` monadic function in the current `ProofSnapshot`, updating the `Tactic.State`. -/
+def runTacticM (p : ProofSnapshot) (t : TacticM α) : IO (α × ProofSnapshot) := do
+  let ((a, tacticState), p') ← p.runTermElabM (t p.tacticContext |>.run p.tacticState)
+  return (a, { p' with tacticState })
+
+/--
+Run a `TacticM` monadic function in the current `ProofSnapshot`, updating the `Tactic.State`,
+and discarding the return value.
+-/
+def runTacticM' (p : ProofSnapshot) (t : TacticM α) : IO ProofSnapshot :=
+  Prod.snd <$> p.runTacticM t
+
+/-- New traces in a `ProofSnapshot`, relative to an optional previous `ProofSnapshot`. -/
+def newTraces (new : ProofSnapshot) (old? : Option ProofSnapshot := none) : IO (List String) :=
+  match old? with
+  | none => (·.1) <$> new.runCoreM (do
+     (← getTraces).toList.mapM fun t => do pure (← t.msg.toString).trim)
+  | some old => do
+    let oldCount ← (·.1) <$> old.runCoreM (return (← getTraces).size)
+    (·.1) <$> new.runCoreM (do
+     ((← getTraces).toList.drop oldCount).mapM fun t => do pure (← t.msg.toString).trim)
+
+/--
+Evaluate a `Syntax` into a `TacticM` tactic, and run it in the current `ProofSnapshot`.
+-/
+def runSyntax (p : ProofSnapshot) (t : Syntax) : IO ProofSnapshot :=
+  Prod.snd <$> p.runTacticM (evalTactic t)
+
+/--
+Parse a string into a `Syntax`, evaluate it as a `TacticM` tactic,
+and run it in the current `ProofSnapshot`.
+-/
+def runString (p : ProofSnapshot) (t : String) : IO ProofSnapshot :=
+  match Parser.runParserCategory p.coreState.env `tactic t with
+  | .error e => throw (IO.userError e)
+  | .ok stx => p.runSyntax stx
+
+/-- Pretty print the current goals in the `ProofSnapshot`. -/
+def ppGoals (p : ProofSnapshot) : IO (List Format) :=
+  Prod.fst <$> p.runMetaM do p.tacticState.goals.mapM (Meta.ppGoal ·)
+/--
+Construct a `ProofSnapshot` from a `ContextInfo` and optional `LocalContext`, and a list of goals.
+
+For convenience, we also allow a list of `Expr`s, and these are appended to the goals
+as fresh metavariables with the given types.
+-/
+def create (ctx : ContextInfo) (lctx? : Option LocalContext) (env? : Option Environment)
+    (goals : List MVarId) (types : List Expr := []) : IO ProofSnapshot := do
+  ctx.runMetaM (lctx?.getD {}) do
+    let goals := goals ++ (← types.mapM fun t => Expr.mvarId! <$> Meta.mkFreshExprMVar (some t))
+    goals.head!.withContext do
+    let s ← getThe Core.State
+    let s := match env? with
+    | none => s
+    | some env => { s with env }
+    pure <|
+    { coreState := s
+      coreContext := ← readThe Core.Context
+      metaState := ← getThe Meta.State
+      metaContext := ← readThe Meta.Context
+      termState := {}
+      termContext := {}
+      tacticState := { goals }
+      tacticContext := { elaborator := .anonymous } }
+
+open Lean.Core in
+/-- A copy of `Core.State` with the `Environment`, caches, and logging omitted. -/
+structure CompactableCoreState where
+  -- env             : Environment
+  nextMacroScope  : MacroScope     := firstFrontendMacroScope + 1
+  ngen            : NameGenerator  := {}
+  -- traceState      : TraceState     := {}
+  -- cache           : Core.Cache     := {}
+  -- messages        : MessageLog     := {}
+  -- infoState       : Elab.InfoState := {}
+
+open Lean.Meta in
+/-- A copy of `Meta.Context` with closures omitted. -/
+structure CompactableMetaContext where
+  config            : Config               := {}
+  lctx              : LocalContext         := {}
+  localInstances    : LocalInstances       := #[]
+  defEqCtx?         : Option DefEqContext  := none
+  synthPendingDepth : Nat                  := 0
+  -- canUnfold?        : Option (Config → ConstantInfo → CoreM Bool) := none
+
+/-- A copy of `Term.Context` with closures and a cache omitted. -/
+structure CompactableTermContext where
+  declName? : Option Name := none
+  auxDeclToFullName : FVarIdMap Name  := {}
+  macroStack        : MacroStack      := []
+  mayPostpone : Bool := true
+  errToSorry : Bool := true
+  autoBoundImplicit  : Bool            := false
+  autoBoundImplicits : PArray Expr := {}
+  -- autoBoundImplicitForbidden : Name → Bool := fun _ => false
+  sectionVars        : NameMap Name    := {}
+  sectionFVars       : NameMap Expr    := {}
+  implicitLambda     : Bool            := true
+  isNoncomputableSection : Bool        := false
+  ignoreTCFailures : Bool := false
+  inPattern        : Bool := false
+  -- tacticCache?     : Option (IO.Ref Tactic.Cache) := none
+  saveRecAppSyntax : Bool := true
+  holesAsSyntheticOpaque : Bool := false
+
+open System (FilePath)
+
+/--
+Pickle a `ProofSnapshot`, discarding closures and non-essential caches.
+
+When pickling the `Environment`, we do so relative to its imports.
+-/
+def pickle (p : ProofSnapshot) (path : FilePath) : IO Unit := do
+  let env := p.coreState.env
+  let p' := { p with coreState := { p.coreState with env := ← mkEmptyEnvironment }}
+  _root_.pickle path
+    (env.header.imports,
+     env.constants.map₂,
+     ({ p'.coreState with } : CompactableCoreState),
+     p'.coreContext,
+     p'.metaState,
+     ({ p'.metaContext with } : CompactableMetaContext),
+     p'.termState,
+     ({ p'.termContext with } : CompactableTermContext),
+     p'.tacticState,
+     p'.tacticContext)
+
+/--
+Unpickle a `ProofSnapshot`.
+-/
+def unpickle (path : FilePath) (cmd? : Option CommandSnapshot) :
+    IO (ProofSnapshot × CompactedRegion) := unsafe do
+  let ((imports, map₂, coreState, coreContext, metaState, metaContext, termState, termContext,
+    tacticState, tacticContext), region) ←
+    _root_.unpickle (Array Import × PHashMap Name ConstantInfo × CompactableCoreState ×
+      Core.Context × Meta.State × CompactableMetaContext × Term.State × CompactableTermContext ×
+      Tactic.State × Tactic.Context) path
+  let env ← match cmd? with
+  | none =>
+    enableInitializersExecution
+    (← importModules imports {} 0).replay (HashMap.ofList map₂.toList)
+  | some cmd =>
+    cmd.cmdState.env.replay (HashMap.ofList map₂.toList)
+  let p' : ProofSnapshot :=
+  { coreState := { coreState with env }
+    coreContext
+    metaState
+    metaContext := { metaContext with }
+    termState
+    termContext := { termContext with }
+    tacticState
+    tacticContext }
+  let (_, p'') ← p'.runCoreM do
+    for o in ← getOpenDecls do
+      if let .simple ns _ := o then
+        activateScoped ns
+  return (p'', region)
+
+end ProofSnapshot

itp_interface/tools/repl/REPL/Util/Path.lean

@@ -0,0 +1,36 @@
+/-
+Copyright (c) 2022 Gabriel Ebner. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Gabriel Ebner
+-/
+import Lean
+
+-- This has been duplicated from Std4 to avoid a dependency.
+
+/-!
+# `compile_time_search_path%` term elaborator.
+
+Use this as `searchPathRef.set compile_time_search_path%`.
+-/
+
+open Lean System
+
+-- Ideally this instance would be constructed simply by `deriving instance ToExpr for FilePath`
+-- but for now we have decided not to upstream the `ToExpr` derive handler from `Mathlib`.
+-- https://leanprover.zulipchat.com/#narrow/stream/348111-std4/topic/ToExpr.20derive.20handler/near/386476438
+instance : ToExpr FilePath where
+  toTypeExpr := mkConst ``FilePath
+  toExpr path := mkApp (mkConst ``FilePath.mk) (toExpr path.1)
+
+/--
+Term elaborator that retrieves the current `SearchPath`.
+
+Typical usage is `searchPathRef.set compile_time_search_path%`.
+
+This must not be used in files that are potentially compiled on another machine and then
+imported.
+(That is, if used in an imported file it will embed the search path from whichever machine
+compiled the `.olean`.)
+-/
+elab "compile_time_search_path%" : term =>
+  return toExpr (← searchPathRef.get)

itp_interface/tools/repl/REPL/Util/Pickle.lean

@@ -0,0 +1,44 @@
+/-
+Copyright (c) 2023 Mario Carneiro. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mario Carneiro
+-/
+import Lean.Environment
+
+/-!
+# Pickling and unpickling objects
+
+By abusing `saveModuleData` and `readModuleData` we can pickle and unpickle objects to disk.
+-/
+
+open Lean System
+
+/--
+Save an object to disk.
+If you need to write multiple objects from within a single declaration,
+you will need to provide a unique `key` for each.
+-/
+def pickle {α : Type} (path : FilePath) (x : α) (key : Name := by exact decl_name%) : IO Unit :=
+  saveModuleData path key (unsafe unsafeCast x)
+
+/--
+Load an object from disk.
+Note: The returned `CompactedRegion` can be used to free the memory behind the value
+of type `α`, using `CompactedRegion.free` (which is only safe once all references to the `α` are
+released). Ignoring the `CompactedRegion` results in the data being leaked.
+Use `withUnpickle` to call `CompactedRegion.free` automatically.
+
+This function is unsafe because the data being loaded may not actually have type `α`, and this
+may cause crashes or other bad behavior.
+-/
+unsafe def unpickle (α : Type) (path : FilePath) : IO (α × CompactedRegion) := do
+  let (x, region) ← readModuleData path
+  pure (unsafeCast x, region)
+
+/-- Load an object from disk and run some continuation on it, freeing memory afterwards. -/
+unsafe def withUnpickle [Monad m] [MonadLiftT IO m] {α β : Type}
+    (path : FilePath) (f : α → m β) : m β := do
+  let (x, region) ← unpickle α path
+  let r ← f x
+  region.free
+  pure r

itp_interface/tools/repl/REPL.lean

@@ -0,0 +1,4 @@
+import REPL.Frontend
+import REPL.Lean.InfoTree
+import REPL.JSON
+import REPL.Main

itp_interface/tools/repl/lake-manifest.json

@@ -0,0 +1,5 @@
+{"version": 7,
+ "packagesDir": ".lake/packages",
+ "packages": [],
+ "name": "REPL",
+ "lakeDir": ".lake"}

itp_interface/tools/repl/lakefile.lean

@@ -0,0 +1,15 @@
+import Lake
+open Lake DSL
+
+package REPL {
+  -- add package configuration options here
+}
+
+lean_lib REPL {
+  -- add library configuration options here
+}
+
+@[default_target]
+lean_exe repl where
+  root := `REPL.Main
+  supportInterpreter := true

itp_interface/tools/repl/lean-toolchain

@@ -0,0 +1 @@
+leanprover/lean4:v4.7.0-rc2

itp_interface/tools/repl/test/Mathlib/.gitignore

@@ -0,0 +1,5 @@
+/build
+/lake-packages/*
+/lakefile.olean
+/test/*.olean
+/test/*.olean.tmp

itp_interface/tools/repl/test/Mathlib/H20231110.sh

@@ -0,0 +1,2 @@
+(head -n 2 test/H20231110.in; for i in {1..100}; do tail -n +3 test/H20231110.in; done) |
+lake env ../../build/bin/repl

itp_interface/tools/repl/test/Mathlib/ReplMathlibTests.lean

@@ -0,0 +1 @@
+import Mathlib

itp_interface/tools/repl/test/Mathlib/lake-manifest.json

@@ -0,0 +1,68 @@
+{"version": 7,
+ "packagesDir": ".lake/packages",
+ "packages":
+ [{"url": "https://github.com/leanprover/std4",
+   "type": "git",
+   "subDir": null,
+   "rev": "ff9850c4726f6b9fb8d8e96980c3fcb2900be8bd",
+   "name": "std",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "main",
+   "inherited": true,
+   "configFile": "lakefile.lean"},
+  {"url": "https://github.com/leanprover-community/quote4",
+   "type": "git",
+   "subDir": null,
+   "rev": "fd760831487e6835944e7eeed505522c9dd47563",
+   "name": "Qq",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "master",
+   "inherited": true,
+   "configFile": "lakefile.lean"},
+  {"url": "https://github.com/leanprover-community/aesop",
+   "type": "git",
+   "subDir": null,
+   "rev": "056ca0fa8f5585539d0b940f532d9750c3a2270f",
+   "name": "aesop",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "master",
+   "inherited": true,
+   "configFile": "lakefile.lean"},
+  {"url": "https://github.com/leanprover-community/ProofWidgets4",
+   "type": "git",
+   "subDir": null,
+   "rev": "fb65c476595a453a9b8ffc4a1cea2db3a89b9cd8",
+   "name": "proofwidgets",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "v0.0.30",
+   "inherited": true,
+   "configFile": "lakefile.lean"},
+  {"url": "https://github.com/leanprover/lean4-cli",
+   "type": "git",
+   "subDir": null,
+   "rev": "a751d21d4b68c999accb6fc5d960538af26ad5ec",
+   "name": "Cli",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "main",
+   "inherited": true,
+   "configFile": "lakefile.lean"},
+  {"url": "https://github.com/leanprover-community/import-graph.git",
+   "type": "git",
+   "subDir": null,
+   "rev": "64d082eeaad1a8e6bbb7c23b7a16b85a1715a02f",
+   "name": "importGraph",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "main",
+   "inherited": true,
+   "configFile": "lakefile.lean"},
+  {"url": "https://github.com/leanprover-community/mathlib4",
+   "type": "git",
+   "subDir": null,
+   "rev": "59fdb6b04d7d16825a54483d550d9572ff473abf",
+   "name": "mathlib",
+   "manifestFile": "lake-manifest.json",
+   "inputRev": "v4.7.0-rc2",
+   "inherited": false,
+   "configFile": "lakefile.lean"}],
+ "name": "«repl-mathlib-tests»",
+ "lakeDir": ".lake"}

itp_interface/tools/repl/test/Mathlib/lakefile.lean

@@ -0,0 +1,11 @@
+import Lake
+open Lake DSL
+
+package «repl-mathlib-tests» where
+  -- add package configuration options here
+  require mathlib from git "https://github.com/leanprover-community/mathlib4" @ "v4.7.0-rc2"
+
+@[default_target]
+lean_lib «ReplMathlibTests» where
+  globs := #[.submodules `test]
+  -- add library configuration options here

itp_interface/tools/repl/test/Mathlib/lean-toolchain

@@ -0,0 +1 @@
+leanprover/lean4:v4.7.0-rc2

itp_interface/tools/repl/test/Mathlib/test/20240209.expected.out

@@ -0,0 +1,20 @@
+{"sorries":
+ [{"proofState": 0,
+   "pos": {"line": 1, "column": 22},
+   "goal": "⊢ False",
+   "endPos": {"line": 1, "column": 27}}],
+ "messages":
+ [{"severity": "warning",
+   "pos": {"line": 1, "column": 0},
+   "endPos": {"line": 1, "column": 7},
+   "data": "declaration uses 'sorry'"}],
+ "env": 0}
+
+{"proofState": 1,
+ "messages":
+ [{"severity": "error",
+   "pos": {"line": 0, "column": 0},
+   "endPos": {"line": 0, "column": 0},
+   "data": "unsolved goals\n⊢ False"}],
+ "goals": []}
+

itp_interface/tools/repl/test/Mathlib/test/20240209.in

@@ -0,0 +1,3 @@
+{"cmd": "example : False := by sorry"}
+
+{"tactic": "simpa using show False by done", "proofState": 0}

itp_interface/tools/repl/test/Mathlib/test/20240209.lean

@@ -0,0 +1,4 @@
+import Std.Tactic.Simpa
+
+example : False := by
+  simpa using show False by done

itp_interface/tools/repl/test/Mathlib/test/H20231020.expected.out

@@ -0,0 +1,8 @@
+{"env": 0}
+
+{"env": 1}
+
+{"env": 2}
+
+{"env": 3}
+

itp_interface/tools/repl/test/Mathlib/test/H20231020.in

@@ -0,0 +1,8 @@
+{"cmd": "import Mathlib.Algebra.BigOperators.Basic\nimport Mathlib.Data.Real.Basic\nimport Mathlib.Data.Complex.Basic\nimport Mathlib.Data.Nat.Log\nimport Mathlib.Data.Complex.Exponential\nimport Mathlib.NumberTheory.Divisors\nimport Mathlib.Data.ZMod.Defs\nimport Mathlib.Data.ZMod.Basic\nimport Mathlib.Topology.Basic\nimport Mathlib.Data.Nat.Digits\nimport Mathlib.Tactic.NormNum.GCD\nopen BigOperators\nopen Real\nopen Nat\nopen Topology"}
+
+{"cmd": "theorem mathd_numbertheory_188 : Nat.gcd 180 168 = 12 := by norm_num", "env": 0}
+
+{"cmd": "theorem mathd_numbertheory_403 : ∑ k in (Nat.properDivisors 198), k = 270 := by simp (config := {decide := true})", "env": 0}
+
+{"cmd": "theorem mathd_numbertheory_109 (v : ℕ → ℕ) (h₀ : ∀ n, v n = 2 * n - 1) : (∑ k in Finset.Icc 1 100, v k) % 7 = 4 := by simp_rw (config := {decide := true}) [h₀]", "env": 0}
+

itp_interface/tools/repl/test/Mathlib/test/H20231020.lean

@@ -0,0 +1,22 @@
+import Mathlib.Algebra.BigOperators.Basic
+import Mathlib.Data.Real.Basic
+import Mathlib.Data.Complex.Basic
+import Mathlib.Data.Nat.Log
+import Mathlib.Data.Complex.Exponential
+import Mathlib.NumberTheory.Divisors
+import Mathlib.Data.ZMod.Defs
+import Mathlib.Data.ZMod.Basic
+import Mathlib.Topology.Basic
+import Mathlib.Data.Nat.Digits
+import Mathlib.Tactic.NormNum.GCD
+
+open BigOperators
+open Real
+open Nat
+open Topology
+
+theorem mathd_numbertheory_188 : Nat.gcd 180 168 = 12 := by norm_num
+
+theorem mathd_numbertheory_403 : ∑ k in (Nat.properDivisors 198), k = 270 := by simp (config := {decide := true})
+
+theorem mathd_numbertheory_109 (v : ℕ → ℕ) (h₀ : ∀ n, v n = 2 * n - 1) : (∑ k in Finset.Icc 1 100, v k) % 7 = 4 := by simp_rw (config := {decide := true}) [h₀]

itp_interface/tools/repl/test/Mathlib/test/H20231110.expected.out

@@ -0,0 +1,4 @@
+{"env": 0}
+
+{"env": 1}
+

itp_interface/tools/repl/test/Mathlib/test/H20231110.in

@@ -0,0 +1,4 @@
+{"cmd": "import Mathlib\nopen Real\nlocal macro_rules | `($x ^ $y) => `(HPow.hPow $x $y)"}
+
+{"cmd": "example {n} {x a b : ℝ} (m : ℕ) (e₁ : n + 1 = m) (rm : ℝ) (er : ↑m = rm) (h : |x| ≤ 1) (e : |1 - a| ≤ b - |x| / rm * ((rm + 1) / rm)) : |exp x - expNear n x a| ≤ |x| ^ n / n.factorial * b := by apply Real.exp_approx_end' m e₁ rm er h e", "env": 0}
+

itp_interface/tools/repl/test/Mathlib/test/H20231115.expected.out

@@ -0,0 +1,19 @@
+{"env": 0}
+
+{"sorries":
+ [{"proofState": 0,
+   "pos": {"line": 1, "column": 36},
+   "goal": "x : Nat\n⊢ x + 1 > x",
+   "endPos": {"line": 1, "column": 41}}],
+ "messages":
+ [{"severity": "warning",
+   "pos": {"line": 1, "column": 0},
+   "endPos": {"line": 1, "column": 7},
+   "data": "declaration uses 'sorry'"}],
+ "env": 1}
+
+{"proofState": 1,
+ "goals":
+ ["case zero\n⊢ Nat.zero + 1 > Nat.zero",
+  "case succ\nx : Nat\nhx : x + 1 > x\n⊢ Nat.succ x + 1 > Nat.succ x"]}
+

itp_interface/tools/repl/test/Mathlib/test/H20231115.in

@@ -0,0 +1,5 @@
+{"cmd": "import Mathlib.Tactic.Cases"}
+
+{"cmd": "example {x : Nat} : x + 1 > x := by sorry", "env": 0}
+
+{"tactic": "induction' x with x hx", "proofState": 0}

itp_interface/tools/repl/test/Mathlib/test/H20231115_2.expected.out

@@ -0,0 +1,18 @@
+{"env": 0}
+
+{"sorries":
+ [{"proofState": 0,
+   "pos": {"line": 3, "column": 12},
+   "goal": "case zero\n⊢ Nat.zero + 1 > Nat.zero",
+   "endPos": {"line": 3, "column": 17}},
+  {"proofState": 1,
+   "pos": {"line": 3, "column": 12},
+   "goal": "case succ\nx : Nat\nhx : x + 1 > x\n⊢ Nat.succ x + 1 > Nat.succ x",
+   "endPos": {"line": 3, "column": 17}}],
+ "messages":
+ [{"severity": "warning",
+   "pos": {"line": 1, "column": 0},
+   "endPos": {"line": 1, "column": 7},
+   "data": "declaration uses 'sorry'"}],
+ "env": 1}
+

itp_interface/tools/repl/test/Mathlib/test/H20231115_2.in

@@ -0,0 +1,4 @@
+{"cmd": "import Mathlib.Tactic.Cases"}
+
+{"cmd": "example {x : Nat} : x + 1 > x := by\n  induction' x with x hx\n  all_goals sorry", "env": 0}
+

itp_interface/tools/repl/test/Mathlib/test/H20231115_3.expected.out

@@ -0,0 +1,10 @@
+{"env": 0}
+
+{"messages":
+ [{"severity": "error",
+   "pos": {"line": 1, "column": 33},
+   "endPos": {"line": 2, "column": 24},
+   "data":
+   "unsolved goals\ncase zero\n⊢ Nat.zero + 1 > Nat.zero\n\ncase succ\nx : Nat\nhx : x + 1 > x\n⊢ Nat.succ x + 1 > Nat.succ x"}],
+ "env": 1}
+