module stringlengths 16 90 | startPos dict | endPos dict | nextStartPos dict | goals listlengths 0 96 | goalsAfter listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 371
values | kind stringclasses 375
values |
|---|---|---|---|---|---|---|---|---|
Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | {
"line": 155,
"column": 57
} | {
"line": 155,
"column": 77
} | {
"line": 155,
"column": 77
} | [
{
"pp": "α : Type u\nG : SimpleGraph α\nx✝ : ∃ v w₁ w₂, G.IsPathGraph3Compl v w₁ w₂\nw✝² w✝¹ w✝ : α\nh1 : G.Adj w✝¹ w✝\nh2 : ¬G.Adj w✝² w✝¹\nh3 : ¬G.Adj w✝² w✝\nh : G.IsCompleteMultipartite\n⊢ ¬G.Adj w✝¹ w✝²",
"ppTerm": "?m.40",
"assigned": true,
"usedConstants": [
"congrArg",
"SimpleGra... | [] | rwa [adj_comm] at h2 | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | {
"line": 155,
"column": 57
} | {
"line": 155,
"column": 77
} | {
"line": 155,
"column": 77
} | [
{
"pp": "α : Type u\nG : SimpleGraph α\nx✝ : ∃ v w₁ w₂, G.IsPathGraph3Compl v w₁ w₂\nw✝² w✝¹ w✝ : α\nh1 : G.Adj w✝¹ w✝\nh2 : ¬G.Adj w✝² w✝¹\nh3 : ¬G.Adj w✝² w✝\nh : G.IsCompleteMultipartite\n⊢ ¬G.Adj w✝¹ w✝²",
"ppTerm": "?m.40",
"assigned": true,
"usedConstants": [
"congrArg",
"SimpleGra... | [] | rwa [adj_comm] at h2 | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | {
"line": 246,
"column": 4
} | {
"line": 246,
"column": 45
} | {
"line": 247,
"column": 4
} | [
{
"pp": "α : Type u\nG : SimpleGraph α\ns : Set α\nr t : ℕ\nv : Fin r × Fin t\n⊢ (⟨↑⟨↑v.2 * r + ↑v.1, ⋯⟩ % r, ⋯⟩, ⟨↑⟨↑v.2 * r + ↑v.1, ⋯⟩ / r, ⋯⟩) = v",
"ppTerm": "?m.131",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"add_lt_add_of_le_of_lt",
... | [
"case refine_1\nα : Type u\nG : SimpleGraph α\ns : Set α\nr t : ℕ\nv : Fin r × Fin t\n⊢ ↑(⟨↑⟨↑v.2 * r + ↑v.1, ⋯⟩ % r, ⋯⟩, ⟨↑⟨↑v.2 * r + ↑v.1, ⋯⟩ / r, ⋯⟩).1 = ↑v.1",
"case refine_2\nα : Type u\nG : SimpleGraph α\ns : Set α\nr t : ℕ\nv : Fin r × Fin t\n⊢ ↑(⟨↑⟨↑v.2 * r + ↑v.1, ⋯⟩ % r, ⋯⟩, ⟨↑⟨↑v.2 * r + ↑v.1, ⋯⟩ / r,... | refine Prod.ext (Fin.ext ?_) (Fin.ext ?_) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | {
"line": 204,
"column": 2
} | {
"line": 204,
"column": 16
} | {
"line": 205,
"column": 2
} | [
{
"pp": "V : Type u_1\ninst✝² : Fintype V\nG : SimpleGraph V\ninst✝¹ : DecidableRel G.Adj\nr : ℕ\nh : G.IsTuranMaximal r\ninst✝ : DecidableEq V\nfp : Finpartition univ := h.finpartition\nlarge : Finset V\nhl : large ∈ fp.parts\nsmall : Finset V\nhs : small ∈ fp.parts\nineq : #small + 1 < #large\nw : V\nhw : w ∈... | [
"V : Type u_1\ninst✝² : Fintype V\nG : SimpleGraph V\ninst✝¹ : DecidableRel G.Adj\nr : ℕ\nh : G.IsTuranMaximal r\ninst✝ : DecidableEq V\nfp : Finpartition univ := ⋯\nlarge : Finset V\nhl : large ∈ fp.parts\nsmall : Finset V\nhs : small ∈ fp.parts\nineq : #small + 1 < #large\nw : V\nhw : w ∈ large\nv : V\nhv : v ∈ s... | apply absurd h | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | {
"line": 237,
"column": 2
} | {
"line": 237,
"column": 16
} | {
"line": 238,
"column": 2
} | [
{
"pp": "V : Type u_1\ninst✝² : Fintype V\nG : SimpleGraph V\ninst✝¹ : DecidableRel G.Adj\nr : ℕ\nh : G.IsTuranMaximal r\ninst✝ : DecidableEq V\nfp : Finpartition univ := h.finpartition\nl : #fp.parts < #univ ∧ #fp.parts < r\nx y : V\nhn : x ≠ y\nhe : fp.part x = fp.part y\n⊢ False",
"ppTerm": "?m.136",
... | [
"V : Type u_1\ninst✝² : Fintype V\nG : SimpleGraph V\ninst✝¹ : DecidableRel G.Adj\nr : ℕ\nh : G.IsTuranMaximal r\ninst✝ : DecidableEq V\nfp : Finpartition univ := ⋯\nl : #fp.parts < #univ ∧ #fp.parts < r\nx y : V\nhn : x ≠ y\nhe : fp.part x = fp.part y\n⊢ ¬G.IsTuranMaximal r"
] | apply absurd h | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Combinatorics.SimpleGraph.Extremal.TuranDensity | {
"line": 56,
"column": 76
} | {
"line": 56,
"column": 96
} | {
"line": 57,
"column": 4
} | [
{
"pp": "W : Type u_1\nH : SimpleGraph W\nn : ℕ\nhn : n ≥ 2\nG : SimpleGraph (Fin (n + 1))\ninst✝ : DecidableRel G.Adj\nh : H.Free G\n⊢ ↑(n.choose 2) * ↑(#G.edgeFinset) ≤ ↑((n + 1).choose 2) * ↑(extremalNumber n H)",
"ppTerm": "?m.101",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Gro... | [
"W : Type u_1\nH : SimpleGraph W\nn : ℕ\nhn : n ≥ 2\nG : SimpleGraph (Fin (n + 1))\ninst✝ : DecidableRel G.Adj\nh : H.Free G\n⊢ ↑n * (↑n - 1) / 2 * ↑(#G.edgeFinset) ≤ ↑((n + 1).choose 2) * ↑(extremalNumber n H)"
] | Nat.cast_choose_two, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Combinatorics.SimpleGraph.Extremal.TuranDensity | {
"line": 57,
"column": 4
} | {
"line": 57,
"column": 24
} | {
"line": 57,
"column": 25
} | [
{
"pp": "W : Type u_1\nH : SimpleGraph W\nn : ℕ\nhn : n ≥ 2\nG : SimpleGraph (Fin (n + 1))\ninst✝ : DecidableRel G.Adj\nh : H.Free G\n⊢ ↑n * (↑n - 1) / 2 * ↑(#G.edgeFinset) ≤ ↑((n + 1).choose 2) * ↑(extremalNumber n H)",
"ppTerm": "?m.106",
"assigned": true,
"usedConstants": [
"Eq.mpr",
... | [
"W : Type u_1\nH : SimpleGraph W\nn : ℕ\nhn : n ≥ 2\nG : SimpleGraph (Fin (n + 1))\ninst✝ : DecidableRel G.Adj\nh : H.Free G\n⊢ ↑n * (↑n - 1) / 2 * ↑(#G.edgeFinset) ≤ ↑(n + 1) * (↑(n + 1) - 1) / 2 * ↑(extremalNumber n H)"
] | Nat.cast_choose_two, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | {
"line": 300,
"column": 27
} | {
"line": 300,
"column": 38
} | {
"line": 301,
"column": 4
} | [
{
"pp": "V : Type u_1\ninst✝³ : Fintype V\nG : SimpleGraph V\ninst✝² : DecidableRel G.Adj\nα : Type u_2\ninst✝¹ : Fintype α\ninst✝ : Nontrivial α\n⊢ G.IsExtremal ⊤.Free ↔ G.IsExtremal fun x ↦ x.CliqueFree (Fintype.card α - 1 + 1)",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"Simpl... | [
"V : Type u_1\ninst✝³ : Fintype V\nG : SimpleGraph V\ninst✝² : DecidableRel G.Adj\nα : Type u_2\ninst✝¹ : Fintype α\ninst✝ : Nontrivial α\n⊢ (⊤.Free G ∧ ∀ ⦃G' : SimpleGraph V⦄ [inst : DecidableRel G'.Adj], ⊤.Free G' → #G'.edgeFinset ≤ #G.edgeFinset) ↔\n G.CliqueFree (Fintype.card α - 1 + 1) ∧\n ∀ ⦃G' : Simp... | IsExtremal, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Set.Card.Arithmetic | {
"line": 127,
"column": 8
} | {
"line": 127,
"column": 42
} | {
"line": 128,
"column": 6
} | [
{
"pp": "case neg\nα : Type u_1\nι : Type u_2\nt : Set ι\nht : t.Finite\ns : ι → Set α\nhs : t.PairwiseDisjoint s\ni : ι\nhi : i ∈ t\nhn : (s i).Infinite\n⊢ (⋃ i ∈ t, s i).encard = ∑ᶠ (i : ι) (_ : i ∈ t), (s i).encard",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"S... | [
"case neg\nα : Type u_1\nι : Type u_2\nt : Set ι\nht : t.Finite\ns : ι → Set α\nhs : t.PairwiseDisjoint s\ni : ι\nhi : i ∈ t\nhn : (s i).Infinite\n⊢ (⋃ i_1 ∈ insert i (t \\ {i}), s i_1).encard = ∑ᶠ (i_1 : ι) (_ : i_1 ∈ insert i (t \\ {i})), (s i_1).encard"
] | ← Set.insert_sdiff_self_of_mem hi, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Combinatorics.SimpleGraph.Hall | {
"line": 50,
"column": 23
} | {
"line": 50,
"column": 36
} | {
"line": 50,
"column": 36
} | [
{
"pp": "V : Type u_1\nG : SimpleGraph V\np : Set V\ninst✝ : DecidablePred fun x ↦ x ∈ p\nf : ↑p → V\nh₁ : ∀ (x : ↑p), f x ∉ p\nh₂ : ∀ (x : ↑p), G.Adj (↑x) (f x)\nv w : V\nh✝ : v ∈ p\nh : f ⟨v, h✝⟩ = w\n⊢ v ∈ p",
"ppTerm": "?m.87",
"assigned": true,
"usedConstants": [],
"usedFVars": [
"h✝"... | [] | by assumption | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Combinatorics.SimpleGraph.Hall | {
"line": 51,
"column": 23
} | {
"line": 51,
"column": 36
} | {
"line": 51,
"column": 36
} | [
{
"pp": "V : Type u_1\nG : SimpleGraph V\np : Set V\ninst✝ : DecidablePred fun x ↦ x ∈ p\nf : ↑p → V\nh₁ : ∀ (x : ↑p), f x ∉ p\nh₂ : ∀ (x : ↑p), G.Adj (↑x) (f x)\nv w : V\nh✝¹ : v ∉ p\nh✝ : w ∈ p\nh : f ⟨w, h✝⟩ = v\n⊢ w ∈ p",
"ppTerm": "?m.91",
"assigned": true,
"usedConstants": [],
"usedFVars":... | [] | by assumption | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Combinatorics.SimpleGraph.Hamiltonian | {
"line": 179,
"column": 2
} | {
"line": 180,
"column": 60
} | {
"line": 182,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nG : SimpleGraph α\na : α\np : G.Walk a a\n⊢ p.IsHamiltonianCycle ↔ p.IsCycle ∧ ∀ (a_1 : α), List.count a_1 p.support.tail = 1",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"False",
"congrArg",
"SimpleGraph.Walk.IsCycle",
... | [] | simp +contextual [isHamiltonianCycle_isCycle_and_isHamiltonian_tail,
IsHamiltonian, support_tail_of_not_nil, IsCycle.not_nil] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Combinatorics.SimpleGraph.Hamiltonian | {
"line": 179,
"column": 2
} | {
"line": 180,
"column": 60
} | {
"line": 182,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nG : SimpleGraph α\na : α\np : G.Walk a a\n⊢ p.IsHamiltonianCycle ↔ p.IsCycle ∧ ∀ (a_1 : α), List.count a_1 p.support.tail = 1",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"False",
"congrArg",
"SimpleGraph.Walk.IsCycle",
... | [] | simp +contextual [isHamiltonianCycle_isCycle_and_isHamiltonian_tail,
IsHamiltonian, support_tail_of_not_nil, IsCycle.not_nil] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.SimpleGraph.Hamiltonian | {
"line": 179,
"column": 2
} | {
"line": 180,
"column": 60
} | {
"line": 182,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nG : SimpleGraph α\na : α\np : G.Walk a a\n⊢ p.IsHamiltonianCycle ↔ p.IsCycle ∧ ∀ (a_1 : α), List.count a_1 p.support.tail = 1",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"False",
"congrArg",
"SimpleGraph.Walk.IsCycle",
... | [] | simp +contextual [isHamiltonianCycle_isCycle_and_isHamiltonian_tail,
IsHamiltonian, support_tail_of_not_nil, IsCycle.not_nil] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.SimpleGraph.FiveWheelLike | {
"line": 221,
"column": 2
} | {
"line": 221,
"column": 78
} | {
"line": 222,
"column": 2
} | [
{
"pp": "α : Type u_1\nG : SimpleGraph α\nr : ℕ\ninst✝ : DecidableEq α\nh : Maximal (fun H ↦ H.CliqueFree (r + 2)) G\nhnc : ¬G.IsCompleteMultipartite\nw✝² w✝¹ w✝ : α\ns t : Finset α\nhw : G.IsFiveWheelLike r (#(s ∩ t)) w✝² w✝¹ w✝ s t\n⊢ ∃ k v w₁ w₂ s t, G.IsFiveWheelLike r k v w₁ w₂ s t ∧ k < r ∧ ∀ (j : ℕ), k <... | [
"α : Type u_1\nG : SimpleGraph α\nr : ℕ\ninst✝ : DecidableEq α\nh : Maximal (fun H ↦ H.CliqueFree (r + 2)) G\nhnc : ¬G.IsCompleteMultipartite\nw✝² w✝¹ w✝ : α\ns t : Finset α\nhw : G.IsFiveWheelLike r (#(s ∩ t)) w✝² w✝¹ w✝ s t\nP : ℕ → Prop := fun k ↦ ∃ v w₁ w₂ s t, G.IsFiveWheelLike r k v w₁ w₂ s t\n⊢ ∃ k v w₁ w₂ s... | let P : ℕ → Prop := fun k ↦ ∃ v w₁ w₂ s t, G.IsFiveWheelLike r k v w₁ w₂ s t | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.Combinatorics.SimpleGraph.LapMatrix | {
"line": 136,
"column": 2
} | {
"line": 137,
"column": 60
} | {
"line": 139,
"column": 0
} | [
{
"pp": "V : Type u_1\ninst✝² : Fintype V\nG : SimpleGraph V\ninst✝¹ : DecidableRel G.Adj\ninst✝ : DecidableEq V\nx : V → ℝ\n⊢ lapMatrix ℝ G *ᵥ x = 0 ↔ ∀ (i j : V), G.Adj i j → x i = x j",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Pi.Function.module",
"Pi.i... | [] | rw [← (posSemidef_lapMatrix ℝ G).toLinearMap₂'_zero_iff, star_trivial,
lapMatrix_toLinearMap₂'_apply'_eq_zero_iff_forall_adj] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Combinatorics.SimpleGraph.LapMatrix | {
"line": 136,
"column": 2
} | {
"line": 137,
"column": 60
} | {
"line": 139,
"column": 0
} | [
{
"pp": "V : Type u_1\ninst✝² : Fintype V\nG : SimpleGraph V\ninst✝¹ : DecidableRel G.Adj\ninst✝ : DecidableEq V\nx : V → ℝ\n⊢ lapMatrix ℝ G *ᵥ x = 0 ↔ ∀ (i j : V), G.Adj i j → x i = x j",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Pi.Function.module",
"Pi.i... | [] | rw [← (posSemidef_lapMatrix ℝ G).toLinearMap₂'_zero_iff, star_trivial,
lapMatrix_toLinearMap₂'_apply'_eq_zero_iff_forall_adj] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.SimpleGraph.LapMatrix | {
"line": 136,
"column": 2
} | {
"line": 137,
"column": 60
} | {
"line": 139,
"column": 0
} | [
{
"pp": "V : Type u_1\ninst✝² : Fintype V\nG : SimpleGraph V\ninst✝¹ : DecidableRel G.Adj\ninst✝ : DecidableEq V\nx : V → ℝ\n⊢ lapMatrix ℝ G *ᵥ x = 0 ↔ ∀ (i j : V), G.Adj i j → x i = x j",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Pi.Function.module",
"Pi.i... | [] | rw [← (posSemidef_lapMatrix ℝ G).toLinearMap₂'_zero_iff, star_trivial,
lapMatrix_toLinearMap₂'_apply'_eq_zero_iff_forall_adj] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.SimpleGraph.Trails | {
"line": 110,
"column": 4
} | {
"line": 110,
"column": 18
} | {
"line": 111,
"column": 4
} | [
{
"pp": "case mpr\nV : Type u_1\nG : SimpleGraph V\ninst✝ : DecidableEq V\nu v : V\np : G.Walk u v\n⊢ (p.IsTrail ∧ ∀ e ∈ G.edgeSet, e ∈ p.edges) → p.IsEulerian",
"ppTerm": "?mpr",
"assigned": true,
"usedConstants": [
"SimpleGraph.Walk.IsEulerian",
"Membership.mem",
"SimpleGraph.edg... | [
"case mpr\nV : Type u_1\nG : SimpleGraph V\ninst✝ : DecidableEq V\nu v : V\np : G.Walk u v\nh : p.IsTrail\nhl : ∀ e ∈ G.edgeSet, e ∈ p.edges\n⊢ p.IsEulerian"
] | rintro ⟨h, hl⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.Combinatorics.SimpleGraph.Matching | {
"line": 579,
"column": 89
} | {
"line": 596,
"column": 9
} | {
"line": 598,
"column": 0
} | [
{
"pp": "V : Type u_1\nG G' : SimpleGraph V\nu x : V\nhalt : G.IsAlternating G'\nhnadj : ¬G'.Adj u x\nhu' : ∀ (u' : V), u' ≠ u → G.Adj x u' → G'.Adj x u'\nhx' : ∀ (x' : V), x' ≠ x → G.Adj x' u → G'.Adj x' u\n⊢ (G ⊔ edge u x).IsAlternating G'",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
... | [] | by
by_cases hadj : G.Adj u x
· rwa [sup_edge_of_adj G hadj]
intro v w w' hww' hvw hvv'
simp only [sup_adj, edge_adj] at hvw hvv'
obtain hl | hr := hvw <;> obtain h1 | h2 := hvv'
· exact halt hww' hl h1
· rw [G'.adj_congr_of_sym2 (by grind : s(v, w') = s(u, x))]
simp only [hnadj, not_false_eq_true, iff... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.Partrec | {
"line": 84,
"column": 10
} | {
"line": 84,
"column": 22
} | {
"line": 85,
"column": 6
} | [
{
"pp": "case false.inr\np : ℕ →. Bool\nH : ∃ n, true ∈ p n ∧ ∀ k < n, (p k).Dom\nm : ℕ\nIH : (y : ℕ) → lbp p y m → (∀ n < y, false ∈ p n) → { n // true ∈ p n ∧ ∀ m < n, false ∈ p m }\nal : ∀ n < m, false ∈ p n\npm : (p m).Dom\ne : (p m).get pm = false\nn : ℕ\nh✝ : n ≤ m\nh : n = m\n⊢ false ∈ p m",
"ppTerm"... | [] | exact ⟨_, e⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Computability.Partrec | {
"line": 183,
"column": 12
} | {
"line": 183,
"column": 22
} | {
"line": 184,
"column": 2
} | [
{
"pp": "case zero\nf : ℕ → ℕ\n⊢ Nat.Partrec ↑fun x ↦ 0",
"ppTerm": "?zero",
"assigned": true,
"usedConstants": [
"Nat.Partrec.zero"
],
"usedFVars": [],
"usedGoals": []
}
] | [] | exact zero | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Computability.Partrec | {
"line": 183,
"column": 12
} | {
"line": 183,
"column": 22
} | {
"line": 184,
"column": 2
} | [
{
"pp": "case zero\nf : ℕ → ℕ\n⊢ Nat.Partrec ↑fun x ↦ 0",
"ppTerm": "?zero",
"assigned": true,
"usedConstants": [
"Nat.Partrec.zero"
],
"usedFVars": [],
"usedGoals": []
}
] | [] | exact zero | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.Partrec | {
"line": 183,
"column": 12
} | {
"line": 183,
"column": 22
} | {
"line": 184,
"column": 2
} | [
{
"pp": "case zero\nf : ℕ → ℕ\n⊢ Nat.Partrec ↑fun x ↦ 0",
"ppTerm": "?zero",
"assigned": true,
"usedConstants": [
"Nat.Partrec.zero"
],
"usedFVars": [],
"usedGoals": []
}
] | [] | exact zero | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.Partrec | {
"line": 250,
"column": 4
} | {
"line": 250,
"column": 42
} | {
"line": 252,
"column": 0
} | [
{
"pp": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nf : α → σ\nhf : Primrec f\nn : ℕ\n⊢ (do\n let n ← (↑fun n ↦ encode (Option.map f (decode n))) n\n ↑n.ppred) =\n (↑(decode n)).bind fun a ↦ map encode (↑f a)",
"ppTerm": "?m.17",
"assigned": true,
"usedCo... | [] | simp; cases decode (α := α) n <;> simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.Partrec | {
"line": 250,
"column": 4
} | {
"line": 250,
"column": 42
} | {
"line": 252,
"column": 0
} | [
{
"pp": "α : Type u_1\nσ : Type u_2\ninst✝¹ : Primcodable α\ninst✝ : Primcodable σ\nf : α → σ\nhf : Primrec f\nn : ℕ\n⊢ (do\n let n ← (↑fun n ↦ encode (Option.map f (decode n))) n\n ↑n.ppred) =\n (↑(decode n)).bind fun a ↦ map encode (↑f a)",
"ppTerm": "?m.17",
"assigned": true,
"usedCo... | [] | simp; cases decode (α := α) n <;> simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.Ackermann | {
"line": 97,
"column": 34
} | {
"line": 97,
"column": 53
} | {
"line": 97,
"column": 54
} | [
{
"pp": "case succ\nn : ℕ\nIH : ack 3 n = 2 ^ (n + 3) - 3\n⊢ 2 * 2 ^ (n + 3) - 2 * 3 + 3 = 2 * 2 ^ (n + 3) - 3",
"ppTerm": "?succ",
"assigned": true,
"usedConstants": [
"instPowNat",
"Eq.mpr",
"HMul.hMul",
"CommSemiring.toNonUnitalCommSemiring",
"congrArg",
"Nat.i... | [
"case succ\nn : ℕ\nIH : ack 3 n = 2 ^ (n + 3) - 3\n⊢ 2 * 2 ^ (n + 3) + 3 - 2 * 3 = 2 * 2 ^ (n + 3) - 3",
"case succ\nn : ℕ\nIH : ack 3 n = 2 ^ (n + 3) - 3\n⊢ 2 * 3 ≤ 2 * 2 ^ (n + 3)"
] | ← Nat.sub_add_comm, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.Ackermann | {
"line": 233,
"column": 14
} | {
"line": 233,
"column": 21
} | {
"line": 233,
"column": 22
} | [
{
"pp": "case succ\nk : ℕ\na✝ : k ^ 2 ≤ 2 ^ (k + 1) - 3\n⊢ (k + 1) ^ 2 ≤ 2 ^ (k + 1 + 1) - 3",
"ppTerm": "?succ",
"assigned": true,
"usedConstants": [
"Nat.instMonoid",
"HSub.hSub",
"instSubNat",
"instOfNatNat",
"LE.le",
"instLENat",
"Monoid.toPow",
"N... | [
"case succ.zero\na✝ : 0 ^ 2 ≤ 2 ^ (0 + 1) - 3\n⊢ (0 + 1) ^ 2 ≤ 2 ^ (0 + 1 + 1) - 3",
"case succ.succ\nn✝ : ℕ\na✝ : (n✝ + 1) ^ 2 ≤ 2 ^ (n✝ + 1 + 1) - 3\n⊢ (n✝ + 1 + 1) ^ 2 ≤ 2 ^ (n✝ + 1 + 1 + 1) - 3"
] | cases k | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Computability.Ackermann | {
"line": 372,
"column": 4
} | {
"line": 372,
"column": 67
} | {
"line": 373,
"column": 2
} | [
{
"pp": "this : Primrec fun t ↦ Nat.rec succ (fun x c ↦ pappAck.step c) t\n⊢ Primrec pappAck",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.recAux",
"congrArg",
"Primcodable.ofDenumerable",
"HEq.refl",
"Nat.Partrec.Code",
"Nat.rec",... | [] | convert! this using 2 with n; induction n <;> simp [pappAck, *] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.Ackermann | {
"line": 372,
"column": 4
} | {
"line": 372,
"column": 67
} | {
"line": 373,
"column": 2
} | [
{
"pp": "this : Primrec fun t ↦ Nat.rec succ (fun x c ↦ pappAck.step c) t\n⊢ Primrec pappAck",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.recAux",
"congrArg",
"Primcodable.ofDenumerable",
"HEq.refl",
"Nat.Partrec.Code",
"Nat.rec",... | [] | convert! this using 2 with n; induction n <;> simp [pappAck, *] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.Primrec.List | {
"line": 751,
"column": 2
} | {
"line": 751,
"column": 21
} | {
"line": 751,
"column": 22
} | [
{
"pp": "case pair\nn : ℕ\nf✝¹ : List.Vector ℕ n → ℕ\nf f✝ g✝ : ℕ → ℕ\na✝¹ : Nat.Primrec f✝\na✝ : Nat.Primrec g✝\nhf : Primrec' fun v ↦ f✝ v.head\nhg : Primrec' fun v ↦ g✝ v.head\n⊢ Primrec' fun v ↦ (fun n ↦ pair (f✝ n) (g✝ n)) v.head",
"ppTerm": "?pair",
"assigned": true,
"usedConstants": [
"... | [] | | pair _ _ hf hg => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Computability.AkraBazzi.SumTransform | {
"line": 146,
"column": 59
} | {
"line": 146,
"column": 84
} | {
"line": 147,
"column": 13
} | [
{
"pp": "case h₂\nα : Type u_1\ninst✝¹ : Fintype α\nT : ℕ → ℝ\ng : ℝ → ℝ\na b : α → ℝ\nr : α → ℕ → ℕ\ninst✝ : Nonempty α\nR : AkraBazziRecurrence T g a b r\nn : ℕ\nhn : ∀ (i : α), ‖↑(r i n) - b i * ↑n‖ ≤ ↑n / log ↑n ^ 2\ni : α\n⊢ ↑(r i n) - b i * ↑n ≤ ‖↑(r i n) - b i * ↑n‖",
"ppTerm": "?h₂",
"assigned":... | [] | exact Real.le_norm_self _ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Computability.AkraBazzi.SumTransform | {
"line": 358,
"column": 68
} | {
"line": 361,
"column": 21
} | {
"line": 363,
"column": 0
} | [
{
"pp": "x : ℝ\n⊢ deriv ε x = -x⁻¹ / log x ^ 2",
"ppTerm": "?m.30",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MulOne.toOne",
"Real",
"DivInvMonoid.toInv",
"instHDiv",
"Semiring.toModule",
"Real.denselyNormedField",
"Monoid.toMulOneClass",
"... | [] | by
unfold smoothingFn
simp_rw [one_div]
apply deriv_inv_log | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.PartrecCode | {
"line": 490,
"column": 2
} | {
"line": 490,
"column": 61
} | {
"line": 491,
"column": 2
} | [
{
"pp": "cf cg : Code\na k : ℕ\n⊢ (cf.prec cg).eval (Nat.pair a k.succ) = do\n let ih ← (cf.prec cg).eval (Nat.pair a k)\n cg.eval (Nat.pair a (Nat.pair k ih))",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Part",
"Eq.mpr",
"PFun",
"congrArg",
"Part.bi... | [
"cf cg : Code\na k : ℕ\n⊢ Nat.rec (cf.eval (a, k.succ).1)\n (fun y IH ↦ do\n let i ← IH\n cg.eval (Nat.pair (a, k.succ).1 (Nat.pair y i)))\n (a, k.succ).2 =\n (unpaired\n (fun a n ↦\n Nat.rec (cf.eval a)\n (fun y IH ↦ do\n let i ← IH\n ... | rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Computability.AkraBazzi.GrowsPolynomially | {
"line": 453,
"column": 4
} | {
"line": 464,
"column": 48
} | {
"line": 465,
"column": 4
} | [
{
"pp": "case lb\nf g : ℝ → ℝ\nhf✝ : GrowsPolynomially f\nhfg : ∀ᶠ (x : ℝ) in atTop, ‖g x‖ ≤ 1 / 2 * ‖f x‖\nb : ℝ\nhb : b ∈ Set.Ioo 0 1\nhb_ub : b < 1\nhf' : ∀ᶠ (x : ℝ) in atTop, f x ≤ 0\nc₁ : ℝ\nhc₁_mem : 0 < c₁\nc₂ : ℝ\nhc₂_mem : 0 < c₂\nhf : ∀ᶠ (x : ℝ) in atTop, ∀ u ∈ Set.Icc (b * x) x, f u ∈ Set.Icc (c₁ * f... | [
"case ub\nf g : ℝ → ℝ\nhf✝ : GrowsPolynomially f\nhfg : ∀ᶠ (x : ℝ) in atTop, ‖g x‖ ≤ 1 / 2 * ‖f x‖\nb : ℝ\nhb : b ∈ Set.Ioo 0 1\nhb_ub : b < 1\nhf' : ∀ᶠ (x : ℝ) in atTop, f x ≤ 0\nc₁ : ℝ\nhc₁_mem : 0 < c₁\nc₂ : ℝ\nhc₂_mem : 0 < c₂\nhf : ∀ᶠ (x : ℝ) in atTop, ∀ u ∈ Set.Icc (b * x) x, f u ∈ Set.Icc (c₁ * f x) (c₂ * f ... | case lb =>
calc f u + g u ≥ f u - ‖g u‖ := by
rw [sub_eq_add_neg, norm_eq_abs]; gcongr; exact neg_abs_le _
_ ≥ f u + 1 / 2 * f u := by
rw [sub_eq_add_neg]
gcongr
refine le_of_neg_le_neg ?_
rwa [neg_neg, ← neg_mul,... | Lean.Elab.Tactic.evalCase | Lean.Parser.Tactic.case |
Mathlib.Computability.AkraBazzi.GrowsPolynomially | {
"line": 491,
"column": 10
} | {
"line": 491,
"column": 41
} | {
"line": 492,
"column": 10
} | [
{
"pp": "f : ℝ → ℝ\nhf : GrowsPolynomially f\nthis : GrowsPolynomially fun x ↦ |(f x)⁻¹|\nhf' : ∀ᶠ (x : ℝ) in atTop, 0 < f x\n⊢ (fun x ↦ (f x)⁻¹) =ᶠ[atTop] fun x ↦ |(f x)⁻¹|",
"ppTerm": "?m.155",
"assigned": true,
"usedConstants": [
"Real",
"Real.lattice",
"Real.instZero",
"a... | [
"f : ℝ → ℝ\nhf : GrowsPolynomially f\nthis : GrowsPolynomially fun x ↦ |(f x)⁻¹|\nhf' : ∀ᶠ (x : ℝ) in atTop, 0 < f x\nx : ℝ\nhx₁ : 0 < f x\n⊢ (f x)⁻¹ = |(f x)⁻¹|"
] | filter_upwards [hf'] with x hx₁ | Mathlib.Tactic._aux_Mathlib_Order_Filter_Defs___elabRules_Mathlib_Tactic_filterUpwards_1 | Mathlib.Tactic.filterUpwards |
Mathlib.Computability.AkraBazzi.GrowsPolynomially | {
"line": 496,
"column": 10
} | {
"line": 496,
"column": 41
} | {
"line": 497,
"column": 10
} | [
{
"pp": "f : ℝ → ℝ\nhf : GrowsPolynomially f\nthis : GrowsPolynomially fun x ↦ |(f x)⁻¹|\nhf' : ∀ᶠ (x : ℝ) in atTop, f x < 0\n⊢ (fun x ↦ (f x)⁻¹) =ᶠ[atTop] fun x ↦ -|(f x)⁻¹|",
"ppTerm": "?m.217",
"assigned": true,
"usedConstants": [
"Real",
"Real.lattice",
"Real.instZero",
"... | [
"f : ℝ → ℝ\nhf : GrowsPolynomially f\nthis : GrowsPolynomially fun x ↦ |(f x)⁻¹|\nhf' : ∀ᶠ (x : ℝ) in atTop, f x < 0\nx : ℝ\nhx₁ : f x < 0\n⊢ (f x)⁻¹ = -|(f x)⁻¹|"
] | filter_upwards [hf'] with x hx₁ | Mathlib.Tactic._aux_Mathlib_Order_Filter_Defs___elabRules_Mathlib_Tactic_filterUpwards_1 | Mathlib.Tactic.filterUpwards |
Mathlib.Computability.Language | {
"line": 314,
"column": 12
} | {
"line": 314,
"column": 46
} | {
"line": 314,
"column": 47
} | [
{
"pp": "case a.h.inl\nα : Type u_1\nl m n : Language α\nhm : [] ∉ m\nh : l = m * l + n\na : List α\nha : a ∈ m\nb : List α\nhb : b ∈ l\nih : b ∈ m∗ * n\nhx : a ++ b ∈ m * l\nhal : 0 < a.length\n⊢ a ++ b ∈ m∗ * n",
"ppTerm": "?a.h.inl✝",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"La... | [
"case a.h.inl\nα : Type u_1\nl m n : Language α\nhm : [] ∉ m\nh : l = m * l + n\na : List α\nha : a ∈ m\nb : List α\nhb : b ∈ l\nih : b ∈ m∗ * n\nhx : a ++ b ∈ m * l\nhal : 0 < a.length\n⊢ a ++ b ∈ (1 + m * m∗) * n"
] | ← one_add_self_mul_kstar_eq_kstar, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.DFA | {
"line": 212,
"column": 31
} | {
"line": 212,
"column": 40
} | {
"line": 214,
"column": 0
} | [
{
"pp": "case append_singleton\nα : Type u\nσ : Type v\nM : DFA α σ\nα' : Type u_1\nf : α' → α\ns : σ\nx : List α'\na : α'\nih : (comap f M).evalFrom s x = M.evalFrom s (List.map f x)\n⊢ (comap f M).evalFrom s (x ++ [a]) = M.evalFrom s (List.map f (x ++ [a]))",
"ppTerm": "?append_singleton",
"assigned":... | [] | simp [ih] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Computability.DFA | {
"line": 212,
"column": 31
} | {
"line": 212,
"column": 40
} | {
"line": 214,
"column": 0
} | [
{
"pp": "case append_singleton\nα : Type u\nσ : Type v\nM : DFA α σ\nα' : Type u_1\nf : α' → α\ns : σ\nx : List α'\na : α'\nih : (comap f M).evalFrom s x = M.evalFrom s (List.map f x)\n⊢ (comap f M).evalFrom s (x ++ [a]) = M.evalFrom s (List.map f (x ++ [a]))",
"ppTerm": "?append_singleton",
"assigned":... | [] | simp [ih] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.DFA | {
"line": 212,
"column": 31
} | {
"line": 212,
"column": 40
} | {
"line": 214,
"column": 0
} | [
{
"pp": "case append_singleton\nα : Type u\nσ : Type v\nM : DFA α σ\nα' : Type u_1\nf : α' → α\ns : σ\nx : List α'\na : α'\nih : (comap f M).evalFrom s x = M.evalFrom s (List.map f x)\n⊢ (comap f M).evalFrom s (x ++ [a]) = M.evalFrom s (List.map f (x ++ [a]))",
"ppTerm": "?append_singleton",
"assigned":... | [] | simp [ih] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.DFA | {
"line": 254,
"column": 31
} | {
"line": 254,
"column": 40
} | {
"line": 256,
"column": 0
} | [
{
"pp": "case append_singleton\nα : Type u\nσ : Type v\nM : DFA α σ\nσ' : Type u_2\ng : σ ≃ σ'\ns : σ'\nx : List α\na : α\nih : ((reindex g) M).evalFrom s x = g (M.evalFrom (g.symm s) x)\n⊢ ((reindex g) M).evalFrom s (x ++ [a]) = g (M.evalFrom (g.symm s) (x ++ [a]))",
"ppTerm": "?append_singleton",
"ass... | [] | simp [ih] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Computability.DFA | {
"line": 254,
"column": 31
} | {
"line": 254,
"column": 40
} | {
"line": 256,
"column": 0
} | [
{
"pp": "case append_singleton\nα : Type u\nσ : Type v\nM : DFA α σ\nσ' : Type u_2\ng : σ ≃ σ'\ns : σ'\nx : List α\na : α\nih : ((reindex g) M).evalFrom s x = g (M.evalFrom (g.symm s) x)\n⊢ ((reindex g) M).evalFrom s (x ++ [a]) = g (M.evalFrom (g.symm s) (x ++ [a]))",
"ppTerm": "?append_singleton",
"ass... | [] | simp [ih] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.DFA | {
"line": 254,
"column": 31
} | {
"line": 254,
"column": 40
} | {
"line": 256,
"column": 0
} | [
{
"pp": "case append_singleton\nα : Type u\nσ : Type v\nM : DFA α σ\nσ' : Type u_2\ng : σ ≃ σ'\ns : σ'\nx : List α\na : α\nih : ((reindex g) M).evalFrom s x = g (M.evalFrom (g.symm s) x)\n⊢ ((reindex g) M).evalFrom s (x ++ [a]) = g (M.evalFrom (g.symm s) (x ++ [a]))",
"ppTerm": "?append_singleton",
"ass... | [] | simp [ih] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.DFA | {
"line": 310,
"column": 2
} | {
"line": 312,
"column": 60
} | {
"line": 314,
"column": 0
} | [
{
"pp": "α : Type u\nσ1 σ2 : Type v\nM1 : DFA α σ1\nM2 : DFA α σ2\ns1 : σ1\ns2 : σ2\nx : List α\n⊢ (M1.union M2).evalFrom (s1, s2) x ∈ (M1.union M2).accept ↔ M1.evalFrom s1 x ∈ M1.accept ∨ M2.evalFrom s2 x ∈ M2.accept",
"ppTerm": "?m.34",
"assigned": true,
"usedConstants": [
"DFA.union_step",
... | [] | induction x generalizing s1 s2 with
| nil => simp
| cons a x ih => simp only [evalFrom_cons, union_step, ih] | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.Nat.Size | {
"line": 109,
"column": 6
} | {
"line": 109,
"column": 15
} | {
"line": 110,
"column": 4
} | [
{
"pp": "case bit\nb✝ : Bool\nn✝ : ℕ\nh : n✝ = 0 → b✝ = true\nih : n✝.bits.length = n✝.size\n⊢ (b✝ :: n✝.bits).length = n✝.size.succ",
"ppTerm": "?bit",
"assigned": true,
"usedConstants": [
"congrArg",
"Nat.bits",
"instOfNatNat",
"List.cons",
"instHAdd",
"Nat.add_... | [] | simp [ih] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Nat.Size | {
"line": 109,
"column": 6
} | {
"line": 109,
"column": 15
} | {
"line": 110,
"column": 4
} | [
{
"pp": "case bit\nb✝ : Bool\nn✝ : ℕ\nh : n✝ = 0 → b✝ = true\nih : n✝.bits.length = n✝.size\n⊢ (b✝ :: n✝.bits).length = n✝.size.succ",
"ppTerm": "?bit",
"assigned": true,
"usedConstants": [
"congrArg",
"Nat.bits",
"instOfNatNat",
"List.cons",
"instHAdd",
"Nat.add_... | [] | simp [ih] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Size | {
"line": 109,
"column": 6
} | {
"line": 109,
"column": 15
} | {
"line": 110,
"column": 4
} | [
{
"pp": "case bit\nb✝ : Bool\nn✝ : ℕ\nh : n✝ = 0 → b✝ = true\nih : n✝.bits.length = n✝.size\n⊢ (b✝ :: n✝.bits).length = n✝.size.succ",
"ppTerm": "?bit",
"assigned": true,
"usedConstants": [
"congrArg",
"Nat.bits",
"instOfNatNat",
"List.cons",
"instHAdd",
"Nat.add_... | [] | simp [ih] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Bitwise | {
"line": 223,
"column": 2
} | {
"line": 223,
"column": 22
} | {
"line": 224,
"column": 4
} | [
{
"pp": "case bit\nf : Bool → Bool → Bool\nbm : Bool\nm : ℕ\nhm : m = 0 → bm = true\nihm : ∀ (n : ℕ), bitwise (swap f) m n = bitwise f n m\nn : ℕ\n⊢ bitwise (swap f) (bit bm m) n = bitwise f n (bit bm m)",
"ppTerm": "?bit",
"assigned": true,
"usedConstants": [
"Nat.bit",
"Eq.mpr",
... | [] | | bit bm m hm ihm => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Computability.NFA | {
"line": 80,
"column": 53
} | {
"line": 80,
"column": 70
} | {
"line": 82,
"column": 0
} | [
{
"pp": "α : Type u\nσ : Type v\nM : NFA α σ\na : α\n⊢ M.stepSet ∅ a = ∅",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"False",
"NFA.step",
"Set.mem_empty_iff_false._simp_1",
"Iff.of_eq",
"congrArg",
"Membership.mem",
"funext",
"Set.iUnion_o... | [] | by simp [stepSet] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.NFA | {
"line": 133,
"column": 19
} | {
"line": 133,
"column": 28
} | {
"line": 135,
"column": 0
} | [
{
"pp": "case cons\nα : Type u\nσ : Type v\nM : NFA α σ\na : α\nx : List α\nih : ∀ (S T : Set σ), M.evalFrom (S ∪ T) x = M.evalFrom S x ∪ M.evalFrom T x\nS T : Set σ\n⊢ M.evalFrom (S ∪ T) (a :: x) = M.evalFrom S (a :: x) ∪ M.evalFrom T (a :: x)",
"ppTerm": "?cons",
"assigned": true,
"usedConstants":... | [] | simp [ih] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Computability.NFA | {
"line": 133,
"column": 19
} | {
"line": 133,
"column": 28
} | {
"line": 135,
"column": 0
} | [
{
"pp": "case cons\nα : Type u\nσ : Type v\nM : NFA α σ\na : α\nx : List α\nih : ∀ (S T : Set σ), M.evalFrom (S ∪ T) x = M.evalFrom S x ∪ M.evalFrom T x\nS T : Set σ\n⊢ M.evalFrom (S ∪ T) (a :: x) = M.evalFrom S (a :: x) ∪ M.evalFrom T (a :: x)",
"ppTerm": "?cons",
"assigned": true,
"usedConstants":... | [] | simp [ih] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.NFA | {
"line": 133,
"column": 19
} | {
"line": 133,
"column": 28
} | {
"line": 135,
"column": 0
} | [
{
"pp": "case cons\nα : Type u\nσ : Type v\nM : NFA α σ\na : α\nx : List α\nih : ∀ (S T : Set σ), M.evalFrom (S ∪ T) x = M.evalFrom S x ∪ M.evalFrom T x\nS T : Set σ\n⊢ M.evalFrom (S ∪ T) (a :: x) = M.evalFrom S (a :: x) ∪ M.evalFrom T (a :: x)",
"ppTerm": "?cons",
"assigned": true,
"usedConstants":... | [] | simp [ih] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.Lemmas | {
"line": 58,
"column": 76
} | {
"line": 59,
"column": 53
} | {
"line": 61,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : AddGroupWithOne α\nn : PosNum\n⊢ ↑↑n = ↑n",
"ppTerm": "?m.2",
"assigned": true,
"usedConstants": [
"Int.cast",
"Eq.mpr",
"Int.cast_natCast",
"castPosNum",
"Nat.instOne",
"AddMonoid.toAddSemigroup",
"congrArg",
"AddGroupWi... | [] | by
rw [← to_nat_to_int, Int.cast_natCast, cast_to_nat] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.NFA | {
"line": 299,
"column": 27
} | {
"line": 299,
"column": 51
} | {
"line": 299,
"column": 52
} | [
{
"pp": "α : Type u\nσ : Type v\nM : NFA α σ\ns t : σ\nx✝ : List α\na : α\nx : List α\nh : t ∈ M.evalFrom (M.stepSet {s} a) x\n⊢ ∃ s' ∈ M.step s a, t ∈ M.evalFrom {s'} x",
"ppTerm": "?m.281",
"assigned": true,
"usedConstants": [
"congrArg",
"NFA.evalFrom",
"Membership.mem",
"... | [
"α : Type u\nσ : Type v\nM : NFA α σ\ns t : σ\nx✝ : List α\na : α\nx : List α\nh : ∃ t_1 ∈ M.stepSet {s} a, t ∈ M.evalFrom {t_1} x\n⊢ ∃ s' ∈ M.step s a, t ∈ M.evalFrom {s'} x"
] | mem_evalFrom_iff_exists, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.EpsilonNFA | {
"line": 120,
"column": 29
} | {
"line": 120,
"column": 43
} | {
"line": 120,
"column": 43
} | [
{
"pp": "case nil\nα : Type u\nσ : Type v\nM : εNFA α σ\n⊢ M.εClosure ∅ = ∅",
"ppTerm": "?nil",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"Set.instEmptyCollection",
"εNFA.εClosure_empty",
"EmptyCollection.emptyCollection",
"Eq",
... | [
"case nil\nα : Type u\nσ : Type v\nM : εNFA α σ\n⊢ ∅ = ∅"
] | εClosure_empty | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.Lemmas | {
"line": 370,
"column": 25
} | {
"line": 370,
"column": 85
} | {
"line": 372,
"column": 0
} | [
{
"pp": "x✝² x✝¹ x✝ : Num\n⊢ (x✝² + x✝¹) * x✝ = x✝² * x✝ + x✝¹ * x✝",
"ppTerm": "?m.148",
"assigned": true,
"usedConstants": [
"add_mul",
"Nat.instMulZeroClass",
"HMul.hMul",
"Nat.instOne",
"AddMonoid.toAddSemigroup",
"congrArg",
"Distrib.rightDistribClass",... | [] | by simp only [← to_nat_inj, mul_to_nat, add_to_nat, add_mul] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Num.Lemmas | {
"line": 415,
"column": 77
} | {
"line": 416,
"column": 53
} | {
"line": 418,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : AddGroupWithOne α\nn : Num\n⊢ ↑↑n = ↑n",
"ppTerm": "?m.3",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Int.cast",
"Eq.mpr",
"Int.cast_natCast",
"Nat.instMulZeroClass",
"Nat.instOne",
"AddMonoid.toAddSe... | [] | by
rw [← to_nat_to_int, Int.cast_natCast, cast_to_nat] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Num.Lemmas | {
"line": 454,
"column": 30
} | {
"line": 454,
"column": 76
} | {
"line": 454,
"column": 76
} | [
{
"pp": "m n : PosNum\nh : ↑m = ↑n\n⊢ pos m = pos n",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"castPosNum",
"Nat.instOne",
"congrArg",
"PosNum.of_to_nat",
"id",
"AddMonoidWithOne.toNatCast",
"Nat.cast",
"Num",
"Nat"... | [] | rw [← PosNum.of_to_nat, ← PosNum.of_to_nat, h] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Num.Lemmas | {
"line": 454,
"column": 30
} | {
"line": 454,
"column": 76
} | {
"line": 454,
"column": 76
} | [
{
"pp": "m n : PosNum\nh : ↑m = ↑n\n⊢ pos m = pos n",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"castPosNum",
"Nat.instOne",
"congrArg",
"PosNum.of_to_nat",
"id",
"AddMonoidWithOne.toNatCast",
"Nat.cast",
"Num",
"Nat"... | [] | rw [← PosNum.of_to_nat, ← PosNum.of_to_nat, h] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.Lemmas | {
"line": 454,
"column": 30
} | {
"line": 454,
"column": 76
} | {
"line": 454,
"column": 76
} | [
{
"pp": "m n : PosNum\nh : ↑m = ↑n\n⊢ pos m = pos n",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"castPosNum",
"Nat.instOne",
"congrArg",
"PosNum.of_to_nat",
"id",
"AddMonoidWithOne.toNatCast",
"Nat.cast",
"Num",
"Nat"... | [] | rw [← PosNum.of_to_nat, ← PosNum.of_to_nat, h] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.Lemmas | {
"line": 488,
"column": 8
} | {
"line": 488,
"column": 20
} | {
"line": 488,
"column": 20
} | [
{
"pp": "n : PosNum\n⊢ (↑n).size + 1 = (Nat.bit false ↑n).size",
"ppTerm": "?m.45",
"assigned": true,
"usedConstants": [
"Nat.bit",
"Eq.mpr",
"castPosNum",
"Nat.instOne",
"congrArg",
"id",
"instOfNatNat",
"Nat.size_bit",
"instHAdd",
"HAdd.h... | [
"n : PosNum\n⊢ (↑n).size + 1 = (↑n).size.succ",
"n : PosNum\n⊢ Nat.bit false ↑n ≠ 0"
] | Nat.size_bit | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.Lemmas | {
"line": 493,
"column": 8
} | {
"line": 493,
"column": 20
} | {
"line": 493,
"column": 20
} | [
{
"pp": "n : PosNum\n⊢ (↑n).size + 1 = (Nat.bit true ↑n).size",
"ppTerm": "?m.70",
"assigned": true,
"usedConstants": [
"Nat.bit",
"Eq.mpr",
"castPosNum",
"Nat.instOne",
"congrArg",
"id",
"instOfNatNat",
"Nat.size_bit",
"Bool.true",
"instHA... | [
"n : PosNum\n⊢ (↑n).size + 1 = (↑n).size.succ",
"n : PosNum\n⊢ Nat.bit true ↑n ≠ 0"
] | Nat.size_bit | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.PartrecBasis | {
"line": 112,
"column": 22
} | {
"line": 125,
"column": 11
} | {
"line": 127,
"column": 0
} | [
{
"pp": "n : ℕ\nf : List.Vector ℕ (n + 1) → ℕ\nhf : Partrec' ↑f\nv : List.Vector ℕ n\nb : ℕ\n⊢ (b ∈ (Nat.rfind fun n_1 ↦ Part.some (decide (1 - f (n_1 ::ᵥ v) = 0))).bind fun a ↦ ↑pred (f (a ::ᵥ v))) ↔\n b ∈ Nat.rfindOpt fun a ↦ ofNat (Option ℕ) (f (a ::ᵥ v))",
"ppTerm": "?m.70",
"assigned": true,
... | [] | by
simp only [Nat.rfindOpt, Nat.sub_eq_zero_iff_le, PFun.coe_val, Part.mem_bind_iff,
Part.mem_some_iff, Option.mem_def, Part.mem_coe]
refine
exists_congr fun a => (and_congr (iff_of_eq ?_) Iff.rfl).trans (and_congr_right fun h => ?_)
· congr
funext n
cases f (n ::ᵥ v) <... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 554,
"column": 27
} | {
"line": 554,
"column": 51
} | {
"line": 554,
"column": 52
} | [
{
"pp": "case push\nK : 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 : ... | [
"case push\nK : 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 : σ → Γ k\nthi... | ListBlank.nth_modifyNth, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.Lemmas | {
"line": 805,
"column": 2
} | {
"line": 805,
"column": 50
} | {
"line": 805,
"column": 51
} | [
{
"pp": "⊢ ∀ (m n : Num), ↑(m.ldiff n) = (↑m).ldiff ↑n",
"ppTerm": "?m.2",
"assigned": true,
"usedConstants": [
"Bool.not",
"Num.castNum_eq_bitwise",
"Num.ldiff",
"Bool.and",
"Bool",
"PosNum",
"PosNum.ldiff"
],
"usedFVars": [],
"usedGoals": [
... | [
"case gff\n⊢ (false && !false) = false",
"case f00\n⊢ ldiff 0 0 = 0",
"case f0n\nn✝ : PosNum\n⊢ ldiff 0 (pos n✝) = bif false && !true then pos n✝ else 0",
"case fn0\nn✝ : PosNum\n⊢ (pos n✝).ldiff 0 = bif true && !false then pos n✝ else 0",
"case fnn\nm✝ n✝ : PosNum\n⊢ (pos m✝).ldiff (pos n✝) = m✝.ldiff n✝",... | apply castNum_eq_bitwise PosNum.ldiff <;> intros | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Computability.TuringMachine.Config | {
"line": 555,
"column": 8
} | {
"line": 555,
"column": 25
} | {
"line": 555,
"column": 25
} | [
{
"pp": "case cons₁\nk' : Cont\na✝² : Code\na✝¹ : List ℕ\na✝ : Cont\na_ih✝ : ∀ {v : List ℕ}, stepRet (a✝.then k') v = (stepRet a✝ v).then k'\nv : List ℕ\n⊢ stepNormal a✝² (Cont.cons₂ v (a✝.then k')) a✝¹ = (stepNormal a✝² (Cont.cons₂ v a✝) a✝¹).then k'",
"ppTerm": "?cons₁",
"assigned": true,
"usedCon... | [
"case cons₁\nk' : Cont\na✝² : Code\na✝¹ : List ℕ\na✝ : Cont\na_ih✝ : ∀ {v : List ℕ}, stepRet (a✝.then k') v = (stepRet a✝ v).then k'\nv : List ℕ\n⊢ stepNormal a✝² (Cont.cons₂ v (a✝.then k')) a✝¹ = stepNormal a✝² ((Cont.cons₂ v a✝).then k') a✝¹"
] | ← stepNormal_then | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.TuringMachine.Config | {
"line": 558,
"column": 8
} | {
"line": 558,
"column": 25
} | {
"line": 558,
"column": 25
} | [
{
"pp": "case comp\nk' : Cont\na✝¹ : Code\na✝ : Cont\na_ih✝ : ∀ {v : List ℕ}, stepRet (a✝.then k') v = (stepRet a✝ v).then k'\nv : List ℕ\n⊢ stepNormal a✝¹ (a✝.then k') v = (stepNormal a✝¹ a✝ v).then k'",
"ppTerm": "?comp",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
... | [
"case comp\nk' : Cont\na✝¹ : Code\na✝ : Cont\na_ih✝ : ∀ {v : List ℕ}, stepRet (a✝.then k') v = (stepRet a✝ v).then k'\nv : List ℕ\n⊢ stepNormal a✝¹ (a✝.then k') v = stepNormal a✝¹ (a✝.then k') v"
] | ← stepNormal_then | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.TuringMachine.Config | {
"line": 562,
"column": 10
} | {
"line": 562,
"column": 27
} | {
"line": 562,
"column": 27
} | [
{
"pp": "case neg\nk' : Cont\na✝¹ : Code\na✝ : Cont\nk_ih : ∀ {v : List ℕ}, stepRet (a✝.then k') v = (stepRet a✝ v).then k'\nv : List ℕ\nh✝ : ¬v.headI = 0\n⊢ stepNormal a✝¹ (Cont.fix a✝¹ (a✝.then k')) v.tail = (stepNormal a✝¹ (Cont.fix a✝¹ a✝) v.tail).then k'",
"ppTerm": "?neg✝",
"assigned": true,
"... | [
"case neg\nk' : Cont\na✝¹ : Code\na✝ : Cont\nk_ih : ∀ {v : List ℕ}, stepRet (a✝.then k') v = (stepRet a✝ v).then k'\nv : List ℕ\nh✝ : ¬v.headI = 0\n⊢ stepNormal a✝¹ (Cont.fix a✝¹ (a✝.then k')) v.tail = stepNormal a✝¹ ((Cont.fix a✝¹ a✝).then k') v.tail"
] | ← stepNormal_then | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 597,
"column": 29
} | {
"line": 597,
"column": 53
} | {
"line": 597,
"column": 54
} | [
{
"pp": "case pop.cons\nK : 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\n... | [
"case pop.cons\nK : 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 : σ → Opti... | ListBlank.nth_modifyNth, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Category.CompHausLike.EffectiveEpi | {
"line": 56,
"column": 12
} | {
"line": 56,
"column": 25
} | {
"line": 57,
"column": 4
} | [
{
"pp": "P : TopCat → Prop\nB X : CompHausLike P\nπ : X ⟶ B\nhπ : Function.Surjective ⇑(ConcreteCategory.hom π)\nW✝ : CompHausLike P\ne : X ⟶ W✝\nh : ∀ {Z : CompHausLike P} (g₁ g₂ : Z ⟶ X), g₁ ≫ π = g₂ ≫ π → g₁ ≫ e = g₂ ≫ e\ng : B ⟶ W✝\nhm : π ≫ g = e\nthis : g = ofHom P (⋯.liftEquiv ⟨TopCat.Hom.hom e.hom, ⋯⟩)\... | [] | by assumption | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 772,
"column": 6
} | {
"line": 772,
"column": 63
} | {
"line": 773,
"column": 6
} | [
{
"pp": "case refine_1\nK : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\ninst✝¹ : DecidableEq K\nM : Λ → TM2.Stmt Γ Λ σ\ninst✝ : Inhabited Λ\nS : Finset Λ\nss : TM2.Supports M S\nk✝ : K\ns : StAct K Γ σ k✝\nq✝ : TM2.Stmt Γ Λ σ\nIH :\n TM2.SupportsStmt S q✝ →\n (∀ x ∈ trStmts₁ q✝, x ∈ trSupp M S) ... | [
"case refine_1\nK : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\ninst✝¹ : DecidableEq K\nM : Λ → TM2.Stmt Γ Λ σ\ninst✝ : Inhabited Λ\nS : Finset Λ\nss : TM2.Supports M S\nk✝ : K\ns : StAct K Γ σ k✝\nq✝ : TM2.Stmt Γ Λ σ\nIH :\n TM2.SupportsStmt S q✝ →\n (∀ x ∈ trStmts₁ q✝, x ∈ trSupp M S) →\n TM1... | obtain ⟨IH₁, IH₂⟩ := IH ss' fun x hx ↦ sub x <| Or.inr hx | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 786,
"column": 6
} | {
"line": 786,
"column": 37
} | {
"line": 787,
"column": 6
} | [
{
"pp": "case refine_2\nK : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\ninst✝¹ : DecidableEq K\nM : Λ → TM2.Stmt Γ Λ σ\ninst✝ : Inhabited Λ\nS : Finset Λ\nss : TM2.Supports M S\na✝ : σ → σ\nq✝ : TM2.Stmt Γ Λ σ\nIH :\n TM2.SupportsStmt S q✝ →\n (∀ x ∈ trStmts₁ q✝, x ∈ trSupp M S) →\n TM1.Sup... | [
"case refine_2\nK : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\ninst✝¹ : DecidableEq K\nM : Λ → TM2.Stmt Γ Λ σ\ninst✝ : Inhabited Λ\nS : Finset Λ\nss : TM2.Supports M S\na✝ : σ → σ\nq✝ : TM2.Stmt Γ Λ σ\nIH :\n TM2.SupportsStmt S q✝ →\n (∀ x ∈ trStmts₁ q✝, x ∈ trSupp M S) →\n TM1.SupportsStmt (t... | unfold TM2to1.trStmts₁ at sub ⊢ | Lean.Elab.Tactic.evalUnfold | Lean.Parser.Tactic.unfold |
Mathlib.Topology.ExtremallyDisconnected | {
"line": 201,
"column": 4
} | {
"line": 201,
"column": 33
} | {
"line": 202,
"column": 4
} | [
{
"pp": "case neg\nA E : Type u\ninst✝¹ : TopologicalSpace A\ninst✝ : TopologicalSpace E\nρ : E → A\nρ_cont : Continuous ρ\nρ_surj : Surjective ρ\nzorn_subset : ∀ (E₀ : Set E), E₀ ≠ univ → IsClosed E₀ → ρ '' E₀ ≠ univ\nG : Set E\nhG : IsOpen G\nG_empty : ¬G = ∅\nN : Set A\nN_open : IsOpen N\ne : E\nhe : e ∈ G\n... | [
"case neg\nA E : Type u\ninst✝¹ : TopologicalSpace A\ninst✝ : TopologicalSpace E\nρ : E → A\nρ_cont : Continuous ρ\nρ_surj : Surjective ρ\nzorn_subset : ∀ (E₀ : Set E), E₀ ≠ univ → IsClosed E₀ → ρ '' E₀ ≠ univ\nG : Set E\nhG : IsOpen G\nG_empty : ¬G = ∅\nN : Set A\nN_open : IsOpen N\ne : E\nhe : e ∈ G\nha : ρ e ∈ ρ... | rcases ρ_surj x with ⟨y, rfl⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Logic.Function.FiberPartition | {
"line": 58,
"column": 51
} | {
"line": 58,
"column": 67
} | {
"line": 58,
"column": 67
} | [
{
"pp": "Y : Type u_2\nZ : Type u_3\nf : Y → Z\ny : Y\na : Fiber f\nh : f y = image f a\n⊢ y ∈ ↑a",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Membership.mem",
"Set.Elem",
"Set.instSingletonSet",
"id",
"Set.preimage",
... | [
"Y : Type u_2\nZ : Type u_3\nf : Y → Z\ny : Y\na : Fiber f\nh : f y = image f a\n⊢ y ∈ f ⁻¹' {image f a}"
] | a.eq_fiber_image | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Category.CompHausLike.SigmaComparison | {
"line": 54,
"column": 2
} | {
"line": 67,
"column": 5
} | {
"line": 69,
"column": 0
} | [
{
"pp": "P : TopCat → Prop\ninst✝⁶ : HasExplicitFiniteCoproducts P\nX : (CompHausLike P)ᵒᵖ ⥤ Type (max u w)\ninst✝⁵ : PreservesFiniteProducts X\nα : Type u\ninst✝⁴ : Finite α\nσ : α → Type u\ninst✝³ : (a : α) → TopologicalSpace (σ a)\ninst✝² : ∀ (a : α), CompactSpace (σ a)\ninst✝¹ : ∀ (a : α), T2Space (σ a)\nin... | [] | ext x a
simp only [TypeCat.Fun.toFun_apply, Cofan.mk_pt, Fan.mk_pt, Functor.mapIso_hom,
PreservesProduct.iso_hom, comp_apply, Types.productIso_hom_comp_eval_apply]
have := ConcreteCategory.congr_hom (piComparison_comp_π X (fun a ↦ ⟨of P (σ a)⟩) a)
simp only [comp_apply] at this
rw [this, ← comp_apply, ← Fun... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Category.CompHausLike.SigmaComparison | {
"line": 54,
"column": 2
} | {
"line": 67,
"column": 5
} | {
"line": 69,
"column": 0
} | [
{
"pp": "P : TopCat → Prop\ninst✝⁶ : HasExplicitFiniteCoproducts P\nX : (CompHausLike P)ᵒᵖ ⥤ Type (max u w)\ninst✝⁵ : PreservesFiniteProducts X\nα : Type u\ninst✝⁴ : Finite α\nσ : α → Type u\ninst✝³ : (a : α) → TopologicalSpace (σ a)\ninst✝² : ∀ (a : α), CompactSpace (σ a)\ninst✝¹ : ∀ (a : α), T2Space (σ a)\nin... | [] | ext x a
simp only [TypeCat.Fun.toFun_apply, Cofan.mk_pt, Fan.mk_pt, Functor.mapIso_hom,
PreservesProduct.iso_hom, comp_apply, Types.productIso_hom_comp_eval_apply]
have := ConcreteCategory.congr_hom (piComparison_comp_π X (fun a ↦ ⟨of P (σ a)⟩) a)
simp only [comp_apply] at this
rw [this, ← comp_apply, ← Fun... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Category.LightProfinite.AsLimit | {
"line": 123,
"column": 84
} | {
"line": 125,
"column": 65
} | {
"line": 127,
"column": 0
} | [
{
"pp": "S : LightProfinite\nn : ℕ\n⊢ Function.Surjective ⇑(ConcreteCategory.hom (S.transitionMap n))",
"ppTerm": "?m.4",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Opposite",
"congrArg",
"CategoryTheory.ConcreteCategory.hom",
"SecondCountableTopology",
"Cont... | [] | by
apply Function.Surjective.of_comp (g := S.proj (n + 1))
simpa only [proj_comp_transitionMap'] using S.proj_surjective n | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Condensed.Epi | {
"line": 62,
"column": 4
} | {
"line": 62,
"column": 68
} | {
"line": 63,
"column": 4
} | [
{
"pp": "A : Type u'\ninst✝⁹ : Category.{v', u'} A\nFA : A → A → Type u_1\nCA : A → Type v'\ninst✝⁸ : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)\ninst✝⁷ : ConcreteCategory A FA\ninst✝⁶ : HasFunctorialSurjectiveInjectiveFactorization A\nX Y : Condensed A\nf : X ⟶ Y\ninst✝⁵ : PreservesFiniteProducts (CategoryTheo... | [
"A : Type u'\ninst✝⁹ : Category.{v', u'} A\nFA : A → A → Type u_1\nCA : A → Type v'\ninst✝⁸ : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)\ninst✝⁷ : ConcreteCategory A FA\ninst✝⁶ : HasFunctorialSurjectiveInjectiveFactorization A\nX Y : Condensed A\nf : X ⟶ Y\ninst✝⁵ : PreservesFiniteProducts (CategoryTheory.forget A)... | ← Presheaf.coherentExtensiveEquivalence.functor.epi_map_iff_epi, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Condensed.Light.Epi | {
"line": 74,
"column": 4
} | {
"line": 75,
"column": 74
} | {
"line": 77,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝ : Ring R\nX Y : LightCondMod R\nf✝ : X ⟶ Y\nX✝ Y✝ : LightCondMod R\nf : X✝ ⟶ Y✝\nhf : Epi ((LightCondensed.forget R).map f)\n⊢ Epi f",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"CategoryTheory.Limits.Types.hasColimitsOfSize",
"ModuleCat.instReflec... | [] | rw [← Sheaf.isLocallySurjective_iff_epi'] at hf ⊢
exact (Presheaf.isLocallySurjective_iff_whisker_forget _ f.hom).mpr hf | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Condensed.Light.Epi | {
"line": 74,
"column": 4
} | {
"line": 75,
"column": 74
} | {
"line": 77,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝ : Ring R\nX Y : LightCondMod R\nf✝ : X ⟶ Y\nX✝ Y✝ : LightCondMod R\nf : X✝ ⟶ Y✝\nhf : Epi ((LightCondensed.forget R).map f)\n⊢ Epi f",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"CategoryTheory.Limits.Types.hasColimitsOfSize",
"ModuleCat.instReflec... | [] | rw [← Sheaf.isLocallySurjective_iff_epi'] at hf ⊢
exact (Presheaf.isLocallySurjective_iff_whisker_forget _ f.hom).mpr hf | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Control.Fold | {
"line": 240,
"column": 24
} | {
"line": 240,
"column": 57
} | {
"line": 242,
"column": 0
} | [
{
"pp": "α β γ : Type u\ninst✝¹ : Monoid α\ninst✝ : Monoid β\nf : α →* β\n⊢ ∀ {α_1 : Type ?u.17} (x : α_1), f (pure x) = pure x",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Pure.pure",
"MonoidHom.instMonoidHomClass",
"MulOne.toOne",
"MonoidHom.instFunLike",
... | [] | intros; simp only [map_one, pure] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Control.Fold | {
"line": 240,
"column": 24
} | {
"line": 240,
"column": 57
} | {
"line": 242,
"column": 0
} | [
{
"pp": "α β γ : Type u\ninst✝¹ : Monoid α\ninst✝ : Monoid β\nf : α →* β\n⊢ ∀ {α_1 : Type ?u.17} (x : α_1), f (pure x) = pure x",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Pure.pure",
"MonoidHom.instMonoidHomClass",
"MulOne.toOne",
"MonoidHom.instFunLike",
... | [] | intros; simp only [map_one, pure] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Control.LawfulFix | {
"line": 127,
"column": 8
} | {
"line": 127,
"column": 16
} | {
"line": 128,
"column": 6
} | [
{
"pp": "α : Type u_1\nβ : α → Type u_2\nf : ((a : α) → Part (β a)) →o (a : α) → Part (β a)\nx : α\ni : ℕ\nhx : Part.fix (⇑f) x ≤ approx (⇑f) i x\n⊢ Part.fix (⇑f) x ≤ ?m.39",
"ppTerm": "?m.40",
"assigned": true,
"usedConstants": [],
"usedFVars": [
"hx"
],
"usedGoals": []
}
] | [] | apply hx | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Control.LawfulFix | {
"line": 127,
"column": 8
} | {
"line": 127,
"column": 16
} | {
"line": 128,
"column": 6
} | [
{
"pp": "α : Type u_1\nβ : α → Type u_2\nf : ((a : α) → Part (β a)) →o (a : α) → Part (β a)\nx : α\ni : ℕ\nhx : Part.fix (⇑f) x ≤ approx (⇑f) i x\n⊢ Part.fix (⇑f) x ≤ ?m.39",
"ppTerm": "?m.40",
"assigned": true,
"usedConstants": [],
"usedFVars": [
"hx"
],
"usedGoals": []
}
] | [] | apply hx | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Control.LawfulFix | {
"line": 127,
"column": 8
} | {
"line": 127,
"column": 16
} | {
"line": 128,
"column": 6
} | [
{
"pp": "α : Type u_1\nβ : α → Type u_2\nf : ((a : α) → Part (β a)) →o (a : α) → Part (β a)\nx : α\ni : ℕ\nhx : Part.fix (⇑f) x ≤ approx (⇑f) i x\n⊢ Part.fix (⇑f) x ≤ ?m.39",
"ppTerm": "?m.40",
"assigned": true,
"usedConstants": [],
"usedFVars": [
"hx"
],
"usedGoals": []
}
] | [] | apply hx | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Control.LawfulFix | {
"line": 137,
"column": 78
} | {
"line": 147,
"column": 14
} | {
"line": 149,
"column": 0
} | [
{
"pp": "α : Type u_1\nβ : α → Type u_2\nf : ((a : α) → Part (β a)) →o (a : α) → Part (β a)\nX : (a : α) → Part (β a)\nhX : f X ≤ X\n⊢ Part.fix ⇑f ≤ X",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"Part",
"Eq.mpr",
"Nat.recAux",
"Pi.preorder",
"OrderHom.mono... | [] | by
rw [fix_eq_ωSup f]
apply ωSup_le _ _ _
simp only [Fix.approxChain]
intro i
induction i with
| zero => apply bot_le
| succ _ i_ih =>
trans f X
· apply f.monotone i_ih
· apply hX | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Control.LawfulFix | {
"line": 160,
"column": 4
} | {
"line": 163,
"column": 39
} | {
"line": 164,
"column": 2
} | [
{
"pp": "case a\nα : Type u_1\nβ : α → Type u_2\ng : ((a : α) → Part (β a)) → (a : α) → Part (β a)\nhc : ωScottContinuous g\n⊢ ωSup (approxChain { toFun := g, monotone' := ⋯ }) ≤\n ωSup ((approxChain { toFun := g, monotone' := ⋯ }).map { toFun := g, monotone' := ⋯ })",
"ppTerm": "?a✝",
"assigned": tr... | [] | apply ωSup_le_ωSup_of_le _
intro i
exists i
apply le_f_of_mem_approx _ ⟨i, rfl⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Control.LawfulFix | {
"line": 160,
"column": 4
} | {
"line": 163,
"column": 39
} | {
"line": 164,
"column": 2
} | [
{
"pp": "case a\nα : Type u_1\nβ : α → Type u_2\ng : ((a : α) → Part (β a)) → (a : α) → Part (β a)\nhc : ωScottContinuous g\n⊢ ωSup (approxChain { toFun := g, monotone' := ⋯ }) ≤\n ωSup ((approxChain { toFun := g, monotone' := ⋯ }).map { toFun := g, monotone' := ⋯ })",
"ppTerm": "?a✝",
"assigned": tr... | [] | apply ωSup_le_ωSup_of_le _
intro i
exists i
apply le_f_of_mem_approx _ ⟨i, rfl⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Analysis.Filter | {
"line": 262,
"column": 51
} | {
"line": 262,
"column": 64
} | {
"line": 262,
"column": 64
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nσ : Type u_3\nτ : Type u_4\nf✝ : Filter α\nm : α → Filter β\nF : f✝.Realizer\nG : (i : α) → (m i).Realizer\nx✝ : (s : F.σ) × ((i : α) → i ∈ F.F.f s → (G i).σ)\ns : F.σ\nf : (i : α) → i ∈ F.F.f s → (G i).σ\ni : α\nh✝ : i ∈ F.F.f s\n⊢ i ∈ F.F.f s",
"ppTerm": "?m.148",
... | [] | by assumption | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Condensed.Light.Sequence | {
"line": 283,
"column": 4
} | {
"line": 283,
"column": 42
} | {
"line": 284,
"column": 4
} | [
{
"pp": "case refine_1\nS T : LightProfinite\nπ : T ⟶ S ⊗ ℕ∪{∞}\ninst✝ : Epi π\nthis✝ : CompactSpace ↑(S' ⇑(ConcreteCategory.hom π))\nS'π : (n : ↑ℕ∪{∞}.toTop) →\n LightProfinite.of ↑(S' ⇑(ConcreteCategory.hom π)) ⟶ LightProfinite.fibre n (π ≫ snd S ℕ∪{∞}) :=\n fun n ↦ { hom := TopCat.ofHom { toFun := fun x ↦ ... | [
"case refine_1\nS T : LightProfinite\nπ : T ⟶ S ⊗ ℕ∪{∞}\ninst✝ : Epi π\nthis✝ : CompactSpace ↑(S' ⇑(ConcreteCategory.hom π))\nS'π : (n : ↑ℕ∪{∞}.toTop) →\n LightProfinite.of ↑(S' ⇑(ConcreteCategory.hom π)) ⟶ LightProfinite.fibre n (π ≫ snd S ℕ∪{∞}) :=\n fun n ↦ { hom := TopCat.ofHom { toFun := fun x ↦ ↑x n, contin... | rw [LightProfinite.epi_iff_surjective] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Condensed.Light.Sequence | {
"line": 288,
"column": 4
} | {
"line": 288,
"column": 42
} | {
"line": 289,
"column": 4
} | [
{
"pp": "case refine_2\nS T : LightProfinite\nπ : T ⟶ S ⊗ ℕ∪{∞}\ninst✝ : Epi π\nthis✝ : CompactSpace ↑(S' ⇑(ConcreteCategory.hom π))\nS'π : (n : ↑ℕ∪{∞}.toTop) →\n LightProfinite.of ↑(S' ⇑(ConcreteCategory.hom π)) ⟶ LightProfinite.fibre n (π ≫ snd S ℕ∪{∞}) :=\n fun n ↦ { hom := TopCat.ofHom { toFun := fun x ↦ ... | [
"case refine_2\nS T : LightProfinite\nπ : T ⟶ S ⊗ ℕ∪{∞}\ninst✝ : Epi π\nthis✝ : CompactSpace ↑(S' ⇑(ConcreteCategory.hom π))\nS'π : (n : ↑ℕ∪{∞}.toTop) →\n LightProfinite.of ↑(S' ⇑(ConcreteCategory.hom π)) ⟶ LightProfinite.fibre n (π ≫ snd S ℕ∪{∞}) :=\n fun n ↦ { hom := TopCat.ofHom { toFun := fun x ↦ ↑x n, contin... | rw [LightProfinite.epi_iff_surjective] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.DFinsupp.Interval | {
"line": 51,
"column": 4
} | {
"line": 51,
"column": 36
} | {
"line": 52,
"column": 4
} | [
{
"pp": "case refine_1\nι : Type u_1\nα : ι → Type u_2\ninst✝² : DecidableEq ι\ninst✝¹ : (i : ι) → Zero (α i)\ns : Finset ι\nt : (i : ι) → Finset (α i)\ninst✝ : (i : ι) → DecidableEq (α i)\nf : (a : ι) → a ∈ s → α a\nhf : f ∈ s.pi t\n⊢ ({ toFun := fun f ↦ DFinsupp.mk s fun i ↦ f ↑i ⋯, inj' := ⋯ } f).support ⊆ s... | [
"case refine_1\nι : Type u_1\nα : ι → Type u_2\ninst✝² : DecidableEq ι\ninst✝¹ : (i : ι) → Zero (α i)\ns : Finset ι\nt : (i : ι) → Finset (α i)\ninst✝ : (i : ι) → DecidableEq (α i)\nf : (a : ι) → a ∈ s → α a\nhf : f ∈ s.pi t\n⊢ (DFinsupp.mk s fun i ↦ f ↑i ⋯).support ⊆ s ∧ ∀ i ∈ s, (DFinsupp.mk s fun i ↦ f ↑i ⋯) i ∈... | rw [Function.Embedding.coeFn_mk] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Condensed.Light.Sequence | {
"line": 294,
"column": 4
} | {
"line": 294,
"column": 42
} | {
"line": 295,
"column": 4
} | [
{
"pp": "case refine_5\nS T : LightProfinite\nπ : T ⟶ S ⊗ ℕ∪{∞}\ninst✝ : Epi π\nthis✝ : CompactSpace ↑(S' ⇑(ConcreteCategory.hom π))\nS'π : (n : ↑ℕ∪{∞}.toTop) →\n LightProfinite.of ↑(S' ⇑(ConcreteCategory.hom π)) ⟶ LightProfinite.fibre n (π ≫ snd S ℕ∪{∞}) :=\n fun n ↦ { hom := TopCat.ofHom { toFun := fun x ↦ ... | [
"case refine_5\nS T : LightProfinite\nπ : T ⟶ S ⊗ ℕ∪{∞}\ninst✝ : Epi π\nthis✝ : CompactSpace ↑(S' ⇑(ConcreteCategory.hom π))\nS'π : (n : ↑ℕ∪{∞}.toTop) →\n LightProfinite.of ↑(S' ⇑(ConcreteCategory.hom π)) ⟶ LightProfinite.fibre n (π ≫ snd S ℕ∪{∞}) :=\n fun n ↦ { hom := TopCat.ofHom { toFun := fun x ↦ ↑x n, contin... | rw [LightProfinite.epi_iff_surjective] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.List.AList | {
"line": 457,
"column": 5
} | {
"line": 476,
"column": 19
} | {
"line": 476,
"column": 19
} | [
{
"pp": "α : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\ns₁ s₂ : AList β\nh : s₁.Disjoint s₂\n⊢ ∀ (x : α) (y : β x), y ∈ dlookup x (s₁ ∪ s₂).entries ↔ y ∈ dlookup x (s₂ ∪ s₁).entries",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"List.kunion",
"congrArg",
... | [] | by
intros; simp only [union_entries, Option.mem_def, dlookup_kunion_eq_some]
constructor <;> intro h'
· rcases h' with h' | h'
· right
refine ⟨?_, h'⟩
apply h
rw [keys, ← List.dlookup_isSome, h']
exact rfl
· left
rw [h'.2]
· rcase... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Finmap | {
"line": 607,
"column": 14
} | {
"line": 615,
"column": 59
} | {
"line": 615,
"column": 59
} | [
{
"pp": "α : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\ns₁ s₂ s₃ : Finmap β\nh : s₁.Disjoint s₃\nh' : s₂.Disjoint s₃\nh'' : s₁ ∪ s₃ = s₂ ∪ s₃\n⊢ s₁ = s₂",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Finmap.ext_lookup",
"congrArg",
"... | [] | by
apply ext_lookup
intro x
have : (s₁ ∪ s₃).lookup x = (s₂ ∪ s₃).lookup x := h'' ▸ rfl
by_cases hs₁ : x ∈ s₁
· rwa [lookup_union_left hs₁, lookup_union_left_of_not_in (h _ hs₁)] at this
· by_cases hs₂ : x ∈ s₂
· rwa [lookup_union_left_of_not_in (h' _ hs₂), lookup_union_left hs₂] at this
... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Finset.PiInduction | {
"line": 56,
"column": 4
} | {
"line": 56,
"column": 17
} | {
"line": 57,
"column": 4
} | [
{
"pp": "case intro.a.inr\nι : Type u_1\nα : ι → Type u_2\ninst✝² : Finite ι\ninst✝¹ : DecidableEq ι\ninst✝ : (i : ι) → DecidableEq (α i)\nr : (i : ι) → α i → Finset (α i) → Prop\nH_ex : ∀ (i : ι) (s : Finset (α i)), s.Nonempty → ∃ x ∈ s, r i x (s.erase x)\np : ((i : ι) → Finset (α i)) → Prop\nh0 : p fun x ↦ ∅\... | [
"case intro.a.inr\nι : Type u_1\nα : ι → Type u_2\ninst✝² : Finite ι\ninst✝¹ : DecidableEq ι\ninst✝ : (i : ι) → DecidableEq (α i)\nr : (i : ι) → α i → Finset (α i) → Prop\nH_ex : ∀ (i : ι) (s : Finset (α i)), s.Nonempty → ∃ x ∈ s, r i x (s.erase x)\np : ((i : ι) → Finset (α i)) → Prop\nh0 : p fun x ↦ ∅\nstep : ∀ (g... | clear_value g | Lean.Elab.Tactic.evalClearValue | Lean.Parser.Tactic.clearValue |
Mathlib.Data.Finset.PiInduction | {
"line": 65,
"column": 4
} | {
"line": 65,
"column": 61
} | {
"line": 66,
"column": 4
} | [
{
"pp": "case intro.a.inr\nι : Type u_1\nα : ι → Type u_2\ninst✝² : Finite ι\ninst✝¹ : DecidableEq ι\ninst✝ : (i : ι) → DecidableEq (α i)\nr : (i : ι) → α i → Finset (α i) → Prop\nH_ex : ∀ (i : ι) (s : Finset (α i)), s.Nonempty → ∃ x ∈ s, r i x (s.erase x)\np : ((i : ι) → Finset (α i)) → Prop\nh0 : p fun x ↦ ∅\... | [
"case intro.a.inr\nι : Type u_1\nα : ι → Type u_2\ninst✝² : Finite ι\ninst✝¹ : DecidableEq ι\ninst✝ : (i : ι) → DecidableEq (α i)\nr : (i : ι) → α i → Finset (α i) → Prop\nH_ex : ∀ (i : ι) (s : Finset (α i)), s.Nonempty → ∃ x ∈ s, r i x (s.erase x)\np : ((i : ι) → Finset (α i)) → Prop\nh0 : p fun x ↦ ∅\nstep : ∀ (g... | rw [ssubset_iff_of_subset (sigma_mono (Subset.refl _) _)] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Holor | {
"line": 198,
"column": 67
} | {
"line": 198,
"column": 73
} | {
"line": 198,
"column": 73
} | [
{
"pp": "α : Type\nd : ℕ\nds : List ℕ\nx y : Holor α (d :: ds)\nh : x.slice = y.slice\nt : HolorIndex (d :: ds)\ni : ℕ\nis : List ℕ\nhiis : ↑t = i :: is\n⊢ Forall₂ (fun x1 x2 ↦ x1 < x2) (i :: is) (d :: ds)",
"ppTerm": "?m.33",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
... | [
"α : Type\nd : ℕ\nds : List ℕ\nx y : Holor α (d :: ds)\nh : x.slice = y.slice\nt : HolorIndex (d :: ds)\ni : ℕ\nis : List ℕ\nhiis : ↑t = i :: is\n⊢ Forall₂ (fun x1 x2 ↦ x1 < x2) (↑t) (d :: ds)"
] | ← hiis | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Int.Bitwise | {
"line": 171,
"column": 4
} | {
"line": 171,
"column": 27
} | {
"line": 172,
"column": 2
} | [
{
"pp": "case false\nn : ℤ\n⊢ bit false n = 2 * n + bif false then 1 else 0",
"ppTerm": "?false",
"assigned": true,
"usedConstants": [
"AddMonoid.toAddZeroClass",
"AddZeroClass.toAddZero",
"Int",
"Int.instAddMonoid",
"AddZero.toZero",
"instHAdd",
"HAdd.hAdd"... | [] | apply (add_zero _).symm | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.