module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 365
values | kind stringclasses 368
values |
|---|---|---|---|---|---|---|
Mathlib.Data.List.ReduceOption | {
"line": 115,
"column": 2
} | {
"line": 115,
"column": 63
} | [
{
"pp": "α : Type u_1\nl : List (Option α)\n⊢ l.reduceOption.length = l.length ↔ ∀ (x : Option α), x ∈ l → x.isSome = true",
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.reduceOption_length_eq",
"Iff.rfl",
"Membership.mem",
"id",
"Bool.true",
"List",
"... | rw [reduceOption_length_eq, List.length_filter_eq_length_iff] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.Lemmas | {
"line": 59,
"column": 6
} | {
"line": 59,
"column": 22
} | [
{
"pp": "α : Type u_1\ninst✝ : AddGroupWithOne α\nn : PosNum\n⊢ ↑↑n = ↑n",
"usedConstants": [
"Int.cast",
"Eq.mpr",
"castPosNum",
"Nat.instOne",
"AddMonoid.toAddSemigroup",
"congrArg",
"AddGroupWithOne.toAddMonoidWithOne",
"id",
"Int",
"AddGroupWit... | ← to_nat_to_int, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.EpsilonNFA | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 31
} | [
{
"pp": "case nil.mp\nα : Type u\nσ : Type v\nM : εNFA α σ\ns₁ s₂ : σ\nn : ℕ\nh✝ : M.IsPath s₁ s₂ (List.replicate n none)\n⊢ ∃ x', x'.reduceOption = [] ∧ M.IsPath s₁ s₂ x'",
"usedConstants": [
"List.replicate",
"Option.none",
"List",
"And",
"Exists.intro",
"List.reduceOpt... | use List.replicate n none | Mathlib.Tactic._aux_Mathlib_Tactic_Use___elabRules_Mathlib_Tactic_useSyntax_1 | Mathlib.Tactic.useSyntax |
Mathlib.Computability.EpsilonNFA | {
"line": 301,
"column": 2
} | {
"line": 301,
"column": 35
} | [
{
"pp": "case h\nα : Type u\nσ : Type v\nM : NFA α σ\nS : Set σ\na : σ\n⊢ a ∈ M.toεNFA.εClosure S ↔ a ∈ S",
"usedConstants": [
"εNFA.εClosure.base",
"Membership.mem",
"Iff.intro",
"Set.instMembership",
"εNFA.εClosure",
"NFA.toεNFA",
"Set"
]
}
] | refine ⟨?_, εNFA.εClosure.base _⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Num.Lemmas | {
"line": 416,
"column": 6
} | {
"line": 416,
"column": 22
} | [
{
"pp": "α : Type u_1\ninst✝ : AddGroupWithOne α\nn : Num\n⊢ ↑↑n = ↑n",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Int.cast",
"Eq.mpr",
"Nat.instMulZeroClass",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"Nat.instOne",
... | ← to_nat_to_int, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.Lemmas | {
"line": 420,
"column": 20
} | {
"line": 420,
"column": 34
} | [
{
"pp": "n : ℕ\n⊢ ↑↑(n + 1) = n + 1",
"usedConstants": [
"Eq.mpr",
"Nat.cast_succ",
"Nat.instMulZeroClass",
"Nat.instOne",
"AddMonoid.toAddSemigroup",
"congrArg",
"id",
"AddMonoidWithOne.toNatCast",
"instOfNatNat",
"Nat.cast",
"castNum",
... | Nat.cast_succ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.StateTransition | {
"line": 112,
"column": 6
} | {
"line": 114,
"column": 34
} | [
{
"pp": "case refine_1.none\nσ : Type u_1\nf : σ → Option σ\na✝ b : σ\nh✝ : b ∈ eval f a✝\na : σ\nh : b ∈ eval f a\nIH : ∀ (a' : σ), f a = some a' → Reaches f a' b ∧ f b = none\ne : f a = none\n⊢ Reaches f a b ∧ f b = none",
"usedConstants": [
"Iff.mpr",
"Part",
"Eq.mpr",
"congrArg",... | rw [Part.mem_unique h
(PFun.mem_fix_iff.2 <| Or.inl <| Part.mem_some_iff.2 <| by rw [e]; rfl)]
exact ⟨ReflTransGen.refl, e⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.StateTransition | {
"line": 112,
"column": 6
} | {
"line": 114,
"column": 34
} | [
{
"pp": "case refine_1.none\nσ : Type u_1\nf : σ → Option σ\na✝ b : σ\nh✝ : b ∈ eval f a✝\na : σ\nh : b ∈ eval f a\nIH : ∀ (a' : σ), f a = some a' → Reaches f a' b ∧ f b = none\ne : f a = none\n⊢ Reaches f a b ∧ f b = none",
"usedConstants": [
"Iff.mpr",
"Part",
"Eq.mpr",
"congrArg",... | rw [Part.mem_unique h
(PFun.mem_fix_iff.2 <| Or.inl <| Part.mem_some_iff.2 <| by rw [e]; rfl)]
exact ⟨ReflTransGen.refl, e⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.Lemmas | {
"line": 717,
"column": 16
} | {
"line": 717,
"column": 51
} | [
{
"pp": "p : PosNum\n⊢ ↑(pos p).pred = (↑(pos p)).pred",
"usedConstants": [
"Eq.mpr",
"castPosNum",
"Nat.instMulZeroClass",
"Nat.instOne",
"PosNum.pred'",
"congrArg",
"PosNum.pred'_to_nat",
"id",
"Num.pred.eq_2",
"castNum",
"Num",
"Nat"... | rw [pred, PosNum.pred'_to_nat]; rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.Lemmas | {
"line": 717,
"column": 16
} | {
"line": 717,
"column": 51
} | [
{
"pp": "p : PosNum\n⊢ ↑(pos p).pred = (↑(pos p)).pred",
"usedConstants": [
"Eq.mpr",
"castPosNum",
"Nat.instMulZeroClass",
"Nat.instOne",
"PosNum.pred'",
"congrArg",
"PosNum.pred'_to_nat",
"id",
"Num.pred.eq_2",
"castNum",
"Num",
"Nat"... | rw [pred, PosNum.pred'_to_nat]; rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.Tape | {
"line": 99,
"column": 2
} | {
"line": 101,
"column": 62
} | [
{
"pp": "Γ : Type ?u.4632\ninst✝ : Inhabited Γ\nl₁ l₂ : List Γ\nh : BlankRel l₁ l₂\n⊢ { l // BlankExtends l₁ l ∧ BlankExtends l₂ l }",
"usedConstants": [
"id",
"Subtype",
"LE.le",
"instLENat",
"dite",
"Subtype.mk",
"List",
"And",
"Turing.BlankExtends",
... | refine
if hl : l₁.length ≤ l₂.length then ⟨l₂, Or.elim h id fun h' ↦ ?_, BlankExtends.refl _⟩
else ⟨l₁, BlankExtends.refl _, Or.elim h (fun h' ↦ ?_) id⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Computability.Halting | {
"line": 324,
"column": 20
} | {
"line": 324,
"column": 34
} | [
{
"pp": "n : ℕ\nf : List.Vector ℕ n →. ℕ\ng : List.Vector ℕ (n + 1) →. ℕ\nhf : Partrec' f\nhg : Partrec' g\n⊢ Partrec' ((fun i ↦ Fin.cases f (fun i v ↦ ↑(some (v.get i))) i) 0)",
"usedConstants": [
"List.Vector.get",
"instNeZeroNatHAdd_1",
"PFun",
"List.Vector",
"Option.some",
... | simpa using hf | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Computability.Halting | {
"line": 324,
"column": 20
} | {
"line": 324,
"column": 34
} | [
{
"pp": "n : ℕ\nf : List.Vector ℕ n →. ℕ\ng : List.Vector ℕ (n + 1) →. ℕ\nhf : Partrec' f\nhg : Partrec' g\n⊢ Partrec' ((fun i ↦ Fin.cases f (fun i v ↦ ↑(some (v.get i))) i) 0)",
"usedConstants": [
"List.Vector.get",
"instNeZeroNatHAdd_1",
"PFun",
"List.Vector",
"Option.some",
... | simpa using hf | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.Halting | {
"line": 324,
"column": 20
} | {
"line": 324,
"column": 34
} | [
{
"pp": "n : ℕ\nf : List.Vector ℕ n →. ℕ\ng : List.Vector ℕ (n + 1) →. ℕ\nhf : Partrec' f\nhg : Partrec' g\n⊢ Partrec' ((fun i ↦ Fin.cases f (fun i v ↦ ↑(some (v.get i))) i) 0)",
"usedConstants": [
"List.Vector.get",
"instNeZeroNatHAdd_1",
"PFun",
"List.Vector",
"Option.some",
... | simpa using hf | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.Halting | {
"line": 342,
"column": 16
} | {
"line": 342,
"column": 30
} | [
{
"pp": "n m : ℕ\nf : List.Vector ℕ n → ℕ\ng : List.Vector ℕ n → List.Vector ℕ m\nhf : Partrec' ↑f\nhg : Vec g\ni : Fin m.succ\n⊢ Partrec' fun v ↦ ↑(some (((fun v ↦ f v ::ᵥ g v) v).get 0))",
"usedConstants": [
"List.Vector.get",
"Part",
"Eq.mpr",
"instNeZeroNatHAdd_1",
"congrAr... | simpa using hf | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Computability.Halting | {
"line": 342,
"column": 16
} | {
"line": 342,
"column": 30
} | [
{
"pp": "n m : ℕ\nf : List.Vector ℕ n → ℕ\ng : List.Vector ℕ n → List.Vector ℕ m\nhf : Partrec' ↑f\nhg : Vec g\ni : Fin m.succ\n⊢ Partrec' fun v ↦ ↑(some (((fun v ↦ f v ::ᵥ g v) v).get 0))",
"usedConstants": [
"List.Vector.get",
"Part",
"Eq.mpr",
"instNeZeroNatHAdd_1",
"congrAr... | simpa using hf | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.Halting | {
"line": 342,
"column": 16
} | {
"line": 342,
"column": 30
} | [
{
"pp": "n m : ℕ\nf : List.Vector ℕ n → ℕ\ng : List.Vector ℕ n → List.Vector ℕ m\nhf : Partrec' ↑f\nhg : Vec g\ni : Fin m.succ\n⊢ Partrec' fun v ↦ ↑(some (((fun v ↦ f v ::ᵥ g v) v).get 0))",
"usedConstants": [
"List.Vector.get",
"Part",
"Eq.mpr",
"instNeZeroNatHAdd_1",
"congrAr... | simpa using hf | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.StateTransition | {
"line": 249,
"column": 11
} | {
"line": 249,
"column": 13
} | [
{
"pp": "σ₁ σ₂ : Type u_1\nf₁ : σ₁ → Option σ₁\nf₂ : σ₂ → Option σ₂\ntr : σ₁ → σ₂\nH : Respects f₁ f₂ fun a b ↦ tr a = b\na₁ : σ₁\nb₂ : σ₂\nh✝ : b₂ ∈ tr <$> eval f₁ a₁\nb₁ : σ₁\nab : b₁ ∈ eval f₁ a₁\nbb : tr b₁ = b₂\nh : tr b₁ ∈ eval f₂ (tr a₁)\n⊢ b₂ ∈ eval f₂ (tr a₁)",
"usedConstants": [
"Part",
... | bb | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.RecursiveIn | {
"line": 73,
"column": 20
} | {
"line": 73,
"column": 46
} | [
{
"pp": "case rfind\nf f✝ : ℕ →. ℕ\na✝ : Nat.Partrec f✝\nih : RecursiveIn ∅ f✝\n⊢ RecursiveIn ∅ fun a ↦ Nat.rfind fun n ↦ (fun m ↦ decide (m = 0)) <$> f✝ (Nat.pair a n)",
"usedConstants": [
"PFun",
"RecursiveIn.rfind",
"Nat",
"Set.instEmptyCollection",
"EmptyCollection.emptyCol... | exact RecursiveIn.rfind ih | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Computability.RecursiveIn | {
"line": 73,
"column": 20
} | {
"line": 73,
"column": 46
} | [
{
"pp": "case rfind\nf f✝ : ℕ →. ℕ\na✝ : Nat.Partrec f✝\nih : RecursiveIn ∅ f✝\n⊢ RecursiveIn ∅ fun a ↦ Nat.rfind fun n ↦ (fun m ↦ decide (m = 0)) <$> f✝ (Nat.pair a n)",
"usedConstants": [
"PFun",
"RecursiveIn.rfind",
"Nat",
"Set.instEmptyCollection",
"EmptyCollection.emptyCol... | exact RecursiveIn.rfind ih | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.RecursiveIn | {
"line": 73,
"column": 20
} | {
"line": 73,
"column": 46
} | [
{
"pp": "case rfind\nf f✝ : ℕ →. ℕ\na✝ : Nat.Partrec f✝\nih : RecursiveIn ∅ f✝\n⊢ RecursiveIn ∅ fun a ↦ Nat.rfind fun n ↦ (fun m ↦ decide (m = 0)) <$> f✝ (Nat.pair a n)",
"usedConstants": [
"PFun",
"RecursiveIn.rfind",
"Nat",
"Set.instEmptyCollection",
"EmptyCollection.emptyCol... | exact RecursiveIn.rfind ih | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 378,
"column": 20
} | {
"line": 380,
"column": 81
} | [
{
"pp": "case branch\nΓ : Type u_1\nΛ : Type u_2\nσ : Type u_3\nq₁✝ q₀ : Stmt Γ Λ σ\nh₀₁ : q₀ ∈ stmts₁ q₁✝\np : Γ → σ → Bool\nq₁ q₂ : Stmt Γ Λ σ\nIH₁ : q₁✝ ∈ stmts₁ q₁ → q₀ ∈ stmts₁ q₁\nIH₂ : q₁✝ ∈ stmts₁ q₂ → q₀ ∈ stmts₁ q₂\nh₁₂ : q₁✝ ∈ stmts₁ (branch p q₁ q₂)\n⊢ q₀ ∈ stmts₁ (branch p q₁ q₂)",
"usedConstan... | (
simp only [stmts₁] at h₁₂ ⊢
simp only [Finset.mem_insert, Finset.mem_union, Finset.mem_singleton] at h₁₂) | Lean.Elab.Tactic.evalParen | Lean.Parser.Tactic.paren |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 378,
"column": 20
} | {
"line": 380,
"column": 81
} | [
{
"pp": "case goto\nΓ : Type u_1\nΛ : Type u_2\nσ : Type u_3\nq₁ q₀ : Stmt Γ Λ σ\nh₀₁ : q₀ ∈ stmts₁ q₁\nl : Γ → σ → Λ\nh₁₂ : q₁ ∈ stmts₁ (goto l)\n⊢ q₀ ∈ stmts₁ (goto l)",
"usedConstants": [
"Finset",
"Membership.mem",
"Eq.mp",
"id",
"Turing.TM1.stmts₁",
"Finset.instSetLi... | (
simp only [stmts₁] at h₁₂ ⊢
simp only [Finset.mem_insert, Finset.mem_union, Finset.mem_singleton] at h₁₂) | Lean.Elab.Tactic.evalParen | Lean.Parser.Tactic.paren |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 378,
"column": 20
} | {
"line": 380,
"column": 81
} | [
{
"pp": "case halt\nΓ : Type u_1\nΛ : Type u_2\nσ : Type u_3\nq₁ q₀ : Stmt Γ Λ σ\nh₀₁ : q₀ ∈ stmts₁ q₁\nh₁₂ : q₁ ∈ stmts₁ halt\n⊢ q₀ ∈ stmts₁ halt",
"usedConstants": [
"Finset",
"Membership.mem",
"Eq.mp",
"id",
"Turing.TM1.stmts₁",
"Turing.TM1.Stmt.halt",
"Finset.in... | (
simp only [stmts₁] at h₁₂ ⊢
simp only [Finset.mem_insert, Finset.mem_union, Finset.mem_singleton] at h₁₂) | Lean.Elab.Tactic.evalParen | Lean.Parser.Tactic.paren |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 378,
"column": 20
} | {
"line": 380,
"column": 81
} | [
{
"pp": "case move\nΓ : Type u_1\nΛ : Type u_2\nσ : Type u_3\nq₁ q₀ : Stmt Γ Λ σ\nh₀₁ : q₀ ∈ stmts₁ q₁\na✝ : Dir\nq : Stmt Γ Λ σ\nIH : q₁ ∈ stmts₁ q → q₀ ∈ stmts₁ q\nh₁₂ : q₁ ∈ stmts₁ (move a✝ q)\n⊢ q₀ ∈ stmts₁ (move a✝ q)",
"usedConstants": [
"_private.Mathlib.Computability.TuringMachine.PostTuringMa... | (
simp only [stmts₁] at h₁₂ ⊢
simp only [Finset.mem_insert, Finset.mem_union, Finset.mem_singleton] at h₁₂) | Lean.Elab.Tactic.evalParen | Lean.Parser.Tactic.paren |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 378,
"column": 20
} | {
"line": 380,
"column": 81
} | [
{
"pp": "case write\nΓ : Type u_1\nΛ : Type u_2\nσ : Type u_3\nq₁ q₀ : Stmt Γ Λ σ\nh₀₁ : q₀ ∈ stmts₁ q₁\na✝ : Γ → σ → Γ\nq : Stmt Γ Λ σ\nIH : q₁ ∈ stmts₁ q → q₀ ∈ stmts₁ q\nh₁₂ : q₁ ∈ stmts₁ (write a✝ q)\n⊢ q₀ ∈ stmts₁ (write a✝ q)",
"usedConstants": [
"_private.Mathlib.Computability.TuringMachine.Pos... | (
simp only [stmts₁] at h₁₂ ⊢
simp only [Finset.mem_insert, Finset.mem_union, Finset.mem_singleton] at h₁₂) | Lean.Elab.Tactic.evalParen | Lean.Parser.Tactic.paren |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 378,
"column": 20
} | {
"line": 380,
"column": 81
} | [
{
"pp": "case load\nΓ : Type u_1\nΛ : Type u_2\nσ : Type u_3\nq₁ q₀ : Stmt Γ Λ σ\nh₀₁ : q₀ ∈ stmts₁ q₁\na✝ : Γ → σ → σ\nq : Stmt Γ Λ σ\nIH : q₁ ∈ stmts₁ q → q₀ ∈ stmts₁ q\nh₁₂ : q₁ ∈ stmts₁ (load a✝ q)\n⊢ q₀ ∈ stmts₁ (load a✝ q)",
"usedConstants": [
"_private.Mathlib.Computability.TuringMachine.PostTu... | (
simp only [stmts₁] at h₁₂ ⊢
simp only [Finset.mem_insert, Finset.mem_union, Finset.mem_singleton] at h₁₂) | Lean.Elab.Tactic.evalParen | Lean.Parser.Tactic.paren |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 437,
"column": 15
} | {
"line": 437,
"column": 51
} | [
{
"pp": "Γ : Type u_1\nΛ : Type u_2\nσ : Type u_3\ninst✝¹ : Inhabited Λ\ninst✝ : Inhabited Γ\nM : Λ → Stmt Γ Λ σ\nS : Finset Λ\nss : Supports M S\nl₁ : Λ\nv : σ\nT : Tape Γ\nx✝ : Stmt Γ Λ σ\n⊢ SupportsStmt S x✝ → (stepAux x✝ v T).l ∈ Finset.insertNone S",
"usedConstants": [
"cond",
"Iff.mpr",
... | induction M l₁ generalizing v T with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 531,
"column": 4
} | {
"line": 531,
"column": 40
} | [
{
"pp": "case some\nΓ : Type u_1\nΛ : Type u_2\ninst✝² : Inhabited Λ\nσ : Type u_3\ninst✝¹ : Inhabited σ\nM : Λ → TM1.Stmt Γ Λ σ\ninst✝ : Inhabited Γ\nx✝¹ : TM1.Cfg Γ Λ σ\nv : σ\nT : Tape Γ\nl₁ : Λ\nx✝ : TM1.Stmt Γ Λ σ\n⊢ Reaches₁ (TM0.step (tr M)) { q := (some x✝, v), Tape := T }\n {\n q :=\n (m... | induction M l₁ generalizing v T with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.Num.Lemmas | {
"line": 796,
"column": 2
} | {
"line": 797,
"column": 68
} | [
{
"pp": "⊢ ∀ (m n : Num), ↑(m ||| n) = ↑m ||| ↑n",
"usedConstants": [
"PosNum.casesOn",
"cond",
"Num.bit",
"instHOrOfOrOp",
"Num.castNum_eq_bitwise",
"PosNum.lor",
"PosNum.bit1",
"PosNum.bit",
"instOnePosNum",
"Bool.true",
"HOr.hOr",
"P... | apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
(try rintro (_ | _)) <;> (try rintro (_ | _)) <;> intros <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.Num.Lemmas | {
"line": 796,
"column": 2
} | {
"line": 797,
"column": 68
} | [
{
"pp": "⊢ ∀ (m n : Num), ↑(m ||| n) = ↑m ||| ↑n",
"usedConstants": [
"PosNum.casesOn",
"cond",
"Num.bit",
"instHOrOfOrOp",
"Num.castNum_eq_bitwise",
"PosNum.lor",
"PosNum.bit1",
"PosNum.bit",
"instOnePosNum",
"Bool.true",
"HOr.hOr",
"P... | apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
(try rintro (_ | _)) <;> (try rintro (_ | _)) <;> intros <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.Lemmas | {
"line": 796,
"column": 2
} | {
"line": 797,
"column": 68
} | [
{
"pp": "⊢ ∀ (m n : Num), ↑(m ||| n) = ↑m ||| ↑n",
"usedConstants": [
"PosNum.casesOn",
"cond",
"Num.bit",
"instHOrOfOrOp",
"Num.castNum_eq_bitwise",
"PosNum.lor",
"PosNum.bit1",
"PosNum.bit",
"instOnePosNum",
"Bool.true",
"HOr.hOr",
"P... | apply castNum_eq_bitwise fun x y => pos (PosNum.lor x y) <;>
(try rintro (_ | _)) <;> (try rintro (_ | _)) <;> intros <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.RegularExpressions | {
"line": 288,
"column": 12
} | {
"line": 288,
"column": 56
} | [
{
"pp": "case mpr.cons.cons.nil\nα : Type u_1\ninst✝ : DecidableEq α\nP : RegularExpression α\na : α\nx : List α\nIH :\n ∀ (t : List α),\n t.length < (a :: x).length → (P.star.rmatch t = true ↔ ∃ S, t = S.flatten ∧ ∀ t ∈ S, t ≠ [] ∧ P.rmatch t = true)\nU : List (List α)\nhsum : a :: x = ([] :: U).flatten\nh... | simp only [not_true, Ne, false_and] at helem | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 275,
"column": 6
} | {
"line": 277,
"column": 26
} | [
{
"pp": "case branch\nK : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\ninst✝¹ : Inhabited Λ\ninst✝ : DecidableEq K\nM : Λ → Stmt Γ Λ σ\nS : Finset Λ\nss : Supports M S\nl₁ : Λ\np : σ → Bool\nq₁' q₂' : Stmt Γ Λ σ\nIH₁ : ∀ (v : σ) (T : (k : K) → List (Γ k)), SupportsStmt S q₁' → (stepAux q₁' v T).l ∈ F... | unfold stepAux; cases p v
· exact IH₂ _ _ hs.2
· exact IH₁ _ _ hs.1 | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 275,
"column": 6
} | {
"line": 277,
"column": 26
} | [
{
"pp": "case branch\nK : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\ninst✝¹ : Inhabited Λ\ninst✝ : DecidableEq K\nM : Λ → Stmt Γ Λ σ\nS : Finset Λ\nss : Supports M S\nl₁ : Λ\np : σ → Bool\nq₁' q₂' : Stmt Γ Λ σ\nIH₁ : ∀ (v : σ) (T : (k : K) → List (Γ k)), SupportsStmt S q₁' → (stepAux q₁' v T).l ∈ F... | unfold stepAux; cases p v
· exact IH₂ _ _ hs.2
· exact IH₁ _ _ hs.1 | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 644,
"column": 2
} | {
"line": 644,
"column": 91
} | [
{
"pp": "Γ : Type u_1\ninst✝¹ : Inhabited Γ\ninst✝ : Finite Γ\nn : ℕ\ne : Γ ≃ Fin n\nthis : DecidableEq Γ := e.decidableEq\nG : Fin n ↪ Fin n → Bool := { toFun := fun a b ↦ decide (a = b), inj' := ⋯ }\nH : Γ ↪ List.Vector Bool n := (e.toEmbedding.trans G).trans (Equiv.vectorEquivFin Bool n).symm.toEmbedding\nen... | exact ⟨_, enc, Function.invFun enc, H.setValue_eq _ _, Function.leftInverse_invFun enc.2⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 273,
"column": 15
} | {
"line": 273,
"column": 51
} | [
{
"pp": "K : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\ninst✝¹ : Inhabited Λ\ninst✝ : DecidableEq K\nM : Λ → Stmt Γ Λ σ\nS : Finset Λ\nss : Supports M S\nl₁ : Λ\nv : σ\nT : (k : K) → List (Γ k)\nx✝ : Stmt Γ Λ σ\n⊢ SupportsStmt S x✝ → (stepAux x✝ v T).l ∈ Finset.insertNone S",
"usedConstants": [... | induction M l₁ generalizing v T with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Computability.TuringMachine.Config | {
"line": 251,
"column": 8
} | {
"line": 252,
"column": 11
} | [
{
"pp": "m n : ℕ\nf : List.Vector ℕ n →. ℕ\ng : Fin n → List.Vector ℕ m →. ℕ\nhg✝ : ∀ (i : Fin n), ∃ c, ∀ (v : List.Vector ℕ m), c.eval ↑v = pure <$> g i v\ncg : Code\nhg : ∀ (v : List.Vector ℕ m), cg.eval ↑v = Subtype.val <$> Vector.mOfFn fun i ↦ g i v\ncf : Code\nhf : ∀ (v : List.Vector ℕ n), cf.eval ↑v = pur... | simp [hg, hf, map_bind]
rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.Config | {
"line": 251,
"column": 8
} | {
"line": 252,
"column": 11
} | [
{
"pp": "m n : ℕ\nf : List.Vector ℕ n →. ℕ\ng : Fin n → List.Vector ℕ m →. ℕ\nhg✝ : ∀ (i : Fin n), ∃ c, ∀ (v : List.Vector ℕ m), c.eval ↑v = pure <$> g i v\ncg : Code\nhg : ∀ (v : List.Vector ℕ m), cg.eval ↑v = Subtype.val <$> Vector.mOfFn fun i ↦ g i v\ncf : Code\nhf : ∀ (v : List.Vector ℕ n), cf.eval ↑v = pur... | simp [hg, hf, map_bind]
rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringDegree | {
"line": 71,
"column": 18
} | {
"line": 71,
"column": 44
} | [
{
"pp": "case rfind\nf g f✝ : ℕ →. ℕ\na✝ : Nat.Partrec f✝\nih : f✝ ≤ᵀ g\n⊢ (fun a ↦ Nat.rfind fun n ↦ (fun m ↦ decide (m = 0)) <$> f✝ (Nat.pair a n)) ≤ᵀ g",
"usedConstants": [
"PFun",
"Set.instSingletonSet",
"RecursiveIn.rfind",
"Nat",
"Singleton.singleton",
"Set"
]
... | exact RecursiveIn.rfind ih | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Computability.TuringDegree | {
"line": 71,
"column": 18
} | {
"line": 71,
"column": 44
} | [
{
"pp": "case rfind\nf g f✝ : ℕ →. ℕ\na✝ : Nat.Partrec f✝\nih : f✝ ≤ᵀ g\n⊢ (fun a ↦ Nat.rfind fun n ↦ (fun m ↦ decide (m = 0)) <$> f✝ (Nat.pair a n)) ≤ᵀ g",
"usedConstants": [
"PFun",
"Set.instSingletonSet",
"RecursiveIn.rfind",
"Nat",
"Singleton.singleton",
"Set"
]
... | exact RecursiveIn.rfind ih | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringDegree | {
"line": 71,
"column": 18
} | {
"line": 71,
"column": 44
} | [
{
"pp": "case rfind\nf g f✝ : ℕ →. ℕ\na✝ : Nat.Partrec f✝\nih : f✝ ≤ᵀ g\n⊢ (fun a ↦ Nat.rfind fun n ↦ (fun m ↦ decide (m = 0)) <$> f✝ (Nat.pair a n)) ≤ᵀ g",
"usedConstants": [
"PFun",
"Set.instSingletonSet",
"RecursiveIn.rfind",
"Nat",
"Singleton.singleton",
"Set"
]
... | exact RecursiveIn.rfind ih | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringDegree | {
"line": 98,
"column": 18
} | {
"line": 98,
"column": 44
} | [
{
"pp": "case rfind\nf g h : ℕ →. ℕ\nhh : g ≤ᵀ h\nf✝ : ℕ →. ℕ\nhf✝ : RecursiveIn {g} f✝\nih : f✝ ≤ᵀ h\n⊢ (fun a ↦ Nat.rfind fun n ↦ (fun m ↦ decide (m = 0)) <$> f✝ (Nat.pair a n)) ≤ᵀ h",
"usedConstants": [
"PFun",
"Set.instSingletonSet",
"RecursiveIn.rfind",
"Nat",
"Singleton.s... | exact RecursiveIn.rfind ih | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Computability.TuringDegree | {
"line": 98,
"column": 18
} | {
"line": 98,
"column": 44
} | [
{
"pp": "case rfind\nf g h : ℕ →. ℕ\nhh : g ≤ᵀ h\nf✝ : ℕ →. ℕ\nhf✝ : RecursiveIn {g} f✝\nih : f✝ ≤ᵀ h\n⊢ (fun a ↦ Nat.rfind fun n ↦ (fun m ↦ decide (m = 0)) <$> f✝ (Nat.pair a n)) ≤ᵀ h",
"usedConstants": [
"PFun",
"Set.instSingletonSet",
"RecursiveIn.rfind",
"Nat",
"Singleton.s... | exact RecursiveIn.rfind ih | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringDegree | {
"line": 98,
"column": 18
} | {
"line": 98,
"column": 44
} | [
{
"pp": "case rfind\nf g h : ℕ →. ℕ\nhh : g ≤ᵀ h\nf✝ : ℕ →. ℕ\nhf✝ : RecursiveIn {g} f✝\nih : f✝ ≤ᵀ h\n⊢ (fun a ↦ Nat.rfind fun n ↦ (fun m ↦ decide (m = 0)) <$> f✝ (Nat.pair a n)) ≤ᵀ h",
"usedConstants": [
"PFun",
"Set.instSingletonSet",
"RecursiveIn.rfind",
"Nat",
"Singleton.s... | exact RecursiveIn.rfind ih | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 709,
"column": 6
} | {
"line": 709,
"column": 26
} | [
{
"pp": "K : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\ninst✝² : DecidableEq K\ninst✝¹ : Inhabited Λ\ninst✝ : Inhabited σ\nk : K\nL : List (Γ k)\n⊢ TrCfg (TM2.init k L) (TM1.init (trInit k L))",
"usedConstants": [
"Eq.mpr",
"Turing.TM2to1.trInit",
"Turing.TM1.init",
"con... | (_ : TM1.init _ = _) | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 718,
"column": 4
} | {
"line": 720,
"column": 94
} | [
{
"pp": "case pos\nK : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\ninst✝² : DecidableEq K\ninst✝¹ : Inhabited Λ\ninst✝ : Inhabited σ\nk : K\nL : List (Γ k)\nk' : K\ni : ℕ\nthis : ((proj k').f ∘ fun a ↦ update default k (some a)) = fun a ↦ (proj k').f (update default k (some a))\nh : k' = k\n⊢ (Optio... | · subst k'
simp only [Function.update_self]
rw [ListBlank.nth_mk, List.getI_eq_getElem?_getD, ← List.map_reverse, List.getElem?_map] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Topology.Category.CompHausLike.Basic | {
"line": 241,
"column": 22
} | {
"line": 241,
"column": 52
} | [
{
"pp": "P : TopCat → Prop\nX : Type u\ninst✝³ : TopologicalSpace X\ninst✝² : CompactSpace X\ninst✝¹ : T2Space X\ninst✝ : HasProp P X\nA B : CompHausLike P\nf : A ⟶ B\nhf : IsIso ((forget (CompHausLike P)).map f)\n⊢ IsIso f",
"usedConstants": [
"CategoryTheory.IsIso",
"congrArg",
"Continuo... | rw [isIso_iff_bijective] at hf | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case move.move\np✝¹ : Γ' → Bool\nk₁✝¹ k₂✝¹ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\n⊢ Decidable (move p✝¹ k₁✝¹ k₂✝¹ q✝¹ = move p✝ k₁✝ k₂✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.move.noConfusion",
"Turing.Part... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case move.move\np✝¹ : Γ' → Bool\nk₁✝¹ k₂✝¹ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\n⊢ Decidable (move p✝¹ k₁✝¹ k₂✝¹ q✝¹ = move p✝ k₁✝ k₂✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.move.noConfusion",
"Turing.Part... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case move.clear\np✝¹ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\n⊢ Decidable (move p✝¹ k₁✝ k₂✝ q✝¹ = clear p✝ k✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case move.clear\np✝¹ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\n⊢ Decidable (move p✝¹ k₁✝ k₂✝ q✝¹ = clear p✝ k✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case move.copy\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (move p✝ k₁✝ k₂✝ q✝¹ = q✝.copy)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq.casesO... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case move.copy\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (move p✝ k₁✝ k₂✝ q✝¹ = q✝.copy)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq.casesO... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case move.push\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\n⊢ Decidable (move p✝ k₁✝ k₂✝ q✝¹ = push k✝ s✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"HEq.refl",
"False.eli... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case move.push\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\n⊢ Decidable (move p✝ k₁✝ k₂✝ q✝¹ = push k✝ s✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"HEq.refl",
"False.eli... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case move.read\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nf✝ : Option Γ' → Λ'\n⊢ Decidable (move p✝ k₁✝ k₂✝ q✝ = read f✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noConfusion_of_Nat",
... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case move.read\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nf✝ : Option Γ' → Λ'\n⊢ Decidable (move p✝ k₁✝ k₂✝ q✝ = read f✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noConfusion_of_Nat",
... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case move.succ\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (move p✝ k₁✝ k₂✝ q✝¹ = q✝.succ)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'.succ",
"Turi... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case move.succ\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (move p✝ k₁✝ k₂✝ q✝¹ = q✝.succ)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'.succ",
"Turi... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case move.pred\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nq₁✝ q₂✝ : Λ'\n⊢ Decidable (move p✝ k₁✝ k₂✝ q✝ = q₁✝.pred q₂✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case move.pred\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nq₁✝ q₂✝ : Λ'\n⊢ Decidable (move p✝ k₁✝ k₂✝ q✝ = q₁✝.pred q₂✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case move.ret\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nk✝ : Cont'\n⊢ Decidable (move p✝ k₁✝ k₂✝ q✝ = ret k✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn"... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case move.ret\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nk✝ : Cont'\n⊢ Decidable (move p✝ k₁✝ k₂✝ q✝ = ret k✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn"... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case clear.move\np✝¹ : Γ' → Bool\nk✝ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\n⊢ Decidable (clear p✝¹ k✝ q✝¹ = move p✝ k₁✝ k₂✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case clear.move\np✝¹ : Γ' → Bool\nk✝ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\n⊢ Decidable (clear p✝¹ k✝ q✝¹ = move p✝ k₁✝ k₂✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case clear.clear\np✝¹ : Γ' → Bool\nk✝¹ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\n⊢ Decidable (clear p✝¹ k✝¹ q✝¹ = clear p✝ k✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Γ'",
"HEq.refl",
"sorryAx",
"Turing.Part... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case clear.clear\np✝¹ : Γ' → Bool\nk✝¹ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\n⊢ Decidable (clear p✝¹ k✝¹ q✝¹ = clear p✝ k✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Γ'",
"HEq.refl",
"sorryAx",
"Turing.Part... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case clear.copy\np✝ : Γ' → Bool\nk✝ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (clear p✝ k✝ q✝¹ = q✝.copy)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Turing.PartrecToT... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case clear.copy\np✝ : Γ' → Bool\nk✝ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (clear p✝ k✝ q✝¹ = q✝.copy)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Turing.PartrecToT... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case clear.push\np✝ : Γ' → Bool\nk✝¹ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\n⊢ Decidable (clear p✝ k✝¹ q✝¹ = push k✝ s✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"HEq.refl",
"False.elim",
... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case clear.push\np✝ : Γ' → Bool\nk✝¹ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\n⊢ Decidable (clear p✝ k✝¹ q✝¹ = push k✝ s✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"HEq.refl",
"False.elim",
... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case clear.read\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nf✝ : Option Γ' → Λ'\n⊢ Decidable (clear p✝ k✝ q✝ = read f✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noConfusion_of_Nat",
"Tur... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case clear.read\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nf✝ : Option Γ' → Λ'\n⊢ Decidable (clear p✝ k✝ q✝ = read f✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noConfusion_of_Nat",
"Tur... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case clear.succ\np✝ : Γ' → Bool\nk✝ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (clear p✝ k✝ q✝¹ = q✝.succ)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'.succ",
"Turing.Partr... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case clear.succ\np✝ : Γ' → Bool\nk✝ : K'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (clear p✝ k✝ q✝¹ = q✝.succ)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'.succ",
"Turing.Partr... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case clear.pred\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nq₁✝ q₂✝ : Λ'\n⊢ Decidable (clear p✝ k✝ q✝ = q₁✝.pred q₂✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Turing.Par... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case clear.pred\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nq₁✝ q₂✝ : Λ'\n⊢ Decidable (clear p✝ k✝ q✝ = q₁✝.pred q₂✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Turing.Par... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case clear.ret\np✝ : Γ' → Bool\nk✝¹ : K'\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nk✝ : Cont'\n⊢ Decidable (clear p✝ k✝¹ q✝ = ret k✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Turing.PartrecToT... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case clear.ret\np✝ : Γ' → Bool\nk✝¹ : K'\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nk✝ : Cont'\n⊢ Decidable (clear p✝ k✝¹ q✝ = ret k✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Turing.PartrecToT... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case copy.move\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\n⊢ Decidable (q✝¹.copy = move p✝ k₁✝ k₂✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq.casesO... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case copy.move\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\n⊢ Decidable (q✝¹.copy = move p✝ k₁✝ k₂✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq.casesO... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case copy.clear\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\n⊢ Decidable (q✝¹.copy = clear p✝ k✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Turing.PartrecToT... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case copy.clear\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\n⊢ Decidable (q✝¹.copy = clear p✝ k✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Turing.PartrecToT... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case copy.copy\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (q✝¹.copy = q✝.copy)",
"usedConstants": [
"False",
"HEq.refl",
"sorryAx",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn",
"instOfNatNat",
"Lean.Name.num",
"Lean.Name.str",
... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case copy.copy\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (q✝¹.copy = q✝.copy)",
"usedConstants": [
"False",
"HEq.refl",
"sorryAx",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn",
"instOfNatNat",
"Lean.Name.num",
"Lean.Name.str",
... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case copy.push\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\n⊢ Decidable (q✝¹.copy = push k✝ s✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Tu... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case copy.push\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\n⊢ Decidable (q✝¹.copy = push k✝ s✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Tu... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case copy.read\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nf✝ : Option Γ' → Λ'\n⊢ Decidable (q✝.copy = read f✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq.c... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case copy.read\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nf✝ : Option Γ' → Λ'\n⊢ Decidable (q✝.copy = read f✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq.c... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case copy.succ\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (q✝¹.copy = q✝.succ)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'.succ",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn",
... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case copy.succ\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (q✝¹.copy = q✝.succ)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'.succ",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn",
... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case copy.pred\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nq₁✝ q₂✝ : Λ'\n⊢ Decidable (q✝.copy = q₁✝.pred q₂✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn",
"Turing.PartrecToTM2.Λ'.... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case copy.pred\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nq₁✝ q₂✝ : Λ'\n⊢ Decidable (q✝.copy = q₁✝.pred q₂✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn",
"Turing.PartrecToTM2.Λ'.... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case copy.ret\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nk✝ : Cont'\n⊢ Decidable (q✝.copy = ret k✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn",
"Turing.PartrecToTM2.Λ'.ret",
... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case copy.ret\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nk✝ : Cont'\n⊢ Decidable (q✝.copy = ret k✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn",
"Turing.PartrecToTM2.Λ'.ret",
... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case push.move\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\n⊢ Decidable (push k✝ s✝ q✝¹ = move p✝ k₁✝ k₂✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"HEq.refl",
"False.eli... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case push.move\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\n⊢ Decidable (push k✝ s✝ q✝¹ = move p✝ k₁✝ k₂✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"HEq.refl",
"False.eli... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case push.clear\nk✝¹ : K'\ns✝ : Option Γ' → Option Γ'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\n⊢ Decidable (push k✝¹ s✝ q✝¹ = clear p✝ k✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"HEq.refl",
"False.elim",
... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case push.clear\nk✝¹ : K'\ns✝ : Option Γ' → Option Γ'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\n⊢ Decidable (push k✝¹ s✝ q✝¹ = clear p✝ k✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"HEq.refl",
"False.elim",
... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.