module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 366
values | kind stringclasses 370
values |
|---|---|---|---|---|---|---|
Mathlib.Data.List.ReduceOption | {
"line": 137,
"column": 2
} | {
"line": 137,
"column": 96
} | [
{
"pp": "α : Type u_1\nl : List (Option α)\nx : α\n⊢ (l.concat (some x)).reduceOption = l.reduceOption.concat x",
"usedConstants": [
"congrArg",
"List.concat",
"Option.some",
"List.concat_eq_append",
"List.cons",
"instHAppendOfAppend",
"List",
"congr",
"... | simp only [reduceOption_nil, concat_eq_append, reduceOption_append, reduceOption_cons_of_some] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.List.ReduceOption | {
"line": 137,
"column": 2
} | {
"line": 137,
"column": 96
} | [
{
"pp": "α : Type u_1\nl : List (Option α)\nx : α\n⊢ (l.concat (some x)).reduceOption = l.reduceOption.concat x",
"usedConstants": [
"congrArg",
"List.concat",
"Option.some",
"List.concat_eq_append",
"List.cons",
"instHAppendOfAppend",
"List",
"congr",
"... | simp only [reduceOption_nil, concat_eq_append, reduceOption_append, reduceOption_cons_of_some] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.ReduceOption | {
"line": 137,
"column": 2
} | {
"line": 137,
"column": 96
} | [
{
"pp": "α : Type u_1\nl : List (Option α)\nx : α\n⊢ (l.concat (some x)).reduceOption = l.reduceOption.concat x",
"usedConstants": [
"congrArg",
"List.concat",
"Option.some",
"List.concat_eq_append",
"List.cons",
"instHAppendOfAppend",
"List",
"congr",
"... | simp only [reduceOption_nil, concat_eq_append, reduceOption_append, reduceOption_cons_of_some] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.Halting | {
"line": 41,
"column": 30
} | {
"line": 41,
"column": 38
} | [
{
"pp": "case pos\nC : Set (ℕ →. ℕ)\nf g : ℕ →. ℕ\nhf : Nat.Partrec f\nhg : Nat.Partrec g\nfC : f ∈ C\nw✝ : DecidablePred fun c ↦ c.eval ∈ C\nh : Computable fun a ↦ decide ((fun c ↦ c.eval ∈ C) a)\nc : Code\ne : c.eval = fun b ↦ if c.eval ∈ C then g b else f b\nH : c.eval ∈ C\n⊢ g ∈ C",
"usedConstants": [
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Computability.Halting | {
"line": 41,
"column": 30
} | {
"line": 41,
"column": 38
} | [
{
"pp": "case neg\nC : Set (ℕ →. ℕ)\nf g : ℕ →. ℕ\nhf : Nat.Partrec f\nhg : Nat.Partrec g\nfC : f ∈ C\nw✝ : DecidablePred fun c ↦ c.eval ∈ C\nh : Computable fun a ↦ decide ((fun c ↦ c.eval ∈ C) a)\nc : Code\ne : c.eval = fun b ↦ if c.eval ∈ C then g b else f b\nH : c.eval ∉ C\n⊢ g ∈ C",
"usedConstants": [
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Computability.EpsilonNFA | {
"line": 189,
"column": 4
} | {
"line": 189,
"column": 53
} | [
{
"pp": "α : Type u\nσ : Type v\nM : εNFA α σ\ns u : σ\nx y : List (Option α)\nt : σ\nhx : M.IsPath s t x\nright✝ : M.IsPath t u y\n⊢ M.IsPath s u (x ++ y)",
"usedConstants": [
"εNFA.IsPath.nil",
"εNFA.IsPath.cons",
"HEq.refl",
"False.elim",
"noConfusion_of_Nat",
"Members... | induction x generalizing s <;> cases hx <;> tauto | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Computability.EpsilonNFA | {
"line": 198,
"column": 6
} | {
"line": 198,
"column": 22
} | [
{
"pp": "case h\nα : Type u\nσ : Type v\nM : εNFA α σ\ns₁ s₂ : σ\n⊢ M.IsPath s₁ s₁ (List.replicate 0 none)",
"usedConstants": [
"εNFA.IsPath.nil"
]
}
] | apply IsPath.nil | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Data.Num.Lemmas | {
"line": 722,
"column": 4
} | {
"line": 722,
"column": 71
} | [
{
"pp": "p : PosNum\n⊢ castNum <$> (pos p).ppred = (↑(pos p)).ppred",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Nat.instMulZeroClass",
"Nat.instOne",
"PosNum.pred'",
"congrArg",
"Option.some",
"instFunctorOption",
"id",
"Nat.ppred_eq_some",
"c... | rw [ppred, Option.map_eq_map, Option.map_some, Nat.ppred_eq_some.2] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Computability.RecursiveIn | {
"line": 224,
"column": 20
} | {
"line": 224,
"column": 69
} | [
{
"pp": "α : Type u_1\nσ : Type u_4\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nf : α →. σ\ns : Part ℕ\nhf : RecursiveIn {fun x ↦ s} f\ng : ℕ →. ℕ\nhg : g ∈ {fun x ↦ s}\n⊢ Partrec g",
"usedConstants": [
"Eq.mpr",
"PFun",
"congrArg",
"Primcodable.ofDenumerable",
"Membership.... | rw [Set.mem_singleton_iff.mp hg]; exact .const' s | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.RecursiveIn | {
"line": 224,
"column": 20
} | {
"line": 224,
"column": 69
} | [
{
"pp": "α : Type u_1\nσ : Type u_4\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nf : α →. σ\ns : Part ℕ\nhf : RecursiveIn {fun x ↦ s} f\ng : ℕ →. ℕ\nhg : g ∈ {fun x ↦ s}\n⊢ Partrec g",
"usedConstants": [
"Eq.mpr",
"PFun",
"congrArg",
"Primcodable.ofDenumerable",
"Membership.... | rw [Set.mem_singleton_iff.mp hg]; exact .const' s | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.Reduce | {
"line": 385,
"column": 2
} | {
"line": 388,
"column": 30
} | [
{
"pp": "d₁ d₂ d₃ : ManyOneDegree\n⊢ d₁ ≤ d₂ → d₂ ≤ d₃ → d₁ ≤ d₃",
"usedConstants": [
"ManyOneDegree.instLE",
"Primcodable.ofDenumerable",
"ManyOneDegree.ind_on",
"ManyOneReducible.trans",
"instInhabitedNat",
"LE.le",
"toNat",
"Nat",
"ManyOneDegree",
... | induction d₁ using ManyOneDegree.ind_on
induction d₂ using ManyOneDegree.ind_on
induction d₃ using ManyOneDegree.ind_on
apply ManyOneReducible.trans | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.Reduce | {
"line": 385,
"column": 2
} | {
"line": 388,
"column": 30
} | [
{
"pp": "d₁ d₂ d₃ : ManyOneDegree\n⊢ d₁ ≤ d₂ → d₂ ≤ d₃ → d₁ ≤ d₃",
"usedConstants": [
"ManyOneDegree.instLE",
"Primcodable.ofDenumerable",
"ManyOneDegree.ind_on",
"ManyOneReducible.trans",
"instInhabitedNat",
"LE.le",
"toNat",
"Nat",
"ManyOneDegree",
... | induction d₁ using ManyOneDegree.ind_on
induction d₂ using ManyOneDegree.ind_on
induction d₃ using ManyOneDegree.ind_on
apply ManyOneReducible.trans | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 853,
"column": 4
} | {
"line": 853,
"column": 39
} | [
{
"pp": "case some\nΓ : Type u_1\nΛ : Type u_2\nσ : Type u_3\nn : ℕ\nenc : Γ → List.Vector Bool n\ndec : List.Vector Bool n → Γ\nM : Λ → Stmt Γ Λ σ\ninst✝ : Inhabited Γ\nenc0 : enc default = List.Vector.replicate n false\nencdec : ∀ (a : Γ), dec (enc a) = a\nx✝ : Cfg Γ Λ σ\nv : σ\nL : ListBlank Γ\nq : Stmt Γ Λ ... | induction q generalizing v L R with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Computability.TuringMachine.Config | {
"line": 284,
"column": 6
} | {
"line": 284,
"column": 71
} | [
{
"pp": "case prim.prec\nn✝¹ : ℕ\nf✝¹ : List.Vector ℕ n✝¹ →. ℕ\nn✝ : ℕ\nf✝ : List.Vector ℕ n✝ → ℕ\nn : ℕ\nf : List.Vector ℕ n → ℕ\ng : List.Vector ℕ (n + 2) → ℕ\na✝¹ : Nat.Primrec' f\na✝ : Nat.Primrec' g\ncf : Code\nhf : ∀ (v : List.Vector ℕ n), cf.eval ↑v = pure <$> ↑f v\ncg : Code\nhg : ∀ (v : List.Vector ℕ (... | simp only [Part.map_eq_map, Part.map_some, PFun.coe_val] at hf hg | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Computability.TuringMachine.Config | {
"line": 309,
"column": 8
} | {
"line": 309,
"column": 16
} | [
{
"pp": "n✝² : ℕ\nf✝¹ : List.Vector ℕ n✝² →. ℕ\nn✝¹ : ℕ\nf✝ : List.Vector ℕ n✝¹ → ℕ\nn✝ : ℕ\nf : List.Vector ℕ n✝ → ℕ\ng : List.Vector ℕ (n✝ + 2) → ℕ\na✝² : Nat.Primrec' f\na✝¹ : Nat.Primrec' g\ncf cg : Code\nv : List.Vector ℕ (n✝ + 1)\nhf : cf.eval (↑v).tail = pure (pure (f v.tail))\nhg : ∀ (a b : ℕ), cg.eval ... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Computability.TuringMachine.Config | {
"line": 354,
"column": 38
} | {
"line": 354,
"column": 46
} | [
{
"pp": "n✝¹ : ℕ\nf✝ : List.Vector ℕ n✝¹ →. ℕ\nn✝ : ℕ\nf : List.Vector ℕ (n✝ + 1) → ℕ\na✝ : Nat.Partrec' ↑f\ncf : Code\nv : List.Vector ℕ n✝\nhf : ∀ (a : ℕ), cf.eval (a :: ↑v) = Part.some [f (a ::ᵥ v)]\nv' v₀ : List ℕ\nn : ℕ\nh2 :\n v' ∈\n PFun.fix\n (fun v ↦\n (cf.eval v).bind fun y ↦\n ... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Computability.TuringMachine.Config | {
"line": 354,
"column": 38
} | {
"line": 354,
"column": 46
} | [
{
"pp": "n✝¹ : ℕ\nf✝ : List.Vector ℕ n✝¹ →. ℕ\nn✝ : ℕ\nf : List.Vector ℕ (n✝ + 1) → ℕ\na✝ : Nat.Partrec' ↑f\ncf : Code\nv : List.Vector ℕ n✝\nhf : ∀ (a : ℕ), cf.eval (a :: ↑v) = Part.some [f (a ::ᵥ v)]\nv' v₀ : List ℕ\nn : ℕ\nh2 :\n v' ∈\n PFun.fix\n (fun v ↦\n (cf.eval v).bind fun y ↦\n ... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.Config | {
"line": 354,
"column": 38
} | {
"line": 354,
"column": 46
} | [
{
"pp": "n✝¹ : ℕ\nf✝ : List.Vector ℕ n✝¹ →. ℕ\nn✝ : ℕ\nf : List.Vector ℕ (n✝ + 1) → ℕ\na✝ : Nat.Partrec' ↑f\ncf : Code\nv : List.Vector ℕ n✝\nhf : ∀ (a : ℕ), cf.eval (a :: ↑v) = Part.some [f (a ::ᵥ v)]\nv' v₀ : List ℕ\nn : ℕ\nh2 :\n v' ∈\n PFun.fix\n (fun v ↦\n (cf.eval v).bind fun y ↦\n ... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 593,
"column": 12
} | {
"line": 594,
"column": 89
} | [
{
"pp": "K : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\ninst✝ : DecidableEq K\nk : K\nq : TM1.Stmt (Γ' K Γ) (Λ' K Γ Λ σ) σ\nv : σ\nS : (k : K) → List (Γ k)\nL : ListBlank ((k : K) → Option (Γ k))\nhL : ∀ (k : K), ListBlank.map (proj k) L = ListBlank.mk (List.map some (S k)).reverse\nf : σ → Option ... | show (List.cons hd tl).reverse[tl.length]? = some hd by
rw [List.reverse_cons, ← List.length_reverse, List.getElem?_concat_length], | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.TuringMachine.Config | {
"line": 617,
"column": 10
} | {
"line": 617,
"column": 14
} | [
{
"pp": "case mp.halt\nf : Code\nk : Cont\nv✝ : List ℕ\nfok : f.Ok\nx c : Cfg\nhe : x ∈ eval step c\nv v' : List ℕ\nh : x ∈ eval step (stepRet (Cont.fix f k) v')\nIH :\n ∀ (a' : Cfg),\n step (stepRet (Cont.fix f k) v') = some a' →\n ∀ (v : List ℕ) (c' : Cfg),\n a' = c'.then (Cont.fix f k) →\n ... | fok, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 644,
"column": 4
} | {
"line": 644,
"column": 28
} | [
{
"pp": "case succ\nK : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\ninst✝ : DecidableEq K\nM : Λ → TM2.Stmt Γ Λ σ\nk : K\no : StAct K Γ σ k\nq : TM2.Stmt Γ Λ σ\nv : σ\nS : List (Γ k)\nL : ListBlank ((k : K) → Option (Γ k))\nhL : ListBlank.map (proj k) L = ListBlank.mk (List.map some S).reverse\nn : ... | rw [iterate_succ_apply'] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Computability.TuringMachine.Config | {
"line": 648,
"column": 8
} | {
"line": 648,
"column": 12
} | [
{
"pp": "case mpr\nf : Code\nk : Cont\nv✝ : List ℕ\nfok : f.Ok\nx : Cfg\nv' : List ℕ\nhe✝ : v' ∈ f.fix.eval v✝\nhr✝ : x ∈ eval step (Cfg.ret k v')\nhr : x ∈ eval step (stepRet k v')\nv : List ℕ\nhe : v' ∈ f.fix.eval v\nIH :\n ∀ (a'' : List ℕ),\n Sum.inr a'' ∈ Part.map (fun v ↦ if v.headI = 0 then Sum.inl v.... | fok, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 523,
"column": 2
} | {
"line": 523,
"column": 27
} | [
{
"pp": "a b c d a' : List Γ'\n⊢ update (elim a b c d) main a' = elim a' b c d",
"usedConstants": [
"Function.update",
"Turing.PartrecToTM2.K'.rev",
"Turing.PartrecToTM2.instDecidableEqK'",
"Turing.PartrecToTM2.Γ'",
"Turing.PartrecToTM2.K'.stack",
"Turing.PartrecToTM2.K'.... | funext x; cases x <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 523,
"column": 2
} | {
"line": 523,
"column": 27
} | [
{
"pp": "a b c d a' : List Γ'\n⊢ update (elim a b c d) main a' = elim a' b c d",
"usedConstants": [
"Function.update",
"Turing.PartrecToTM2.K'.rev",
"Turing.PartrecToTM2.instDecidableEqK'",
"Turing.PartrecToTM2.Γ'",
"Turing.PartrecToTM2.K'.stack",
"Turing.PartrecToTM2.K'.... | funext x; cases x <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 527,
"column": 2
} | {
"line": 527,
"column": 27
} | [
{
"pp": "a b c d b' : List Γ'\n⊢ update (elim a b c d) rev b' = elim a b' c d",
"usedConstants": [
"Function.update",
"Turing.PartrecToTM2.K'.rev",
"Turing.PartrecToTM2.instDecidableEqK'",
"Turing.PartrecToTM2.Γ'",
"Turing.PartrecToTM2.K'.stack",
"Turing.PartrecToTM2.K'.c... | funext x; cases x <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 527,
"column": 2
} | {
"line": 527,
"column": 27
} | [
{
"pp": "a b c d b' : List Γ'\n⊢ update (elim a b c d) rev b' = elim a b' c d",
"usedConstants": [
"Function.update",
"Turing.PartrecToTM2.K'.rev",
"Turing.PartrecToTM2.instDecidableEqK'",
"Turing.PartrecToTM2.Γ'",
"Turing.PartrecToTM2.K'.stack",
"Turing.PartrecToTM2.K'.c... | funext x; cases x <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 531,
"column": 2
} | {
"line": 531,
"column": 27
} | [
{
"pp": "a b c d c' : List Γ'\n⊢ update (elim a b c d) aux c' = elim a b c' d",
"usedConstants": [
"Function.update",
"Turing.PartrecToTM2.K'.rev",
"Turing.PartrecToTM2.instDecidableEqK'",
"Turing.PartrecToTM2.Γ'",
"Turing.PartrecToTM2.K'.stack",
"Turing.PartrecToTM2.K'.c... | funext x; cases x <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 531,
"column": 2
} | {
"line": 531,
"column": 27
} | [
{
"pp": "a b c d c' : List Γ'\n⊢ update (elim a b c d) aux c' = elim a b c' d",
"usedConstants": [
"Function.update",
"Turing.PartrecToTM2.K'.rev",
"Turing.PartrecToTM2.instDecidableEqK'",
"Turing.PartrecToTM2.Γ'",
"Turing.PartrecToTM2.K'.stack",
"Turing.PartrecToTM2.K'.c... | funext x; cases x <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 535,
"column": 63
} | {
"line": 535,
"column": 88
} | [
{
"pp": "a b c d d' : List Γ'\n⊢ update (elim a b c d) stack d' = elim a b c d'",
"usedConstants": [
"Function.update",
"Turing.PartrecToTM2.K'.rev",
"Turing.PartrecToTM2.instDecidableEqK'",
"Turing.PartrecToTM2.Γ'",
"Turing.PartrecToTM2.K'.stack",
"Turing.PartrecToTM2.K'... | funext x; cases x <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 535,
"column": 63
} | {
"line": 535,
"column": 88
} | [
{
"pp": "a b c d d' : List Γ'\n⊢ update (elim a b c d) stack d' = elim a b c d'",
"usedConstants": [
"Function.update",
"Turing.PartrecToTM2.K'.rev",
"Turing.PartrecToTM2.instDecidableEqK'",
"Turing.PartrecToTM2.Γ'",
"Turing.PartrecToTM2.K'.stack",
"Turing.PartrecToTM2.K'... | funext x; cases x <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 576,
"column": 12
} | {
"line": 576,
"column": 15
} | [
{
"pp": "case some.nil\nα : Type u_1\np : α → Bool\na : α\nL : List α\nIH :\n ∀ (l₁ : List α) (o : Option α) (l₂ : List α),\n (∀ x ∈ l₁, p x = false) →\n Option.elim' (L = l₁ ∧ l₂ = []) (fun a ↦ p a = true ∧ L = l₁ ++ a :: l₂) o → splitAtPred p L = (l₁, o, l₂)\nh₁ : ∀ x ∈ [], p x = false\nh₂ : p a = tr... | h₂, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Separation.Profinite | {
"line": 142,
"column": 86
} | {
"line": 142,
"column": 94
} | [
{
"pp": "X : Type u_4\ninst✝³ : TopologicalSpace X\ninst✝² : CompactSpace X\ninst✝¹ : T2Space X\ninst✝ : TotallyDisconnectedSpace X\nZ U : Set X\nhZ : IsClosed[inst✝³] Z\nhU : IsOpen[inst✝³] U\nhZU : Z ⊆ U\nV : ↑Z → Set X\nhV : ∀ (z : ↑Z), IsClopen (V z) ∧ ↑z ∈ V z ∧ V z ⊆ U\nV_cover : Z ⊆ ⋃ z, V z\nI : Finset ... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Topology.Separation.Profinite | {
"line": 142,
"column": 86
} | {
"line": 142,
"column": 94
} | [
{
"pp": "X : Type u_4\ninst✝³ : TopologicalSpace X\ninst✝² : CompactSpace X\ninst✝¹ : T2Space X\ninst✝ : TotallyDisconnectedSpace X\nZ U : Set X\nhZ : IsClosed[inst✝³] Z\nhU : IsOpen[inst✝³] U\nhZU : Z ⊆ U\nV : ↑Z → Set X\nhV : ∀ (z : ↑Z), IsClopen (V z) ∧ ↑z ∈ V z ∧ V z ⊆ U\nV_cover : Z ⊆ ⋃ z, V z\nI : Finset ... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Separation.Profinite | {
"line": 142,
"column": 86
} | {
"line": 142,
"column": 94
} | [
{
"pp": "X : Type u_4\ninst✝³ : TopologicalSpace X\ninst✝² : CompactSpace X\ninst✝¹ : T2Space X\ninst✝ : TotallyDisconnectedSpace X\nZ U : Set X\nhZ : IsClosed[inst✝³] Z\nhU : IsOpen[inst✝³] U\nhZU : Z ⊆ U\nV : ↑Z → Set X\nhV : ∀ (z : ↑Z), IsClopen (V z) ∧ ↑z ∈ V z ∧ V z ⊆ U\nV_cover : Z ⊆ ⋃ z, V z\nI : Finset ... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Category.Profinite.Basic | {
"line": 245,
"column": 6
} | {
"line": 245,
"column": 63
} | [
{
"pp": "case mp\nX Y : Profinite\nf : X ⟶ Y\ny : ↑Y.toTop\nhy : ∀ (a : ↑X.toTop), (ConcreteCategory.hom f) a ≠ y\nhf : Epi f\nC : Set ((fun X ↦ ↑X.toTop) Y) := Set.range ⇑(ConcreteCategory.hom f)\nhC : IsClosed C\nU : Set ((fun X ↦ ↑X.toTop) Y) := Cᶜ\nhyU : y ∈ U\nhUy : U ∈ 𝓝 y\nV : Set ↑Y.toTop\nhV : V ∈ {s ... | let h : Y ⟶ Z := ofHom _ ⟨fun _ => ⟨1⟩, continuous_const⟩ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 668,
"column": 82
} | {
"line": 679,
"column": 18
} | [
{
"pp": "q : Λ'\ns : Option Γ'\na b c d : List Γ'\n⊢ Reaches₁ (TM2.step tr) { l := some q.copy, var := s, stk := elim a b c d }\n { l := some q, var := none, stk := elim (b.reverseAux a) [] c (b.reverseAux d) }",
"usedConstants": [
"List.head?",
"cond",
"Eq.mpr",
"Inhabited.defaul... | by
induction b generalizing a d s with
| nil =>
refine TransGen.single ?_
simp
| cons x b IH =>
refine TransGen.head rfl ?_
rw [tr]
simp only [TM2.step, Option.mem_def, TM2.stepAux, elim_rev, List.head?_cons, Option.isSome_some,
List.tail_cons, elim_update_rev, elim_main, elim_update_mai... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.Category.Stonean.Basic | {
"line": 159,
"column": 4
} | {
"line": 161,
"column": 8
} | [
{
"pp": "X : Stonean\nB C : CompHaus\nφ : toCompHaus.obj X ⟶ C\nf : B ⟶ C\ninst✝ : Epi f\nthis : ExtremallyDisconnected ↑(toCompHaus.obj X).toTop\nhf : Function.Surjective ⇑(ConcreteCategory.hom f)\n⊢ ∃ f', f' ≫ f = φ",
"usedConstants": [
"ContinuousMap.continuous",
"TopCat.instCategory",
... | obtain ⟨f', h⟩ := CompactT2.ExtremallyDisconnected.projective φ.hom.hom.continuous
f.hom.hom.continuous
hf | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Topology.Category.Stonean.Basic | {
"line": 172,
"column": 4
} | {
"line": 174,
"column": 8
} | [
{
"pp": "X : Stonean\nB C : Profinite\nφ : toProfinite.obj X ⟶ C\nf : B ⟶ C\ninst✝ : Epi f\nthis : ExtremallyDisconnected ↑(toProfinite.obj X).toTop\nhf : Function.Surjective ⇑(ConcreteCategory.hom f)\n⊢ ∃ f', f' ≫ f = φ",
"usedConstants": [
"ContinuousMap.continuous",
"Stonean.toProfinite",
... | obtain ⟨f', h⟩ := CompactT2.ExtremallyDisconnected.projective φ.hom.hom.continuous
f.hom.hom.continuous
hf | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Topology.Category.Stonean.Basic | {
"line": 185,
"column": 4
} | {
"line": 187,
"column": 8
} | [
{
"pp": "X B C : Stonean\nφ : X ⟶ C\nf : B ⟶ C\ninst✝ : Epi f\nthis : ExtremallyDisconnected ↑X.toTop\nhf : Function.Surjective ⇑(ConcreteCategory.hom f)\n⊢ ∃ f', f' ≫ f = φ",
"usedConstants": [
"ContinuousMap.continuous",
"TopCat.instCategory",
"ContinuousMap",
"CompHausLike",
... | obtain ⟨f', h⟩ := CompactT2.ExtremallyDisconnected.projective φ.hom.hom.continuous
f.hom.hom.continuous
hf | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Topology.ExtremallyDisconnected | {
"line": 318,
"column": 6
} | {
"line": 318,
"column": 14
} | [
{
"pp": "case pos\nX : Type u\ninst✝ : TopologicalSpace X\nh : PreirreducibleSpace X\nU : Set X\nhU : IsOpen U\nUn : U = ∅\n⊢ IsOpen (closure U)",
"usedConstants": [
"congrArg",
"IsClosed.closure_eq",
"IsClosed",
"closure",
"True",
"Set.instEmptyCollection",
"of_eq_... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Topology.ExtremallyDisconnected | {
"line": 318,
"column": 6
} | {
"line": 318,
"column": 14
} | [
{
"pp": "case pos\nX : Type u\ninst✝ : TopologicalSpace X\nh : PreirreducibleSpace X\nU : Set X\nhU : IsOpen U\nUn : U = ∅\n⊢ IsOpen (closure U)",
"usedConstants": [
"congrArg",
"IsClosed.closure_eq",
"IsClosed",
"closure",
"True",
"Set.instEmptyCollection",
"of_eq_... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.ExtremallyDisconnected | {
"line": 318,
"column": 6
} | {
"line": 318,
"column": 14
} | [
{
"pp": "case pos\nX : Type u\ninst✝ : TopologicalSpace X\nh : PreirreducibleSpace X\nU : Set X\nhU : IsOpen U\nUn : U = ∅\n⊢ IsOpen (closure U)",
"usedConstants": [
"congrArg",
"IsClosed.closure_eq",
"IsClosed",
"closure",
"True",
"Set.instEmptyCollection",
"of_eq_... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.ExtremallyDisconnected | {
"line": 328,
"column": 4
} | {
"line": 328,
"column": 12
} | [
{
"pp": "case inl\nX : Type u\ninst✝ : TopologicalSpace X\nh : ExtremallyDisconnected X\nh' : PreconnectedSpace X\ns : Set X\nhs : IsOpen s\nsn : s.Nonempty\nh✝ : closure s = ∅\n⊢ closure s = univ",
"usedConstants": [
"Eq.mpr",
"False",
"congrArg",
"Set.univ",
"False.elim",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Topology.ExtremallyDisconnected | {
"line": 328,
"column": 4
} | {
"line": 328,
"column": 12
} | [
{
"pp": "case inl\nX : Type u\ninst✝ : TopologicalSpace X\nh : ExtremallyDisconnected X\nh' : PreconnectedSpace X\ns : Set X\nhs : IsOpen s\nsn : s.Nonempty\nh✝ : closure s = ∅\n⊢ closure s = univ",
"usedConstants": [
"Eq.mpr",
"False",
"congrArg",
"Set.univ",
"False.elim",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.ExtremallyDisconnected | {
"line": 328,
"column": 4
} | {
"line": 328,
"column": 12
} | [
{
"pp": "case inl\nX : Type u\ninst✝ : TopologicalSpace X\nh : ExtremallyDisconnected X\nh' : PreconnectedSpace X\ns : Set X\nhs : IsOpen s\nsn : s.Nonempty\nh✝ : closure s = ∅\n⊢ closure s = univ",
"usedConstants": [
"Eq.mpr",
"False",
"congrArg",
"Set.univ",
"False.elim",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1019,
"column": 74
} | {
"line": 1020,
"column": 72
} | [
{
"pp": "c : Code\nk : Cont'\n⊢ trStmts₁ (trNormal c k) ⊆ codeSupp' c k",
"usedConstants": [
"Turing.PartrecToTM2.trStmts₁",
"Finset.instUnion",
"Turing.PartrecToTM2.Γ'",
"Turing.PartrecToTM2.instDecidableEqΓ'",
"Turing.PartrecToTM2.Γ'.consₗ",
"Finset",
"Finset.unio... | by
cases c <;> first | rfl | exact Finset.union_subset_left (fun _ a ↦ a) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.DiscreteQuotient | {
"line": 232,
"column": 8
} | {
"line": 232,
"column": 51
} | [
{
"pp": "α : Type u_1\nX : Type u_2\nY : Type u_3\nZ : Type u_4\ninst✝³ : TopologicalSpace X\ninst✝² : TopologicalSpace Y\ninst✝¹ : TopologicalSpace Z\nS : DiscreteQuotient X\ninst✝ : LocallyConnectedSpace X\nx : X\n⊢ IsOpen[inst✝³] (setOf ((connectedComponentSetoid X) x))",
"usedConstants": [
"Eq.mpr... | convert! isOpen_connectedComponent (x := x) | Mathlib.Tactic._aux_Mathlib_Tactic_Convert___macroRules_Mathlib_Tactic_convert!_1 | Mathlib.Tactic.convert! |
Mathlib.Topology.Category.TopCat.Limits.Cofiltered | {
"line": 54,
"column": 4
} | {
"line": 54,
"column": 26
} | [
{
"pp": "case h.e'_3.h.mp\nJ : Type v\ninst✝¹ : Category.{w, v} J\ninst✝ : IsCofiltered J\nF : J ⥤ TopCat\nC : Cone F\nhC : IsLimit C\nT : (j : J) → Set (Set ↑(F.obj j))\nhT : ∀ (j : J), IsTopologicalBasis (T j)\nuniv : ∀ (i : J), Set.univ ∈ T i\ninter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i →... | rintro ⟨j, V, hV, rfl⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.Topology.Category.Profinite.CofilteredLimit | {
"line": 117,
"column": 2
} | {
"line": 118,
"column": 42
} | [
{
"pp": "case h.h\nJ : Type v\ninst✝¹ : SmallCategory J\ninst✝ : IsCofiltered J\nF : J ⥤ Profinite\nC : Cone F\nhC : IsLimit C\nf : LocallyConstant (↑C.pt.toTop) (Fin 2)\nU : Set ↑C.pt.toTop := ⋯\nhU : IsClopen U\nj : J\nV : Set ↑(F.obj j).toTop\nhV : IsClopen V\nh : U = ⇑(ConcreteCategory.hom (C.π.app j)) ⁻¹' ... | simp only [Fin.isValue, Functor.const_obj_obj, LocallyConstant.coe_comap, Set.preimage_comp,
LocallyConstant.ofIsClopen_fiber_zero] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Topology.Category.Profinite.CofilteredLimit | {
"line": 125,
"column": 91
} | {
"line": 152,
"column": 15
} | [
{
"pp": "J : Type v\ninst✝² : SmallCategory J\ninst✝¹ : IsCofiltered J\nF : J ⥤ Profinite\nC : Cone F\nα : Type u_1\ninst✝ : Finite α\nhC : IsLimit C\nf : LocallyConstant (↑C.pt.toTop) α\n⊢ ∃ j g,\n LocallyConstant.map (fun a b ↦ if a = b then 0 else 1) f = LocallyConstant.comap (TopCat.Hom.hom (C.π.app j).h... | by
cases nonempty_fintype α
let ι : α → α → Fin 2 := fun x y => if x = y then 0 else 1
let ff := (f.map ι).flip
have hff := fun a : α => exists_locallyConstant_fin_two _ hC (ff a)
choose j g h using hff
let G : Finset J := Finset.univ.image j
obtain ⟨j0, hj0⟩ := IsCofiltered.inf_objs_exists G
have hj : ... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Condensed.TopComparison | {
"line": 55,
"column": 10
} | {
"line": 55,
"column": 13
} | [
{
"pp": "C : Type u\ninst✝³ : Category.{v, u} C\nG : C ⥤ TopCat\nX : Type w'\ninst✝² : TopologicalSpace X\nZ B : C\nπ : Z ⟶ B\ninst✝¹ : HasPullback π π\ninst✝ : PreservesLimit (cospan π π) G\na : C(↑(G.obj Z), X)\nha : ⇑a ∘ ⇑(ConcreteCategory.hom (G.map (pullback.fst π π))) = ⇑a ∘ ⇑(ConcreteCategory.hom (G.map ... | h₂, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Condensed.TopComparison | {
"line": 68,
"column": 49
} | {
"line": 87,
"column": 100
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\nG : C ⥤ TopCat\nX : Type w'\ninst✝¹ : TopologicalSpace X\ninst✝ : ∀ (Z B : C) (π : Z ⟶ B) [EffectiveEpi π], PreservesLimit (cospan π π) G\nhq : ∀ (Z B : C) (π : Z ⟶ B) [EffectiveEpi π], IsQuotientMap ⇑(ConcreteCategory.hom (G.map π))\n⊢ EqualizerCondition (yoneda... | by
apply EqualizerCondition.mk
intro Z B π _ _
refine ⟨fun a b h ↦ ?_, fun ⟨a, ha⟩ ↦ ?_⟩
· simp only [yonedaPresheaf, comp, Quiver.Hom.unop_op, TypeCat.Fun.coe_mk,
Set.coe_setOf, mapToEqualizer, Set.mem_setOf_eq, ConcreteCategory.hom_ofHom, Subtype.mk.injEq,
mk.injEq] at h
simp only [yonedaPresh... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Condensed.Discrete.Module | {
"line": 55,
"column": 64
} | {
"line": 59,
"column": 70
} | [
{
"pp": "P : TopCat → Prop\nR : Type (max u w)\ninst✝² : Ring R\ninst✝¹ : HasExplicitFiniteCoproducts P\ninst✝ : HasExplicitPullbacks P\nhs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), EffectiveEpi f → Function.Surjective ⇑(ConcreteCategory.hom f)\nX : ModuleCat R\n⊢ Presheaf.IsSheaf (coherentTopology (CompHausLike ... | by
have := CompHausLike.preregular hs
apply Presheaf.isSheaf_coherent_of_hasPullbacks_of_comp
(s := CategoryTheory.forget (ModuleCat R))
exact ((CompHausLike.LocallyConstant.functor P hs).obj _).property | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Condensed.Light.TopCatAdjunction | {
"line": 132,
"column": 2
} | {
"line": 133,
"column": 46
} | [
{
"pp": "X✝ Y : LightCondSet\nf : X✝ ⟶ Y\nX : TopCat\n⊢ Epi (topCatAdjunction.counit.app X)",
"usedConstants": [
"LightCondensed._proof_1",
"Eq.mpr",
"lightCondSetToTopCat",
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.Epi",
"congrArg",
"CategoryTheor... | rw [TopCat.epi_iff_surjective]
exact (topCatAdjunctionCounit_bijective _).2 | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Condensed.Light.TopCatAdjunction | {
"line": 132,
"column": 2
} | {
"line": 133,
"column": 46
} | [
{
"pp": "X✝ Y : LightCondSet\nf : X✝ ⟶ Y\nX : TopCat\n⊢ Epi (topCatAdjunction.counit.app X)",
"usedConstants": [
"LightCondensed._proof_1",
"Eq.mpr",
"lightCondSetToTopCat",
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.Epi",
"congrArg",
"CategoryTheor... | rw [TopCat.epi_iff_surjective]
exact (topCatAdjunctionCounit_bijective _).2 | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Category.LightProfinite.Injective | {
"line": 90,
"column": 4
} | {
"line": 90,
"column": 12
} | [
{
"pp": "X : Type u_1\nY : Type u_2\nS : Type u_3\nT : Type u_4\ninst✝¹⁰ : TopologicalSpace X\ninst✝⁹ : CompactSpace X\ninst✝⁸ : TopologicalSpace Y\ninst✝⁷ : CompactSpace Y\ninst✝⁶ : T2Space Y\ninst✝⁵ : TotallyDisconnectedSpace Y\ninst✝⁴ : TopologicalSpace S\ninst✝³ : T2Space S\ninst✝² : Finite S\ninst✝¹ : Topo... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Condensed.Discrete.Colimit | {
"line": 301,
"column": 2
} | {
"line": 301,
"column": 79
} | [
{
"pp": "case w.h.w.e_a.h.toFun.h.h\nX : Profiniteᵒᵖ ⥤ Type (u + 1)\ninst✝ : PreservesFiniteProducts X\nhX : (S : Profinite) → IsColimit (X.mapCocone S.asLimitCone.op)\nS : Profiniteᵒᵖ\nY : FintypeCatᵒᵖ\nright✝ : Discrete PUnit.{1}\ng : toProfinite.op.obj Y ⟶ (fromPUnit S).obj right✝\nf :\n LocallyConstant (↑(... | apply injective_of_mono (isoFinYonedaComponents X (fiber.{u, u + 1} f x)).hom | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Condensed.TopCatAdjunction | {
"line": 142,
"column": 2
} | {
"line": 143,
"column": 46
} | [
{
"pp": "X✝ : CondensedSet\nX : TopCat\n⊢ Epi (topCatAdjunction.counit.app X)",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.Epi",
"Condensed._proof_1",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"TopCat.instCatego... | rw [TopCat.epi_iff_surjective]
exact (topCatAdjunctionCounit_bijective _).2 | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Condensed.TopCatAdjunction | {
"line": 142,
"column": 2
} | {
"line": 143,
"column": 46
} | [
{
"pp": "X✝ : CondensedSet\nX : TopCat\n⊢ Epi (topCatAdjunction.counit.app X)",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Functor",
"Opposite",
"CategoryTheory.Epi",
"Condensed._proof_1",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"TopCat.instCatego... | rw [TopCat.epi_iff_surjective]
exact (topCatAdjunctionCounit_bijective _).2 | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Condensed.Light.Sequence | {
"line": 82,
"column": 57
} | {
"line": 82,
"column": 65
} | [
{
"pp": "S : Type u_1\nT : Type u_2\nX : Type u_3\ninst✝⁵ : TopologicalSpace S\ninst✝⁴ : TopologicalSpace T\ninst✝³ : TopologicalSpace X\ninst✝² : DiscreteTopology X\ninst✝¹ : T2Space T\ninst✝ : CompactSpace S\nπ : T → S × OnePoint X\nhπ : Continuous π\nσ : Option X → S → T\nhσ : ∀ (x : Option X), Continuous (σ... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Condensed.Light.Sequence | {
"line": 82,
"column": 57
} | {
"line": 82,
"column": 65
} | [
{
"pp": "S : Type u_1\nT : Type u_2\nX : Type u_3\ninst✝⁵ : TopologicalSpace S\ninst✝⁴ : TopologicalSpace T\ninst✝³ : TopologicalSpace X\ninst✝² : DiscreteTopology X\ninst✝¹ : T2Space T\ninst✝ : CompactSpace S\nπ : T → S × OnePoint X\nhπ : Continuous π\nσ : Option X → S → T\nhσ : ∀ (x : Option X), Continuous (σ... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Condensed.Light.Sequence | {
"line": 82,
"column": 57
} | {
"line": 82,
"column": 65
} | [
{
"pp": "S : Type u_1\nT : Type u_2\nX : Type u_3\ninst✝⁵ : TopologicalSpace S\ninst✝⁴ : TopologicalSpace T\ninst✝³ : TopologicalSpace X\ninst✝² : DiscreteTopology X\ninst✝¹ : T2Space T\ninst✝ : CompactSpace S\nπ : T → S × OnePoint X\nhπ : Continuous π\nσ : Option X → S → T\nhσ : ∀ (x : Option X), Continuous (σ... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Control.Traversable.Equiv | {
"line": 168,
"column": 26
} | {
"line": 168,
"column": 29
} | [
{
"pp": "t t' : Type u → Type u\neqv : (α : Type u) → t α ≃ t' α\ninst✝² : Traversable t\ninst✝¹ : LawfulTraversable t\ninst✝ : Traversable t'\nh₀ : ∀ {α β : Type u} (f : α → β), map f = Equiv.map eqv f\nh₁ : ∀ {α β : Type u} (f : β), mapConst f = (Equiv.map eqv ∘ Function.const α) f\nh₂ :\n ∀ {F : Type u → Ty... | h₂, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Control.Traversable.Equiv | {
"line": 169,
"column": 32
} | {
"line": 169,
"column": 35
} | [
{
"pp": "t t' : Type u → Type u\neqv : (α : Type u) → t α ≃ t' α\ninst✝⁶ : Traversable t\ninst✝⁵ : LawfulTraversable t\ninst✝⁴ : Traversable t'\nh₀ : ∀ {α β : Type u} (f : α → β), map f = Equiv.map eqv f\nh₁ : ∀ {α β : Type u} (f : β), mapConst f = (Equiv.map eqv ∘ Function.const α) f\nh₂ :\n ∀ {F : Type u → T... | h₂, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Control.Traversable.Equiv | {
"line": 170,
"column": 35
} | {
"line": 170,
"column": 38
} | [
{
"pp": "t t' : Type u → Type u\neqv : (α : Type u) → t α ≃ t' α\ninst✝² : Traversable t\ninst✝¹ : LawfulTraversable t\ninst✝ : Traversable t'\nh₀ : ∀ {α β : Type u} (f : α → β), map f = Equiv.map eqv f\nh₁ : ∀ {α β : Type u} (f : β), mapConst f = (Equiv.map eqv ∘ Function.const α) f\nh₂ :\n ∀ {F : Type u → Ty... | h₂, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Control.Traversable.Equiv | {
"line": 171,
"column": 33
} | {
"line": 171,
"column": 36
} | [
{
"pp": "t t' : Type u → Type u\neqv : (α : Type u) → t α ≃ t' α\ninst✝⁶ : Traversable t\ninst✝⁵ : LawfulTraversable t\ninst✝⁴ : Traversable t'\nh₀ : ∀ {α β : Type u} (f : α → β), map f = Equiv.map eqv f\nh₁ : ∀ {α β : Type u} (f : β), mapConst f = (Equiv.map eqv ∘ Function.const α) f\nh₂ :\n ∀ {F : Type u → T... | h₂, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Semiquot | {
"line": 48,
"column": 24
} | {
"line": 48,
"column": 44
} | [
{
"pp": "α : Type u_1\nq₂ : Semiquot α\ns✝ : Set α\nv₁ : Trunc ↑s✝\nh : { s := s✝, val := v₁ }.s = q₂.s\n⊢ { s := s✝, val := v₁ } = q₂",
"usedConstants": []
}
] | obtain ⟨_, v₂⟩ := q₂ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.List.Lookmap | {
"line": 56,
"column": 20
} | {
"line": 56,
"column": 28
} | [
{
"pp": "case none\nα : Type u_1\nf : α → Option α\na : α\nl : List α\nh : f a = none\n⊢ lookmap f (a :: l) =\n match none with\n | none => a :: lookmap f l\n | some b => b :: l",
"usedConstants": [
"congrArg",
"List.lookmap",
"List.cons",
"Option.none",
"List",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Lookmap | {
"line": 56,
"column": 20
} | {
"line": 56,
"column": 28
} | [
{
"pp": "case some\nα : Type u_1\nf : α → Option α\na : α\nl : List α\nval✝ : α\nh : f a = some val✝\n⊢ lookmap f (a :: l) =\n match some val✝ with\n | none => a :: lookmap f l\n | some b => b :: l",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Option.some.injEq",
"Option.some"... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.FinEnum | {
"line": 238,
"column": 4
} | {
"line": 239,
"column": 48
} | [
{
"pp": "case h.e_3\nα : Type u\nβ : α → Type v\ninst✝ : IsEmpty α\ne : FinEnum α\n⊢ equiv ≍ Equiv.equivOfIsEmpty α (Fin 0)",
"usedConstants": [
"congrArg",
"Equiv.equivOfIsEmpty",
"FinEnum.card",
"cast",
"IsEmpty.instSubsingleton",
"Equiv",
"instOfNatNat",
"E... | · refine heq_of_cast_eq ?_ (Subsingleton.allEq _ _)
exact congrArg (α ≃ Fin ·) <| card_eq_zero | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Finset.DenselyOrdered | {
"line": 25,
"column": 73
} | {
"line": 25,
"column": 81
} | [
{
"pp": "α : Type u_1\ninst✝¹ : LinearOrder α\ninst✝ : DenselyOrdered α\ns t : Finset α\nhs : s.Nonempty\nht : t.Nonempty\nH : ∀ x ∈ s, ∀ y ∈ t, x < y\n⊢ s.max' hs < t.min' ht",
"usedConstants": [
"Finset.min'",
"Preorder.toLT",
"Finset",
"PartialOrder.toPreorder",
"Finset.max'... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Finset.DenselyOrdered | {
"line": 25,
"column": 73
} | {
"line": 25,
"column": 81
} | [
{
"pp": "α : Type u_1\ninst✝¹ : LinearOrder α\ninst✝ : DenselyOrdered α\ns t : Finset α\nhs : s.Nonempty\nht : t.Nonempty\nH : ∀ x ∈ s, ∀ y ∈ t, x < y\n⊢ s.max' hs < t.min' ht",
"usedConstants": [
"Finset.min'",
"Preorder.toLT",
"Finset",
"PartialOrder.toPreorder",
"Finset.max'... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.DenselyOrdered | {
"line": 25,
"column": 73
} | {
"line": 25,
"column": 81
} | [
{
"pp": "α : Type u_1\ninst✝¹ : LinearOrder α\ninst✝ : DenselyOrdered α\ns t : Finset α\nhs : s.Nonempty\nht : t.Nonempty\nH : ∀ x ∈ s, ∀ y ∈ t, x < y\n⊢ s.max' hs < t.min' ht",
"usedConstants": [
"Finset.min'",
"Preorder.toLT",
"Finset",
"PartialOrder.toPreorder",
"Finset.max'... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.DenselyOrdered | {
"line": 31,
"column": 55
} | {
"line": 31,
"column": 63
} | [
{
"pp": "α : Type u_1\ninst✝⁴ : LinearOrder α\ninst✝³ : DenselyOrdered α\ns t : Finset α\ninst✝² : NoMaxOrder α\ninst✝¹ : NoMinOrder α\ninst✝ : Nonempty α\nH : ∀ x ∈ s, ∀ y ∈ t, x < y\nhs : s.Nonempty\nht : ¬t.Nonempty\np : α\nhp : s.max' hs < p\n⊢ (∀ x ∈ s, x < p) ∧ ∀ y ∈ t, p < y",
"usedConstants": [
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Finset.DenselyOrdered | {
"line": 31,
"column": 55
} | {
"line": 31,
"column": 63
} | [
{
"pp": "α : Type u_1\ninst✝⁴ : LinearOrder α\ninst✝³ : DenselyOrdered α\ns t : Finset α\ninst✝² : NoMaxOrder α\ninst✝¹ : NoMinOrder α\ninst✝ : Nonempty α\nH : ∀ x ∈ s, ∀ y ∈ t, x < y\nhs : s.Nonempty\nht : ¬t.Nonempty\np : α\nhp : s.max' hs < p\n⊢ (∀ x ∈ s, x < p) ∧ ∀ y ∈ t, p < y",
"usedConstants": [
... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.DenselyOrdered | {
"line": 31,
"column": 55
} | {
"line": 31,
"column": 63
} | [
{
"pp": "α : Type u_1\ninst✝⁴ : LinearOrder α\ninst✝³ : DenselyOrdered α\ns t : Finset α\ninst✝² : NoMaxOrder α\ninst✝¹ : NoMinOrder α\ninst✝ : Nonempty α\nH : ∀ x ∈ s, ∀ y ∈ t, x < y\nhs : s.Nonempty\nht : ¬t.Nonempty\np : α\nhp : s.max' hs < p\n⊢ (∀ x ∈ s, x < p) ∧ ∀ y ∈ t, p < y",
"usedConstants": [
... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.AList | {
"line": 290,
"column": 2
} | {
"line": 292,
"column": 33
} | [
{
"pp": "α : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\nl : AList β\nk k' : α\nv : β k\n⊢ lookup k' (insert k v l) = none ↔ k' ≠ k ∧ lookup k' l = none",
"usedConstants": [
"False",
"eq_false",
"Option.ctorIdx",
"congrArg",
"AList.lookup_insert_ne",
"False.elim",
... | by_cases h : k' = k
· subst h; simp
· simp_all [lookup_insert_ne h] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.AList | {
"line": 290,
"column": 2
} | {
"line": 292,
"column": 33
} | [
{
"pp": "α : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\nl : AList β\nk k' : α\nv : β k\n⊢ lookup k' (insert k v l) = none ↔ k' ≠ k ∧ lookup k' l = none",
"usedConstants": [
"False",
"eq_false",
"Option.ctorIdx",
"congrArg",
"AList.lookup_insert_ne",
"False.elim",
... | by_cases h : k' = k
· subst h; simp
· simp_all [lookup_insert_ne h] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.DenselyOrdered | {
"line": 32,
"column": 55
} | {
"line": 32,
"column": 63
} | [
{
"pp": "α : Type u_1\ninst✝⁴ : LinearOrder α\ninst✝³ : DenselyOrdered α\ns t : Finset α\ninst✝² : NoMaxOrder α\ninst✝¹ : NoMinOrder α\ninst✝ : Nonempty α\nH : ∀ x ∈ s, ∀ y ∈ t, x < y\nhs : ¬s.Nonempty\nht : t.Nonempty\np : α\nhp : p < t.min' ht\n⊢ (∀ x ∈ s, x < p) ∧ ∀ y ∈ t, p < y",
"usedConstants": [
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Finset.DenselyOrdered | {
"line": 32,
"column": 55
} | {
"line": 32,
"column": 63
} | [
{
"pp": "α : Type u_1\ninst✝⁴ : LinearOrder α\ninst✝³ : DenselyOrdered α\ns t : Finset α\ninst✝² : NoMaxOrder α\ninst✝¹ : NoMinOrder α\ninst✝ : Nonempty α\nH : ∀ x ∈ s, ∀ y ∈ t, x < y\nhs : ¬s.Nonempty\nht : t.Nonempty\np : α\nhp : p < t.min' ht\n⊢ (∀ x ∈ s, x < p) ∧ ∀ y ∈ t, p < y",
"usedConstants": [
... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.DenselyOrdered | {
"line": 32,
"column": 55
} | {
"line": 32,
"column": 63
} | [
{
"pp": "α : Type u_1\ninst✝⁴ : LinearOrder α\ninst✝³ : DenselyOrdered α\ns t : Finset α\ninst✝² : NoMaxOrder α\ninst✝¹ : NoMinOrder α\ninst✝ : Nonempty α\nH : ∀ x ∈ s, ∀ y ∈ t, x < y\nhs : ¬s.Nonempty\nht : t.Nonempty\np : α\nhp : p < t.min' ht\n⊢ (∀ x ∈ s, x < p) ∧ ∀ y ∈ t, p < y",
"usedConstants": [
... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.DenselyOrdered | {
"line": 33,
"column": 43
} | {
"line": 33,
"column": 51
} | [
{
"pp": "α : Type u_1\ninst✝⁴ : LinearOrder α\ninst✝³ : DenselyOrdered α\ns t : Finset α\ninst✝² : NoMaxOrder α\ninst✝¹ : NoMinOrder α\ninst✝ : Nonempty α\nH : ∀ x ∈ s, ∀ y ∈ t, x < y\nhs : ¬s.Nonempty\nht : ¬t.Nonempty\np : α\n⊢ (∀ x ∈ s, x < p) ∧ ∀ y ∈ t, p < y",
"usedConstants": [
"False",
"P... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Finset.DenselyOrdered | {
"line": 33,
"column": 43
} | {
"line": 33,
"column": 51
} | [
{
"pp": "α : Type u_1\ninst✝⁴ : LinearOrder α\ninst✝³ : DenselyOrdered α\ns t : Finset α\ninst✝² : NoMaxOrder α\ninst✝¹ : NoMinOrder α\ninst✝ : Nonempty α\nH : ∀ x ∈ s, ∀ y ∈ t, x < y\nhs : ¬s.Nonempty\nht : ¬t.Nonempty\np : α\n⊢ (∀ x ∈ s, x < p) ∧ ∀ y ∈ t, p < y",
"usedConstants": [
"False",
"P... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.DenselyOrdered | {
"line": 33,
"column": 43
} | {
"line": 33,
"column": 51
} | [
{
"pp": "α : Type u_1\ninst✝⁴ : LinearOrder α\ninst✝³ : DenselyOrdered α\ns t : Finset α\ninst✝² : NoMaxOrder α\ninst✝¹ : NoMinOrder α\ninst✝ : Nonempty α\nH : ∀ x ∈ s, ∀ y ∈ t, x < y\nhs : ¬s.Nonempty\nht : ¬t.Nonempty\np : α\n⊢ (∀ x ∈ s, x < p) ∧ ∀ y ∈ t, p < y",
"usedConstants": [
"False",
"P... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.Functor | {
"line": 64,
"column": 2
} | {
"line": 64,
"column": 12
} | [
{
"pp": "case trans\nF : Type u → Type u\ninst✝¹ : Applicative F\ninst✝ : CommApplicative F\nα' β' : Type u\nf : α' → F β'\na b l₁✝ l₂✝ l₃✝ : List α'\na✝¹ : l₁✝ ~ l₂✝\na✝ : l₂✝ ~ l₃✝\na_ih✝¹ : ofList <$> Traversable.traverse f l₁✝ = ofList <$> Traversable.traverse f l₂✝\na_ih✝ : ofList <$> Traversable.traverse ... | | trans => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.List.AList | {
"line": 377,
"column": 2
} | {
"line": 377,
"column": 37
} | [
{
"pp": "α : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\ns : AList β\n⊢ extract a s = (lookup a s, erase a s)",
"usedConstants": [
"Eq.mpr",
"AList.extract._proof_3",
"AList.mk",
"congrArg",
"id",
"Prod.mk",
"List.kextract_eq_dlookup_kerase",
"List.k... | simp [extract]; constructor <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.AList | {
"line": 377,
"column": 2
} | {
"line": 377,
"column": 37
} | [
{
"pp": "α : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\ns : AList β\n⊢ extract a s = (lookup a s, erase a s)",
"usedConstants": [
"Eq.mpr",
"AList.extract._proof_3",
"AList.mk",
"congrArg",
"id",
"Prod.mk",
"List.kextract_eq_dlookup_kerase",
"List.k... | simp [extract]; constructor <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.Functor | {
"line": 100,
"column": 30
} | {
"line": 100,
"column": 37
} | [
{
"pp": "case inl\nα β : Type u\ninst✝ : (P : Prop) → Decidable P\nα✝ β✝ : Type u_1\ns : Finset α✝\n⊢ (if True then ∅ else s) = (image (const β✝) s).sup fun f ↦ ∅",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"if_true",
"congrArg",
"Finset",
"id",
"Fins... | if_true | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.List.Sigma | {
"line": 321,
"column": 4
} | {
"line": 322,
"column": 29
} | [
{
"pp": "case pos\nα : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nb : β a\na' : α\nb' : β a'\nl : List (Sigma β)\nh : a = a'\n⊢ b ∈ lookupAll a (⟨a', b'⟩ :: l) ↔ ⟨a, b⟩ ∈ ⟨a', b'⟩ :: l",
"usedConstants": [
"congrArg",
"heq_eq_eq",
"Membership.mem",
"Sigma.mk.injEq",
... | · subst h
simp [*, mem_lookupAll] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.List.Sigma | {
"line": 376,
"column": 6
} | {
"line": 376,
"column": 14
} | [
{
"pp": "case neg\nα : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nb : β a\nl : List (Sigma β)\nnd : l.NodupKeys\nh : ⟨a, b⟩ ∈ l\na' : α\nb' : β a'\nh' : ⟨a', b'⟩ ∈ l\nh✝¹ : a = a'\nh✝ : ¬decide (a = a') = true\n⊢ False",
"usedConstants": [
"False",
"instDecidableTrue",
"congrArg... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Sigma | {
"line": 376,
"column": 6
} | {
"line": 376,
"column": 14
} | [
{
"pp": "case neg\nα : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nb : β a\nl : List (Sigma β)\nnd : l.NodupKeys\nh : ⟨a, b⟩ ∈ l\na' : α\nb' : β a'\nh' : ⟨a', b'⟩ ∈ l\nh✝¹ : a = a'\nh✝ : ¬decide (a = a') = true\n⊢ False",
"usedConstants": [
"False",
"instDecidableTrue",
"congrArg... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Sigma | {
"line": 376,
"column": 6
} | {
"line": 376,
"column": 14
} | [
{
"pp": "case neg\nα : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nb : β a\nl : List (Sigma β)\nnd : l.NodupKeys\nh : ⟨a, b⟩ ∈ l\na' : α\nb' : β a'\nh' : ⟨a', b'⟩ ∈ l\nh✝¹ : a = a'\nh✝ : ¬decide (a = a') = true\n⊢ False",
"usedConstants": [
"False",
"instDecidableTrue",
"congrArg... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Sigma | {
"line": 377,
"column": 6
} | {
"line": 377,
"column": 14
} | [
{
"pp": "case pos\nα : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nb : β a\nl : List (Sigma β)\nnd : l.NodupKeys\nh : ⟨a, b⟩ ∈ l\na' : α\nb' : β a'\nh' : ⟨a', b'⟩ ∈ l\nh✝¹ : ¬a = a'\nh✝ : decide (a = a') = true\n⊢ False",
"usedConstants": [
"False",
"eq_false",
"congrArg",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Sigma | {
"line": 377,
"column": 6
} | {
"line": 377,
"column": 14
} | [
{
"pp": "case pos\nα : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nb : β a\nl : List (Sigma β)\nnd : l.NodupKeys\nh : ⟨a, b⟩ ∈ l\na' : α\nb' : β a'\nh' : ⟨a', b'⟩ ∈ l\nh✝¹ : ¬a = a'\nh✝ : decide (a = a') = true\n⊢ False",
"usedConstants": [
"False",
"eq_false",
"congrArg",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Sigma | {
"line": 377,
"column": 6
} | {
"line": 377,
"column": 14
} | [
{
"pp": "case pos\nα : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nb : β a\nl : List (Sigma β)\nnd : l.NodupKeys\nh : ⟨a, b⟩ ∈ l\na' : α\nb' : β a'\nh' : ⟨a', b'⟩ ∈ l\nh✝¹ : ¬a = a'\nh✝ : decide (a = a') = true\n⊢ False",
"usedConstants": [
"False",
"eq_false",
"congrArg",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Sigma | {
"line": 484,
"column": 10
} | {
"line": 484,
"column": 18
} | [
{
"pp": "case H\nα : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nl₁ l₂ : List (Sigma β)\nnd : l₁.NodupKeys\na✝³ b✝ : Sigma β\na✝² : a✝³.fst ≠ b✝.fst\na✝¹ : decide (a = a✝³.fst) = true\na✝ : decide (a = b✝.fst) = true\n⊢ False",
"usedConstants": [
"False",
"eq_false",
"congrArg",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.Sigma | {
"line": 653,
"column": 11
} | {
"line": 653,
"column": 27
} | [
{
"pp": "case nil\nα : Type u\nβ : α → Type v\ninst✝¹ : DecidableEq α\ninst✝ : SizeOf (Sigma β)\n⊢ rec 1 (fun head tail tail_ih ↦ 1 + sizeOf head + tail_ih) [].dedupKeys ≤\n rec 1 (fun head tail tail_ih ↦ 1 + sizeOf head + tail_ih) []",
"usedConstants": [
"Lean.Grind.instIsPreorderNat",
"Std.... | simp [dedupKeys] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.List.Sigma | {
"line": 653,
"column": 11
} | {
"line": 653,
"column": 27
} | [
{
"pp": "case nil\nα : Type u\nβ : α → Type v\ninst✝¹ : DecidableEq α\ninst✝ : SizeOf (Sigma β)\n⊢ rec 1 (fun head tail tail_ih ↦ 1 + sizeOf head + tail_ih) [].dedupKeys ≤\n rec 1 (fun head tail tail_ih ↦ 1 + sizeOf head + tail_ih) []",
"usedConstants": [
"Lean.Grind.instIsPreorderNat",
"Std.... | simp [dedupKeys] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Sigma | {
"line": 653,
"column": 11
} | {
"line": 653,
"column": 27
} | [
{
"pp": "case nil\nα : Type u\nβ : α → Type v\ninst✝¹ : DecidableEq α\ninst✝ : SizeOf (Sigma β)\n⊢ rec 1 (fun head tail tail_ih ↦ 1 + sizeOf head + tail_ih) [].dedupKeys ≤\n rec 1 (fun head tail tail_ih ↦ 1 + sizeOf head + tail_ih) []",
"usedConstants": [
"Lean.Grind.instIsPreorderNat",
"Std.... | simp [dedupKeys] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finsupp.NeLocus | {
"line": 71,
"column": 46
} | {
"line": 71,
"column": 59
} | [
{
"pp": "case h\nα : Type u_1\nN : Type u_3\ninst✝² : DecidableEq α\ninst✝¹ : DecidableEq N\ninst✝ : Zero N\nf : α →₀ N\na✝ : α\n⊢ f a✝ ≠ 0 a✝ ↔ f a✝ ≠ 0",
"usedConstants": [
"Finsupp.instFunLike",
"Eq.mpr",
"congrArg",
"Pi.zero_apply",
"id",
"Pi.instZero",
"Ne",
... | Pi.zero_apply | Lean.Elab.Tactic.evalRewriteSeq | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.