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.Computability.TuringMachine.ToPartrec | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 48
} | [
{
"pp": "case push.copy\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (push k✝ s✝ q✝¹ = q✝.copy)",
"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 push.copy\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (push k✝ s✝ q✝¹ = q✝.copy)",
"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 push.push\nk✝¹ : K'\ns✝¹ : Option Γ' → Option Γ'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\n⊢ Decidable (push k✝¹ s✝¹ q✝¹ = push k✝ s✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Γ'",
"Turing.PartrecToTM2.Λ'.pus... | 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.push\nk✝¹ : K'\ns✝¹ : Option Γ' → Option Γ'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\n⊢ Decidable (push k✝¹ s✝¹ q✝¹ = push k✝ s✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Γ'",
"Turing.PartrecToTM2.Λ'.pus... | 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.read\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nf✝ : Option Γ' → Λ'\n⊢ Decidable (push k✝ s✝ q✝ = read f✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"Fals... | 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.read\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nf✝ : Option Γ' → Λ'\n⊢ Decidable (push k✝ s✝ q✝ = read f✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"Fals... | 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.succ\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (push k✝ s✝ q✝¹ = q✝.succ)",
"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 push.succ\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (push k✝ s✝ q✝¹ = q✝.succ)",
"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 push.pred\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nq₁✝ q₂✝ : Λ'\n⊢ Decidable (push k✝ s✝ q✝ = q₁✝.pred q₂✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"HEq.refl",
"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 push.pred\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nq₁✝ q₂✝ : Λ'\n⊢ Decidable (push k✝ s✝ q✝ = q₁✝.pred q₂✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"HEq.refl",
"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 push.ret\nk✝¹ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nk✝ : Cont'\n⊢ Decidable (push k✝¹ s✝ q✝ = ret k✝)",
"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 push.ret\nk✝¹ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nk✝ : Cont'\n⊢ Decidable (push k✝¹ s✝ q✝ = ret k✝)",
"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 read.move\nf✝ : Option Γ' → Λ'\nf_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\n⊢ Decidable (read f✝ = move p✝ k₁✝ k₂✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noC... | 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 read.move\nf✝ : Option Γ' → Λ'\nf_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\n⊢ Decidable (read f✝ = move p✝ k₁✝ k₂✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noC... | 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 read.clear\nf✝ : Option Γ' → Λ'\nf_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\n⊢ Decidable (read f✝ = clear p✝ k✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noConfusion... | 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 read.clear\nf✝ : Option Γ' → Λ'\nf_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\n⊢ Decidable (read f✝ = clear p✝ k✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noConfusion... | 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 read.copy\nf✝ : Option Γ' → Λ'\nf_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)\nq✝ : Λ'\n⊢ Decidable (read f✝ = q✝.copy)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecTo... | 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 read.copy\nf✝ : Option Γ' → Λ'\nf_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)\nq✝ : Λ'\n⊢ Decidable (read f✝ = q✝.copy)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecTo... | 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 read.push\nf✝ : Option Γ' → Λ'\nf_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\n⊢ Decidable (read f✝ = push k✝ s✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"HEq.refl",
"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 read.push\nf✝ : Option Γ' → Λ'\nf_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\n⊢ Decidable (read f✝ = push k✝ s✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"HEq.refl",
"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 read.read\nf✝¹ : Option Γ' → Λ'\nf_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝¹ a = b)\nf✝ : Option Γ' → Λ'\n⊢ Decidable (read f✝¹ = read f✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Γ'",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"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 read.read\nf✝¹ : Option Γ' → Λ'\nf_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝¹ a = b)\nf✝ : Option Γ' → Λ'\n⊢ Decidable (read f✝¹ = read f✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Γ'",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"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 read.succ\nf✝ : Option Γ' → Λ'\nf_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)\nq✝ : Λ'\n⊢ Decidable (read f✝ = q✝.succ)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecTo... | 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 read.succ\nf✝ : Option Γ' → Λ'\nf_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)\nq✝ : Λ'\n⊢ Decidable (read f✝ = q✝.succ)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecTo... | 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 read.pred\nf✝ : Option Γ' → Λ'\nf_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)\nq₁✝ q₂✝ : Λ'\n⊢ Decidable (read f✝ = q₁✝.pred q₂✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"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 read.pred\nf✝ : Option Γ' → Λ'\nf_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)\nq₁✝ q₂✝ : Λ'\n⊢ Decidable (read f✝ = q₁✝.pred q₂✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"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 read.ret\nf✝ : Option Γ' → Λ'\nf_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)\nk✝ : Cont'\n⊢ Decidable (read f✝ = ret k✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecT... | 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 read.ret\nf✝ : Option Γ' → Λ'\nf_ih✝ : (a : Option Γ') → (b : Λ') → Decidable (f✝ a = b)\nk✝ : Cont'\n⊢ Decidable (read f✝ = ret k✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecT... | 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 succ.move\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\n⊢ Decidable (q✝¹.succ = move p✝ k₁✝ k₂✝ q✝)",
"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 succ.move\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\n⊢ Decidable (q✝¹.succ = move p✝ k₁✝ k₂✝ q✝)",
"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 succ.clear\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\n⊢ Decidable (q✝¹.succ = clear p✝ k✝ q✝)",
"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 succ.clear\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\n⊢ Decidable (q✝¹.succ = clear p✝ k✝ q✝)",
"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 succ.copy\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (q✝¹.succ = q✝.copy)",
"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 succ.copy\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (q✝¹.succ = q✝.copy)",
"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 succ.push\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\n⊢ Decidable (q✝¹.succ = 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 succ.push\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\n⊢ Decidable (q✝¹.succ = 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 succ.read\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nf✝ : Option Γ' → Λ'\n⊢ Decidable (q✝.succ = read f✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'.succ",
... | 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 succ.read\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nf✝ : Option Γ' → Λ'\n⊢ Decidable (q✝.succ = read f✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'.succ",
... | 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 succ.succ\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (q✝¹.succ = q✝.succ)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.succ",
"sorryAx",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn",
"instOfNatNat",
"Le... | 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 succ.succ\nq✝¹ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝¹ = b)\nq✝ : Λ'\n⊢ Decidable (q✝¹.succ = q✝.succ)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.succ",
"sorryAx",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn",
"instOfNatNat",
"Le... | 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 succ.pred\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nq₁✝ q₂✝ : Λ'\n⊢ Decidable (q✝.succ = q₁✝.pred q₂✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'.succ",
"Turing.PartrecToTM2.Λ'",
"Eq.cas... | 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 succ.pred\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nq₁✝ q₂✝ : Λ'\n⊢ Decidable (q✝.succ = q₁✝.pred q₂✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'.succ",
"Turing.PartrecToTM2.Λ'",
"Eq.cas... | 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 succ.ret\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nk✝ : Cont'\n⊢ Decidable (q✝.succ = ret k✝)",
"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 succ.ret\nq✝ : Λ'\nq_ih✝ : (b : Λ') → Decidable (q✝ = b)\nk✝ : Cont'\n⊢ Decidable (q✝.succ = ret k✝)",
"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 pred.move\nq₁✝ q₂✝ : Λ'\nq₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)\nq₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\n⊢ Decidable (q₁✝.pred q₂✝ = move p✝ k₁✝ k₂✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"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 pred.move\nq₁✝ q₂✝ : Λ'\nq₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)\nq₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\n⊢ Decidable (q₁✝.pred q₂✝ = move p✝ k₁✝ k₂✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"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 pred.clear\nq₁✝ q₂✝ : Λ'\nq₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)\nq₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\n⊢ Decidable (q₁✝.pred q₂✝ = clear p✝ k✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"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 pred.clear\nq₁✝ q₂✝ : Λ'\nq₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)\nq₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\n⊢ Decidable (q₁✝.pred q₂✝ = clear p✝ k✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"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 pred.copy\nq₁✝ q₂✝ : Λ'\nq₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)\nq₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)\nq✝ : Λ'\n⊢ Decidable (q₁✝.pred q₂✝ = q✝.copy)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"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 pred.copy\nq₁✝ q₂✝ : Λ'\nq₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)\nq₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)\nq✝ : Λ'\n⊢ Decidable (q₁✝.pred q₂✝ = q✝.copy)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"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 pred.push\nq₁✝ q₂✝ : Λ'\nq₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)\nq₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\n⊢ Decidable (q₁✝.pred q₂✝ = push k✝ s✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"HEq.refl",
"... | 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 pred.push\nq₁✝ q₂✝ : Λ'\nq₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)\nq₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\n⊢ Decidable (q₁✝.pred q₂✝ = push k✝ s✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"HEq.refl",
"... | 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 pred.read\nq₁✝ q₂✝ : Λ'\nq₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)\nq₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)\nf✝ : Option Γ' → Λ'\n⊢ Decidable (q₁✝.pred q₂✝ = read f✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noConfusion... | 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 pred.read\nq₁✝ q₂✝ : Λ'\nq₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)\nq₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)\nf✝ : Option Γ' → Λ'\n⊢ Decidable (q₁✝.pred q₂✝ = read f✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"False.elim",
"noConfusion... | 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 pred.succ\nq₁✝ q₂✝ : Λ'\nq₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)\nq₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)\nq✝ : Λ'\n⊢ Decidable (q₁✝.pred q₂✝ = q✝.succ)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'.succ",
... | 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 pred.succ\nq₁✝ q₂✝ : Λ'\nq₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)\nq₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)\nq✝ : Λ'\n⊢ Decidable (q₁✝.pred q₂✝ = q✝.succ)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'.succ",
... | 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 pred.pred\nq₁✝¹ q₂✝¹ : Λ'\nq₁_ih✝ : (b : Λ') → Decidable (q₁✝¹ = b)\nq₂_ih✝ : (b : Λ') → Decidable (q₂✝¹ = b)\nq₁✝ q₂✝ : Λ'\n⊢ Decidable (q₁✝¹.pred q₂✝¹ = q₁✝.pred q₂✝)",
"usedConstants": [
"False",
"HEq.refl",
"sorryAx",
"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 pred.pred\nq₁✝¹ q₂✝¹ : Λ'\nq₁_ih✝ : (b : Λ') → Decidable (q₁✝¹ = b)\nq₂_ih✝ : (b : Λ') → Decidable (q₂✝¹ = b)\nq₁✝ q₂✝ : Λ'\n⊢ Decidable (q₁✝¹.pred q₂✝¹ = q₁✝.pred q₂✝)",
"usedConstants": [
"False",
"HEq.refl",
"sorryAx",
"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 pred.ret\nq₁✝ q₂✝ : Λ'\nq₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)\nq₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)\nk✝ : Cont'\n⊢ Decidable (q₁✝.pred q₂✝ = ret k✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"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 pred.ret\nq₁✝ q₂✝ : Λ'\nq₁_ih✝ : (b : Λ') → Decidable (q₁✝ = b)\nq₂_ih✝ : (b : Λ') → Decidable (q₂✝ = b)\nk✝ : Cont'\n⊢ Decidable (q₁✝.pred q₂✝ = ret k✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"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 ret.move\nk✝ : Cont'\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\n⊢ Decidable (ret k✝ = move p✝ k₁✝ k₂✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn",
"Turing.PartrecToTM2.Λ'.move",
... | 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 ret.move\nk✝ : Cont'\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq✝ : Λ'\n⊢ Decidable (ret k✝ = move p✝ k₁✝ k₂✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn",
"Turing.PartrecToTM2.Λ'.move",
... | 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 ret.clear\nk✝¹ : Cont'\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\n⊢ Decidable (ret k✝¹ = clear p✝ k✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Turing.PartrecToTM2.Λ'.clear",
"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 ret.clear\nk✝¹ : Cont'\np✝ : Γ' → Bool\nk✝ : K'\nq✝ : Λ'\n⊢ Decidable (ret k✝¹ = clear p✝ k✝ q✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Turing.PartrecToTM2.Λ'.clear",
"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 ret.copy\nk✝ : Cont'\nq✝ : Λ'\n⊢ Decidable (ret k✝ = q✝.copy)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn",
"Turing.PartrecToTM2.Λ'.ret",
"Turing.PartrecToTM2.Λ'.copy",
... | 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 ret.copy\nk✝ : Cont'\nq✝ : Λ'\n⊢ Decidable (ret k✝ = q✝.copy)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn",
"Turing.PartrecToTM2.Λ'.ret",
"Turing.PartrecToTM2.Λ'.copy",
... | 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 ret.push\nk✝¹ : Cont'\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\n⊢ Decidable (ret k✝¹ = push k✝ s✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"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 ret.push\nk✝¹ : Cont'\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq✝ : Λ'\n⊢ Decidable (ret k✝¹ = push k✝ s✝ q✝)",
"usedConstants": [
"False",
"Turing.PartrecToTM2.Λ'.push",
"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 ret.read\nk✝ : Cont'\nf✝ : Option Γ' → Λ'\n⊢ Decidable (ret k✝ = read f✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"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 ret.read\nk✝ : Cont'\nf✝ : Option Γ' → Λ'\n⊢ Decidable (ret k✝ = read f✝)",
"usedConstants": [
"False",
"HEq.refl",
"Turing.PartrecToTM2.Λ'.read",
"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 ret.succ\nk✝ : Cont'\nq✝ : Λ'\n⊢ Decidable (ret k✝ = q✝.succ)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'.succ",
"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 ret.succ\nk✝ : Cont'\nq✝ : Λ'\n⊢ Decidable (ret k✝ = q✝.succ)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'.succ",
"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 ret.pred\nk✝ : Cont'\nq₁✝ q₂✝ : Λ'\n⊢ Decidable (ret k✝ = q₁✝.pred q₂✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn",
"Turing.PartrecToTM2.Λ'.ret",
"Eq.refl",
"HEq",
... | 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 ret.pred\nk✝ : Cont'\nq₁✝ q₂✝ : Λ'\n⊢ Decidable (ret k✝ = q₁✝.pred q₂✝)",
"usedConstants": [
"False",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn",
"Turing.PartrecToTM2.Λ'.ret",
"Eq.refl",
"HEq",
... | 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 ret.ret\nk✝¹ k✝ : Cont'\n⊢ Decidable (ret k✝¹ = ret k✝)",
"usedConstants": [
"Turing.PartrecToTM2.Cont'",
"False",
"HEq.refl",
"sorryAx",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn",
"instOfNatNat",
"Lean.Name.num",
"Lean.Name.str",
"Lean.... | 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 ret.ret\nk✝¹ k✝ : Cont'\n⊢ Decidable (ret k✝¹ = ret k✝)",
"usedConstants": [
"Turing.PartrecToTM2.Cont'",
"False",
"HEq.refl",
"sorryAx",
"Turing.PartrecToTM2.Λ'",
"Eq.casesOn",
"instOfNatNat",
"Lean.Name.num",
"Lean.Name.str",
"Lean.... | apply Decidable.isFalse; rintro ⟨⟨⟩⟩; done | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 644,
"column": 4
} | {
"line": 644,
"column": 67
} | [
{
"pp": "case cons\np : Γ' → Bool\nk : K'\nq : Λ'\no : Option Γ'\nL₂ : List Γ'\na : Γ'\nL₁ : List Γ'\nIH :\n ∀ {s : Option Γ'} {S : K' → List Γ'},\n splitAtPred p (S k) = (L₁, o, L₂) →\n Reaches₁ (TM2.step tr) { l := some (Λ'.clear p k q), var := s, stk := S }\n { l := some q, var := o, stk := u... | rcases e₁ : S k with - | ⟨a', Sk⟩ <;> rw [e₁, splitAtPred] at e | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Topology.Separation.Profinite | {
"line": 102,
"column": 4
} | {
"line": 108,
"column": 29
} | [
{
"pp": "H : Type u_3\ninst✝³ : TopologicalSpace H\ninst✝² : LocallyCompactSpace H\ninst✝¹ : T2Space H\ninst✝ : TotallyDisconnectedSpace H\nU : Set H\nhU : IsOpen U\ns : Set H\ncomp : IsCompact s\nsU : s ⊆ U\nu : Set ↑s := Subtype.val ⁻¹' interior s\nu_open_in_s : IsOpen u\nx : { x // x ∈ s }\nmemU : ↑x ∈ U\nxs... | have f1 : IsOpenEmbedding ((↑) : u → H) := by
refine ⟨f0, ?_⟩
· have : Set.range ((↑) : u → H) = interior s := by
rw [this, Set.range_comp, Subtype.range_coe, Subtype.image_preimage_coe]
apply Set.inter_eq_self_of_subset_right interior_subset
rw [this]
apply isOpen_interi... | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 900,
"column": 37
} | {
"line": 900,
"column": 51
} | [
{
"pp": "case cons.succ\nf : Code\nk : Cont\nIH :\n ∀ (v : List ℕ) (s : Option Γ'),\n ∃ b₂,\n TrCfg (stepRet k v) b₂ ∧\n Reaches₁ (TM2.step tr) { l := some (Λ'.ret (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }\n b₂\ns : Option Γ'\ntail✝ : List ℕ\nn : ℕ\n⊢ if n + ... | Nat.cast_succ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1205,
"column": 4
} | {
"line": 1205,
"column": 16
} | [
{
"pp": "case cons\nS : Finset Λ'\nf fs : Code\nIHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S\nIHfs : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Supports (codeSupp' fs k) S\nk : Cont'\nH : codeSupp (f.cons fs) k ⊆ S\n⊢ Supports (codeSupp' (f.cons fs) k) S",
"usedConstants": [
"Finset",
... | have H' := H | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1218,
"column": 4
} | {
"line": 1218,
"column": 16
} | [
{
"pp": "case comp\nS : Finset Λ'\nf g : Code\nIHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S\nIHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Supports (codeSupp' g k) S\nk : Cont'\nH : codeSupp (f.comp g) k ⊆ S\n⊢ Supports (codeSupp' (f.comp g) k) S",
"usedConstants": [
"Finset",
"T... | have H' := H | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1226,
"column": 4
} | {
"line": 1226,
"column": 16
} | [
{
"pp": "case case\nS : Finset Λ'\nf g : Code\nIHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S\nIHg : ∀ {k : Cont'}, codeSupp g k ⊆ S → Supports (codeSupp' g k) S\nk : Cont'\nH : codeSupp (f.case g) k ⊆ S\n⊢ Supports (codeSupp' (f.case g) k) S",
"usedConstants": [
"Finset",
"T... | have H' := H | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1230,
"column": 4
} | {
"line": 1230,
"column": 16
} | [
{
"pp": "case fix\nS : Finset Λ'\nf : Code\nIHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S\nk : Cont'\nH : codeSupp f.fix k ⊆ S\n⊢ Supports (codeSupp' f.fix k) S",
"usedConstants": [
"Finset",
"Turing.PartrecToTM2.Λ'",
"HasSubset.Subset",
"Turing.PartrecToTM2.code... | have H' := H | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1250,
"column": 4
} | {
"line": 1250,
"column": 16
} | [
{
"pp": "case cons₂\nS : Finset Λ'\nk : Cont'\nIH : contSupp k ⊆ S → Supports (contSupp k) S\nH : contSupp k.cons₂ ⊆ S\n⊢ Supports (contSupp k.cons₂) S",
"usedConstants": [
"Finset",
"Turing.PartrecToTM2.Cont'.cons₂",
"Turing.PartrecToTM2.Λ'",
"HasSubset.Subset",
"Turing.Partre... | have H' := H | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1253,
"column": 4
} | {
"line": 1253,
"column": 16
} | [
{
"pp": "case comp\nS : Finset Λ'\nf : Code\nk : Cont'\nIH : contSupp k ⊆ S → Supports (contSupp k) S\nH : contSupp (Cont'.comp f k) ⊆ S\n⊢ Supports (contSupp (Cont'.comp f k)) S",
"usedConstants": [
"Finset",
"Turing.PartrecToTM2.Λ'",
"HasSubset.Subset",
"Turing.PartrecToTM2.Cont'.c... | have H' := H | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Topology.Category.LightProfinite.Basic | {
"line": 197,
"column": 2
} | {
"line": 197,
"column": 32
} | [
{
"pp": "case reflects\nX Y : LightProfinite\nf✝ : X ⟶ Y\nA B : LightProfinite\nf : A ⟶ B\nhf : IsIso ((forget LightProfinite).map f)\n⊢ IsIso f",
"usedConstants": [
"CategoryTheory.IsIso",
"congrArg",
"SecondCountableTopology",
"ContinuousMap",
"CategoryTheory.isIso_iff_biject... | rw [isIso_iff_bijective] at hf | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Condensed.Discrete.LocallyConstant | {
"line": 344,
"column": 4
} | {
"line": 345,
"column": 53
} | [
{
"pp": "case h\nP : TopCat → Prop\ninst✝⁴ : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)\nS : CompHausLike P\nY : (CompHausLike P)ᵒᵖ ⥤ Type (max u w)\ninst✝³ : HasProp P PUnit.{u + 1}\nf : LocallyConstant (↑S.toTop) (Y.obj (op (of P PUnit.{u + 1})))\nT : CompHausLike P\ng : T ⟶ S\nX✝ : T... | letI : PreservesFiniteProducts ((sheafToPresheaf (coherentTopology _) _).obj X) :=
inferInstanceAs (PreservesFiniteProducts X.obj) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLetI___1 | Lean.Parser.Tactic.tacticLetI__ |
Mathlib.Condensed.Discrete.Characterization | {
"line": 255,
"column": 2
} | {
"line": 261,
"column": 66
} | [
{
"pp": "R : Type u\ninst✝ : Ring R\nM : LightCondMod R\ntfae_1_iff_2 : LightCondensed.IsDiscrete M ↔ IsIso ((LightCondensed.discreteUnderlyingAdj (ModuleCat R)).counit.app M)\ntfae_1_iff_3 : LightCondensed.IsDiscrete M ↔ (LightCondensed.discrete (ModuleCat R)).essImage M\ntfae_1_iff_4 : LightCondensed.IsDiscre... | tfae_have 6 → 1 := by
intro h
rw [isDiscrete_iff_isDiscrete_forget, ((LightCondSet.isDiscrete_tfae _).out 0 5 :)]
intro S
letI : PreservesFilteredColimitsOfSize.{0, 0} (forget (ModuleCat R)) :=
preservesFilteredColimitsOfSize_shrink.{0, u, 0, u} _
exact ⟨isColimitOfPreserves (forget (ModuleCat... | Mathlib.Tactic.TFAE._aux_Mathlib_Tactic_TFAE___macroRules_Mathlib_Tactic_TFAE_tfaeHave_1 | Mathlib.Tactic.TFAE.tfaeHave |
Mathlib.Topology.Compactification.OnePoint.Basic | {
"line": 214,
"column": 4
} | {
"line": 214,
"column": 24
} | [
{
"pp": "X : Type u_1\nY : Type u_2\ninst✝ : TopologicalSpace X\nS : Set (Set (OnePoint X))\nho : ∀ t ∈ S, (∞ ∈ t → IsCompact (some ⁻¹' t)ᶜ) ∧ IsOpen (some ⁻¹' t)\n⊢ IsOpen (some ⁻¹' ⋃₀ S)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Set.sUnion",
"OnePoint.some",
"Membership.mem... | rw [preimage_sUnion] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Topology.Compactness.CompactlyGeneratedSpace | {
"line": 120,
"column": 4
} | {
"line": 120,
"column": 44
} | [
{
"pp": "X : Type w\nt : TopologicalSpace X\nh :\n ∀ {Y : Type w} [tY : TopologicalSpace Y] (f : X → Y),\n (∀ (S : CompHaus) (g : C(↑S.toTop, X)), Continuous (f ∘ ⇑g)) → Continuous f\n⊢ Continuous id",
"usedConstants": [
"id",
"TopologicalSpace.compactlyGenerated"
]
}
] | apply h (tY := compactlyGenerated.{u} X) | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Condensed.Discrete.Colimit | {
"line": 70,
"column": 2
} | {
"line": 72,
"column": 52
} | [
{
"pp": "I : Type u\ninst✝² : Category.{u, u} I\ninst✝¹ : IsCofiltered I\nF : I ⥤ FintypeCat\nc : Cone (F ⋙ toProfinite)\nX : Type (u + 1)\nhc : IsLimit c\ninst✝ : ∀ (i : I), Epi (c.π.app i)\ns : Cocone ((F ⋙ toProfinite).op ⋙ locallyConstantPresheaf X)\ni : I\nf : LocallyConstant (↑(toProfinite.obj (F.obj i)).... | change ((((locallyConstantPresheaf X).mapCocone c.op).ι.app ⟨i⟩) ≫
(isColimitLocallyConstantPresheaf c X hc).desc s) _ = _
rw [(isColimitLocallyConstantPresheaf c X hc).fac] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Condensed.Discrete.Colimit | {
"line": 70,
"column": 2
} | {
"line": 72,
"column": 52
} | [
{
"pp": "I : Type u\ninst✝² : Category.{u, u} I\ninst✝¹ : IsCofiltered I\nF : I ⥤ FintypeCat\nc : Cone (F ⋙ toProfinite)\nX : Type (u + 1)\nhc : IsLimit c\ninst✝ : ∀ (i : I), Epi (c.π.app i)\ns : Cocone ((F ⋙ toProfinite).op ⋙ locallyConstantPresheaf X)\ni : I\nf : LocallyConstant (↑(toProfinite.obj (F.obj i)).... | change ((((locallyConstantPresheaf X).mapCocone c.op).ι.app ⟨i⟩) ≫
(isColimitLocallyConstantPresheaf c X hc).desc s) _ = _
rw [(isColimitLocallyConstantPresheaf c X hc).fac] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Control.LawfulFix | {
"line": 49,
"column": 73
} | {
"line": 52,
"column": 54
} | [
{
"pp": "α : Type u_1\nβ : α → Type u_2\nf : ((a : α) → Part (β a)) →o (a : α) → Part (β a)\ni : ℕ\n⊢ approx (⇑f) i ≤ approx (⇑f) i.succ",
"usedConstants": [
"Part",
"Nat.recAux",
"Pi.preorder",
"OrderHom.monotone",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preo... | by
induction i with
| zero => dsimp [approx]; apply @bot_le _ _ _ (f ⊥)
| succ _ i_ih => intro; apply f.monotone; apply i_ih | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Control.LawfulFix | {
"line": 90,
"column": 4
} | {
"line": 90,
"column": 29
} | [
{
"pp": "case pos\nα : Type u_1\nβ : α → Type u_2\nf : ((a : α) → Part (β a)) →o (a : α) → Part (β a)\nx : α\nhh : ∃ i b, b ∈ approx (⇑f) i x\n⊢ ∃ i, Part.fix (⇑f) x ≤ approx (⇑f) i x",
"usedConstants": []
}
] | rcases hh with ⟨i, b, hb⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Data.DFinsupp.Interval | {
"line": 72,
"column": 2
} | {
"line": 72,
"column": 26
} | [
{
"pp": "case refine_2\nι : Type u_1\nα : ι → Type u_2\ninst✝² : DecidableEq ι\ninst✝¹ : (i : ι) → Zero (α i)\ns : Finset ι\nf : Π₀ (i : ι), α i\ninst✝ : (i : ι) → DecidableEq (α i)\nt : Π₀ (i : ι), Finset (α i)\nht : t.support ⊆ s\ni : ι\nh : f i ∈ t i\nhi : i ∈ f.support\nH : t i = 0\n⊢ f i = 0",
"usedCon... | · rwa [H, mem_zero] at h | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.List.Sigma | {
"line": 194,
"column": 2
} | {
"line": 196,
"column": 46
} | [
{
"pp": "α : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nl : List (Sigma β)\n⊢ Option.map (Sigma.mk a) (dlookup a l) = find? (fun s ↦ decide (a = s.fst)) l",
"usedConstants": [
"_private.Mathlib.Data.List.Sigma.0.List.map_dlookup_eq_find._proof_1_6",
"List.find?",
"Sigma.fst",
... | induction l with
| nil => grind
| cons s _ _ => by_cases s.fst = a <;> grind | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.List.Sigma | {
"line": 194,
"column": 2
} | {
"line": 196,
"column": 46
} | [
{
"pp": "α : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nl : List (Sigma β)\n⊢ Option.map (Sigma.mk a) (dlookup a l) = find? (fun s ↦ decide (a = s.fst)) l",
"usedConstants": [
"_private.Mathlib.Data.List.Sigma.0.List.map_dlookup_eq_find._proof_1_6",
"List.find?",
"Sigma.fst",
... | induction l with
| nil => grind
| cons s _ _ => by_cases s.fst = a <;> grind | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Sigma | {
"line": 194,
"column": 2
} | {
"line": 196,
"column": 46
} | [
{
"pp": "α : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nl : List (Sigma β)\n⊢ Option.map (Sigma.mk a) (dlookup a l) = find? (fun s ↦ decide (a = s.fst)) l",
"usedConstants": [
"_private.Mathlib.Data.List.Sigma.0.List.map_dlookup_eq_find._proof_1_6",
"List.find?",
"Sigma.fst",
... | induction l with
| nil => grind
| cons s _ _ => by_cases s.fst = a <;> grind | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.Lattice.Pi | {
"line": 46,
"column": 2
} | {
"line": 47,
"column": 66
} | [
{
"pp": "case insert\nα : Type u_1\nι : Type u_2\ninst✝² : DistribLattice α\ninst✝¹ : BoundedOrder α\ninst✝ : DecidableEq ι\nκ : ι → Type u_3\nt : (i : ι) → Finset (κ i)\nf : (i : ι) → κ i → α\ni : ι\ns : Finset ι\nhi : i ∉ s\nih : (s.inf fun i ↦ (t i).sup (f i)) = (s.pi t).sup fun g ↦ s.attach.inf fun i ↦ f (↑... | have := h (fun j hj => if hji : j = i then cast (congr_arg κ hji.symm) a
else g _ <| mem_of_mem_insert_of_ne hj hji) (fun j hj => ?_) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.Finmap | {
"line": 564,
"column": 6
} | {
"line": 564,
"column": 71
} | [
{
"pp": "case pos\nα : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\ns : Finmap β\nx : α\nb : β x\nh : lookup x s = some b\n⊢ lookup x (erase x s ∪ singleton x b) = lookup x s",
"usedConstants": [
"Finmap.lookup_singleton_eq",
"Finmap.erase",
"Eq.mpr",
"congrArg",
"Finmap.inst... | rw [lookup_union_right notMem_erase_self, lookup_singleton_eq, h] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.