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.Multiset.DershowitzManna | {
"line": 60,
"column": 4
} | {
"line": 60,
"column": 38
} | [
{
"pp": "case refine_1\nα : Type u_1\ninst✝ : Preorder α\nX₁ Y₁ Z₁ : Multiset α\nhYZ₁ : ∀ (y : α), y ∈ Y₁ → ∃ z, z ∈ Z₁ ∧ y < z\nX₂ Y₂ Z₂ : Multiset α\nhZ₂ : Z₂ ≠ ∅\nhXZXY : Z₁ + X₁ = Y₂ + X₂\nhYZ₂ : ∀ (y : α), y ∈ Y₂ → ∃ z, z ∈ Z₂ ∧ y < z\n⊢ Z₂ + (Z₁ - Y₂) ≠ ∅",
"usedConstants": [
"Eq.mpr",
"co... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Multiset.DershowitzManna | {
"line": 93,
"column": 4
} | {
"line": 93,
"column": 56
} | [
{
"pp": "case inl\nα : Type u_1\ninst✝ : Preorder α\nM : Multiset α\na : α\nX Y : Multiset α\nh0 : a ::ₘ M = X + {a}\nh2 : ∀ (y : α), y ∈ Y → y < a\n⊢ X + Y = M + Y",
"usedConstants": [
"Eq.mpr",
"PartialOrder.toPreorder",
"instIsRightCancelAddOfAddRightReflectLE",
"Multiset.instAddC... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Multiset.DershowitzManna | {
"line": 99,
"column": 4
} | {
"line": 99,
"column": 21
} | [
{
"pp": "case inr.refine_1\nα : Type u_1\ninst✝ : Preorder α\nM : Multiset α\na : α\nX Y : Multiset α\nb : α\nh0 : M + {a} = X + {b}\nh2 : ∀ (y : α), y ∈ Y → y < b\nhab : a ≠ b\nthis : a ∈ X + {b}\n⊢ {a} ≤ X",
"usedConstants": [
"Eq.mpr",
"PartialOrder.toPreorder",
"Preorder.toLE",
"... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Multiset.DershowitzManna | {
"line": 102,
"column": 4
} | {
"line": 102,
"column": 26
} | [
{
"pp": "case inr.refine_2\nα : Type u_1\ninst✝ : Preorder α\nM : Multiset α\na : α\nX Y : Multiset α\nb : α\nh0 : a ::ₘ M = X + {b}\nh2 : ∀ (y : α), y ∈ Y → y < b\nhab : a ≠ b\nthis : b ∈ a ::ₘ M\n⊢ {b} ≤ M",
"usedConstants": [
"Eq.mpr",
"PartialOrder.toPreorder",
"Preorder.toLE",
"... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Multiset.DershowitzManna | {
"line": 115,
"column": 4
} | {
"line": 115,
"column": 15
} | [
{
"pp": "case intro.intro.inr.empty\nα : Type u_1\ninst✝ : Preorder α\na✝ a : α\nh✝ : ∀ (y : α), y < a → Acc LT.lt y\nha : ∀ (y : α), y < a → ∀ {M : Multiset α}, Acc OneStep M → Acc OneStep (y ::ₘ M)\nM✝ M : Multiset α\nhM : ∀ (y : Multiset α), y.OneStep M → Acc OneStep y\nihM : ∀ (y : Multiset α), y.OneStep M ... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Multiset.DershowitzManna | {
"line": 145,
"column": 39
} | {
"line": 145,
"column": 50
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\nz : α\nM N X Y : Multiset α\nhM : M = X + Y\nih :\n ∀ {M N : Multiset α} (X Y : Multiset α),\n 0 ≠ ∅ → M = X + Y → N = X + 0 → (∀ (y : α), y ∈ Y → ∃ z, z ∈ 0 ∧ y < z) → TransGen OneStep M N\nhZ : z ::ₘ 0 ≠ ∅\nhN : N = X + z ::ₘ 0\nhYZ : ∀ (y : α), y ∈ Y → ∃ z_1, z_... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Multiset.DershowitzManna | {
"line": 146,
"column": 2
} | {
"line": 146,
"column": 41
} | [
{
"pp": "case cons.inr\nα : Type u_1\ninst✝ : Preorder α\nz : α\nZ : Multiset α\nih :\n ∀ {M N : Multiset α} (X Y : Multiset α),\n Z ≠ ∅ → M = X + Y → N = X + Z → (∀ (y : α), y ∈ Y → ∃ z, z ∈ Z ∧ y < z) → TransGen OneStep M N\nM N X Y : Multiset α\nhZ✝ : z ::ₘ Z ≠ ∅\nhM : M = X + Y\nhN : N = X + z ::ₘ Z\nhY... | let Y' : Multiset α := Y.filter (· < z) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.Data.Multiset.DershowitzManna | {
"line": 151,
"column": 4
} | {
"line": 151,
"column": 22
} | [
{
"pp": "case cons.inr.refine_2\nα : Type u_1\ninst✝ : Preorder α\nz : α\nZ : Multiset α\nih :\n ∀ {M N : Multiset α} (X Y : Multiset α),\n Z ≠ ∅ → M = X + Y → N = X + Z → (∀ (y : α), y ∈ Y → ∃ z, z ∈ Z ∧ y < z) → TransGen OneStep M N\nM N X Y : Multiset α\nhZ✝ : z ::ₘ Z ≠ ∅\nhM : M = X + Y\nhN : N = X + z ... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 128,
"column": 16
} | {
"line": 128,
"column": 55
} | [
{
"pp": "ι : Type u_1\na s : ι → ℕ\nl l' : List ι\nhl : l.Perm l'\nhs : ∀ i ∈ l, s i ≠ 0\nco : List.Pairwise (Coprime on s) l\nz : { k // ∀ i ∈ l', k ≡ a i [MOD s i] } := chineseRemainderOfList a s l' ⋯\nhlp : (List.map s l).prod = (List.map s l').prod\n⊢ ∀ i ∈ l', s i ≠ 0",
"usedConstants": [
"Eq.mpr... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.NNRat.Floor | {
"line": 36,
"column": 23
} | {
"line": 36,
"column": 34
} | [
{
"pp": "a✝ : ℚ≥0\nh : a✝ < 0\n⊢ ⌊↑a✝⌋₊ = 0",
"usedConstants": [
"Rat.instOfNat",
"Eq.mpr",
"Nat.floor_eq_zero._simp_1",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Preorder.toLT",
"FloorRing.toFloorSemiring",
"NNRat.instSemifield",
"Rat",
"PartialOrder.... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 142,
"column": 39
} | {
"line": 142,
"column": 73
} | [
{
"pp": "ι : Type u_1\na s : ι → ℕ\nm : Multiset ι\nl l' : List ι\npp : l.Perm l'\nnod' : l'.Nodup\nnod : l.Nodup\nhs' : ∀ i ∈ l', s i ≠ 0\n⊢ ∀ i ∈ l, s i ≠ 0",
"usedConstants": [
"Eq.mpr",
"Membership.mem",
"id",
"Ne",
"instOfNatNat",
"List",
"List.instMembership",... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 144,
"column": 62
} | {
"line": 144,
"column": 96
} | [
{
"pp": "ι : Type u_1\na s : ι → ℕ\nm : Multiset ι\nl l' : List ι\npp : l.Perm l'\nnod' : l'.Nodup\nnod : l.Nodup\nhs' : ∀ i ∈ l', s i ≠ 0\nhs : ∀ i ∈ l, s i ≠ 0\nco' : {x | x ∈ l'}.Pairwise (Coprime on s)\n⊢ {x | x ∈ l}.Pairwise (Coprime on s)",
"usedConstants": [
"Eq.mpr",
"Nat.Coprime",
... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 151,
"column": 50
} | {
"line": 152,
"column": 33
} | [
{
"pp": "ι : Type u_1\na s : ι → ℕ\nm : Multiset ι\nl l' : List ι\npp : l.Perm l'\nnod' : l'.Nodup\nnod : l.Nodup\nhs' : ∀ i ∈ l', s i ≠ 0\nhs : ∀ i ∈ l, s i ≠ 0\nco' : {x | x ∈ l'}.Pairwise (Coprime on s)\nco : {x | x ∈ l}.Pairwise (Coprime on s)\nlco : List.Pairwise (Coprime on s) l\n⊢ ∀ {m' : Multiset ι} {e ... | by
rintro _ rfl _ _ _; rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 160,
"column": 2
} | {
"line": 160,
"column": 13
} | [
{
"pp": "case mk\nι : Type u_1\na s : ι → ℕ\nl : List ι\nnod : Multiset.Nodup (Quot.mk (⇑(List.isSetoid ι)) l)\nhs : ∀ i ∈ Quot.mk (⇑(List.isSetoid ι)) l, s i ≠ 0\npp : {x | x ∈ Quot.mk (⇑(List.isSetoid ι)) l}.Pairwise (Coprime on s)\n⊢ ↑(Quotient.recOn (motive := fun x ↦\n x.Nodup → (∀ i ∈ x, s i ≠ 0) →... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 161,
"column": 50
} | {
"line": 161,
"column": 61
} | [
{
"pp": "ι : Type u_1\na s : ι → ℕ\nl : List ι\nnod : Multiset.Nodup (Quot.mk (⇑(List.isSetoid ι)) l)\nhs : ∀ i ∈ Quot.mk (⇑(List.isSetoid ι)) l, s i ≠ 0\npp : {x | x ∈ Quot.mk (⇑(List.isSetoid ι)) l}.Pairwise (Coprime on s)\n⊢ ∀ i ∈ l, s i ≠ 0",
"usedConstants": [
"Membership.mem",
"id",
... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 168,
"column": 2
} | {
"line": 168,
"column": 13
} | [
{
"pp": "ι : Type u_1\na s : ι → ℕ\nt : Finset ι\nhs : ∀ i ∈ t, s i ≠ 0\npp : (↑t).Pairwise (Coprime on s)\n⊢ { k // ∀ i ∈ t, k ≡ a i [MOD s i] }",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 168,
"column": 57
} | {
"line": 168,
"column": 68
} | [
{
"pp": "ι : Type u_1\na s : ι → ℕ\nt : Finset ι\nhs : ∀ i ∈ t, s i ≠ 0\npp : (↑t).Pairwise (Coprime on s)\n⊢ ∀ i ∈ t.val, s i ≠ 0",
"usedConstants": [
"Membership.mem",
"Multiset",
"id",
"Ne",
"instOfNatNat",
"Finset.val",
"Multiset.instMembership",
"Nat",
... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 168,
"column": 77
} | {
"line": 168,
"column": 88
} | [
{
"pp": "ι : Type u_1\na s : ι → ℕ\nt : Finset ι\nhs : ∀ i ∈ t, s i ≠ 0\npp : (↑t).Pairwise (Coprime on s)\n⊢ {x | x ∈ t.val}.Pairwise (Coprime on s)",
"usedConstants": [
"Nat.Coprime",
"Function.onFun",
"setOf",
"Membership.mem",
"Multiset",
"id",
"Set.Pairwise",
... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 173,
"column": 2
} | {
"line": 173,
"column": 40
} | [
{
"pp": "ι : Type u_1\na s : ι → ℕ\nt : Finset ι\nhs : ∀ i ∈ t, s i ≠ 0\npp : (↑t).Pairwise (Coprime on s)\n⊢ ↑(chineseRemainderOfFinset a s t hs pp) < ∏ i ∈ t, s i",
"usedConstants": [
"Finset",
"Membership.mem",
"id",
"Finset.prod",
"Nat.ModEq",
"Finset.instSetLike",
... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 174,
"column": 55
} | {
"line": 174,
"column": 66
} | [
{
"pp": "ι : Type u_1\na s : ι → ℕ\nt : Finset ι\nhs : ∀ i ∈ t, s i ≠ 0\npp : (↑t).Pairwise (Coprime on s)\n⊢ ∀ i ∈ t.val, s i ≠ 0",
"usedConstants": [
"Membership.mem",
"Multiset",
"id",
"Ne",
"instOfNatNat",
"Finset.val",
"Multiset.instMembership",
"Nat",
... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 174,
"column": 75
} | {
"line": 174,
"column": 86
} | [
{
"pp": "ι : Type u_1\na s : ι → ℕ\nt : Finset ι\nhs : ∀ i ∈ t, s i ≠ 0\npp : (↑t).Pairwise (Coprime on s)\n⊢ {x | x ∈ t.val}.Pairwise (Coprime on s)",
"usedConstants": [
"Nat.Coprime",
"Function.onFun",
"setOf",
"Membership.mem",
"Multiset",
"id",
"Set.Pairwise",
... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Choose.Lucas | {
"line": 42,
"column": 4
} | {
"line": 42,
"column": 15
} | [
{
"pp": "n k p : ℕ\ninst✝ : Fact (Nat.Prime p)\n⊢ (X + 1) ^ n = (X + 1) ^ (n % p) * (X ^ p + 1) ^ (n / p)",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Factorial.NatCast | {
"line": 35,
"column": 12
} | {
"line": 35,
"column": 23
} | [
{
"pp": "case zero\nA : Type u_1\ninst✝ : Semiring A\nm : ℕ\nhn_fac : IsUnit ↑(m + 0)!\n⊢ IsUnit ↑m !",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Factorial.NatCast | {
"line": 50,
"column": 4
} | {
"line": 50,
"column": 15
} | [
{
"pp": "A : Type u_1\ninst✝³ : Semiring A\nK : Type u_2\ninst✝² : Semifield K\ninst✝¹ : CharZero K\ninst✝ : Algebra K A\nn : ℕ\nthis : IsUnit ↑n !\n⊢ IsUnit ↑n !",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Fib.Zeckendorf | {
"line": 69,
"column": 22
} | {
"line": 69,
"column": 70
} | [
{
"pp": "n a : ℕ\nl : List ℕ\nhn : ∀ a_1 ∈ (a :: l ++ [0]).head?, a_1 < n\nthis : ∀ b ∈ (l ++ [0]).head?, b < a - 1\nhl : ((∀ x ∈ l, x + 2 ≤ a) ∧ 2 ≤ a) ∧ IsChain (fun a b ↦ b + 2 ≤ a) (l ++ [0])\n⊢ fib (a - 1) + fib a ≤ fib n",
"usedConstants": [
"Eq.mpr",
"Nat.instIsOrderedAddMonoid",
"c... | ← fib_add_one (hl.1.2.trans_lt' zero_lt_two).ne' | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Fib.Zeckendorf | {
"line": 101,
"column": 14
} | {
"line": 101,
"column": 25
} | [
{
"pp": "n : ℕ\nh : n.greatestFib = 0\n⊢ n = 0",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Factorial.NatCast | {
"line": 83,
"column": 4
} | {
"line": 83,
"column": 20
} | [
{
"pp": "A : Type u_1\ninst✝ : CommRing A\nn p : ℕ\nh✝ : p.Coprime n\nm : ℕ\nhm : ↑p ^ m = 0\na b : A\nh : ↑p ^ m * a + ↑n * b = 1\n⊢ ↑n * b = 1",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Fib.Zeckendorf | {
"line": 113,
"column": 4
} | {
"line": 113,
"column": 52
} | [
{
"pp": "n : ℕ\nhn : n ≠ 0\n⊢ n.greatestFib - 1 ≠ 0",
"usedConstants": [
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"Nat.instOrderedSub",
"Preorder.toLT",
"congrArg",
"_private.Mathlib.Data.Nat.Fib.Zeckendorf.0.Nat.greatestFib_sub_fib_greatestFib_le_greatestFib._simp_1_2"... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Factorization.Root | {
"line": 69,
"column": 83
} | {
"line": 70,
"column": 69
} | [
{
"pp": "n : ℕ\nhn : n ≠ 0\na : ℕ\n⊢ n.floorRoot (a ^ n) = a",
"usedConstants": [
"Iff.mpr",
"instPowNat",
"Finsupp.instPosSMulReflectLE",
"Eq.mpr",
"Finsupp.smulZeroClass",
"Finsupp.instFloorDiv",
"False",
"Nat.instMulZeroClass",
"Finsupp.partialorder",... | by
simp [floorRoot_def, pos_iff_ne_zero.2, hn]; split_ifs <;> simp [*] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Factorization.Root | {
"line": 145,
"column": 40
} | {
"line": 145,
"column": 51
} | [
{
"pp": "n a : ℕ\nh : ¬(n = 0 ∨ a = 0)\np : ℕ\nhp : p ∈ (a.factorization ⌈/⌉ n).support\n⊢ Prime p ∧ p ∣ a ∧ ¬a = 0",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Nth | {
"line": 109,
"column": 2
} | {
"line": 110,
"column": 34
} | [
{
"pp": "p : ℕ → Prop\nhf : (setOf p).Finite\n⊢ Set.range (nth p) = insert 0 (setOf p)",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Nat.Nth | {
"line": 172,
"column": 2
} | {
"line": 172,
"column": 70
} | [
{
"pp": "p : ℕ → Prop\nx : ℕ\nh : p x\n⊢ ∃ n, (∀ (hf : (setOf p).Finite), n < #hf.toFinset) ∧ nth p n = x",
"usedConstants": [
"Set.finite_or_infinite",
"setOf",
"Set.Finite",
"Exists",
"And",
"Set.Finite.toFinset",
"Nat",
"LT.lt",
"Finset.card",
"... | refine (setOf p).finite_or_infinite.elim (fun hf => ?_) fun hf => ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Ordmap.Ordnode | {
"line": 194,
"column": 6
} | {
"line": 194,
"column": 15
} | [
{
"pp": "case nil.nil\nα : Type u_1\nl : Ordnode α\nx : α\nr : Ordnode α\n⊢ Ordnode α",
"usedConstants": [
"Ordnode.singleton"
]
}
] | exact ι x | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Ordmap.Ordnode | {
"line": 194,
"column": 6
} | {
"line": 194,
"column": 15
} | [
{
"pp": "case nil.nil\nα : Type u_1\nl : Ordnode α\nx : α\nr : Ordnode α\n⊢ Ordnode α",
"usedConstants": [
"Ordnode.singleton"
]
}
] | exact ι x | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Ordmap.Ordnode | {
"line": 194,
"column": 6
} | {
"line": 194,
"column": 15
} | [
{
"pp": "case nil.nil\nα : Type u_1\nl : Ordnode α\nx : α\nr : Ordnode α\n⊢ Ordnode α",
"usedConstants": [
"Ordnode.singleton"
]
}
] | exact ι x | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Ordmap.Ordnode | {
"line": 228,
"column": 6
} | {
"line": 228,
"column": 15
} | [
{
"pp": "case nil.nil\nα : Type u_1\nl : Ordnode α\nx : α\nr : Ordnode α\n⊢ Ordnode α",
"usedConstants": [
"Ordnode.singleton"
]
}
] | exact ι x | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Ordmap.Ordnode | {
"line": 228,
"column": 6
} | {
"line": 228,
"column": 15
} | [
{
"pp": "case nil.nil\nα : Type u_1\nl : Ordnode α\nx : α\nr : Ordnode α\n⊢ Ordnode α",
"usedConstants": [
"Ordnode.singleton"
]
}
] | exact ι x | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Ordmap.Ordnode | {
"line": 228,
"column": 6
} | {
"line": 228,
"column": 15
} | [
{
"pp": "case nil.nil\nα : Type u_1\nl : Ordnode α\nx : α\nr : Ordnode α\n⊢ Ordnode α",
"usedConstants": [
"Ordnode.singleton"
]
}
] | exact ι x | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Ordmap.Ordnode | {
"line": 262,
"column": 6
} | {
"line": 262,
"column": 15
} | [
{
"pp": "case nil.nil\nα : Type u_1\nl : Ordnode α\nx : α\nr : Ordnode α\n⊢ Ordnode α",
"usedConstants": [
"Ordnode.singleton"
]
}
] | exact ι x | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Ordmap.Ordnode | {
"line": 262,
"column": 6
} | {
"line": 262,
"column": 15
} | [
{
"pp": "case nil.nil\nα : Type u_1\nl : Ordnode α\nx : α\nr : Ordnode α\n⊢ Ordnode α",
"usedConstants": [
"Ordnode.singleton"
]
}
] | exact ι x | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Ordmap.Ordnode | {
"line": 262,
"column": 6
} | {
"line": 262,
"column": 15
} | [
{
"pp": "case nil.nil\nα : Type u_1\nl : Ordnode α\nx : α\nr : Ordnode α\n⊢ Ordnode α",
"usedConstants": [
"Ordnode.singleton"
]
}
] | exact ι x | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Nth | {
"line": 501,
"column": 18
} | {
"line": 501,
"column": 29
} | [
{
"pp": "p : ℕ → Prop\nn n' : ℕ\nhn' : n' ∈ setOf p\nhp : n' ∉ ↑(range n)\n⊢ n' ≥ n",
"usedConstants": [
"Eq.mpr",
"GE.ge",
"id",
"LE.le",
"instLENat",
"ge_iff_le._simp_1",
"Nat",
"Eq"
]
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Num.ZNum | {
"line": 125,
"column": 6
} | {
"line": 125,
"column": 17
} | [
{
"pp": "case pos\nα : Type u_1\ninst✝ : AddGroupWithOne α\na : PosNum\ne : a.succ.pred' = Num.pos a\nthis : ↑(-↑a) = -1 + ↑(-↑a + 1)\n⊢ -↑(Num.casesOn (Num.pos a) 1 bit1) = -↑a.succ + -↑a.succ + 1",
"usedConstants": [
"neg_add_rev",
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"NegZero... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Num.ZNum | {
"line": 134,
"column": 2
} | {
"line": 134,
"column": 30
} | [
{
"pp": "α : Type u_1\ninst✝ : AddGroupWithOne α\nn : ZNum\nthis : ↑(-1 + ↑n + ↑n) = ↑(↑n + ↑n + -1)\n⊢ -(↑(-n) + ↑(-n) + 1) = ↑n + ↑n - 1",
"usedConstants": [
"neg_add_rev",
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"castZNum",
"NegZeroClass.toNeg",
"SubtractionMonoid.to... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Ordmap.Invariants | {
"line": 64,
"column": 4
} | {
"line": 64,
"column": 27
} | [
{
"pp": "a b : ℕ\nh₁ : delta * a < b\nh₂ : delta * b < a\n⊢ a ≤ delta * (delta * a)",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Num.ZNum | {
"line": 171,
"column": 4
} | {
"line": 171,
"column": 32
} | [
{
"pp": "α : Type u_1\ninst✝ : AddGroupWithOne α\na b : PosNum\nthis : ↑(↑a + -↑b + (↑a + -↑b)) = ↑a + ↑a + (-↑b + -↑b)\n⊢ ↑a - ↑b + (↑a - ↑b) = ↑a.bit0 - ↑b.bit0",
"usedConstants": [
"neg_add_rev",
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"castPosNum",
"AddLeftCancelSemigroup... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Num.ZNum | {
"line": 176,
"column": 4
} | {
"line": 176,
"column": 32
} | [
{
"pp": "α : Type u_1\ninst✝ : AddGroupWithOne α\na b : PosNum\nthis : ↑(-↑b + (↑a + (-↑b + -1))) = ↑(↑a + -1 + (-↑b + -↑b))\n⊢ ↑a - ↑b + (↑a - ↑b) - 1 = ↑a.bit0 - ↑b.bit1",
"usedConstants": [
"neg_add_rev",
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"castPosNum",
"AddLeftCancel... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Num.ZNum | {
"line": 178,
"column": 4
} | {
"line": 178,
"column": 44
} | [
{
"pp": "α : Type u_1\ninst✝ : AddGroupWithOne α\na b : PosNum\n⊢ ↑(a.bit1.sub' b.bit0) = ↑a.bit1 - ↑b.bit0",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"castZNum",
"NegZeroClass.toNeg",
"castPosNum",
"ZNum.bit1",
"PosNum.sub'.eq_5",
"AddMono... | rw [sub', ZNum.cast_bit1, cast_sub' a b] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Num.ZNum | {
"line": 181,
"column": 4
} | {
"line": 181,
"column": 32
} | [
{
"pp": "α : Type u_1\ninst✝ : AddGroupWithOne α\na b : PosNum\nthis : ↑(-↑b + (↑a + (-↑b + 1))) = ↑(↑a + 1 + (-↑b + -↑b))\n⊢ ↑a - ↑b + (↑a - ↑b) + 1 = ↑a.bit1 - ↑b.bit0",
"usedConstants": [
"neg_add_rev",
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"castPosNum",
"AddLeftCancelSe... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Num.ZNum | {
"line": 185,
"column": 4
} | {
"line": 185,
"column": 32
} | [
{
"pp": "α : Type u_1\ninst✝ : AddGroupWithOne α\na b : PosNum\nthis : ↑(-↑b + (↑a + -↑b)) = ↑a + (-↑b + -↑b)\n⊢ ↑a - ↑b + (↑a - ↑b) = ↑a.bit1 - ↑b.bit1",
"usedConstants": [
"neg_add_rev",
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"castPosNum",
"add_neg_cancel_left",
"Add... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Num.ZNum | {
"line": 282,
"column": 23
} | {
"line": 282,
"column": 56
} | [
{
"pp": "α : Type u_1\ninst✝ : AddGroupWithOne α\na b : PosNum\n⊢ ↑(pos a + neg b) = ↑(pos a) + ↑(neg b)",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Num.ZNum | {
"line": 307,
"column": 60
} | {
"line": 307,
"column": 71
} | [
{
"pp": "α : Type u_1\ninst✝ : NonAssocRing α\nm n : ZNum\n⊢ ↑m * ↑↑n = ↑m * ↑n",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Int.cast",
"Eq.mpr",
"castZNum",
"NegZeroClass.toNeg",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"AddGroupWithOne.toAddGroup",
... | cast_to_int | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.ZNum | {
"line": 327,
"column": 23
} | {
"line": 327,
"column": 34
} | [
{
"pp": "a b : PosNum\n⊢ Ordering.casesOn ((pos a).cmp (pos b)) (↑(pos a) < ↑(pos b)) (pos a = pos b) (↑(pos b) < ↑(pos a))",
"usedConstants": [
"ZNum.pos.injEq",
"Eq.mpr",
"castZNum",
"Int.instIsStrictOrderedRing",
"congrArg",
"AddGroupWithOne.toAddMonoidWithOne",
... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Num.ZNum | {
"line": 356,
"column": 27
} | {
"line": 357,
"column": 40
} | [
{
"pp": "α : Type u_1\ninst✝² : Ring α\ninst✝¹ : LinearOrder α\ninst✝ : IsStrictOrderedRing α\nm n : ZNum\n⊢ ↑m ≤ ↑n ↔ m ≤ n",
"usedConstants": [
"Eq.mpr",
"castZNum",
"NegZeroClass.toNeg",
"Preorder.toLT",
"congrArg",
"PartialOrder.toPreorder",
"AddGroupWithOne.toA... | by
rw [← not_lt]; exact not_congr cast_lt | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Num.ZNum | {
"line": 559,
"column": 6
} | {
"line": 559,
"column": 17
} | [
{
"pp": "case bit0.h₂\nd n : PosNum\nq r : Num\nIH : ↑r + ↑d * ↑q = ↑n ∧ ↑r < ↑d\n⊢ ↑r.bit0 < 2 * ↑d",
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"castPosNum",
"Nat.instMulZeroClass",
"Preorder.toLT",
"HMul.hMul",
"Nat.instOne",
"M... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Num.ZNum | {
"line": 592,
"column": 6
} | {
"line": 592,
"column": 20
} | [
{
"pp": "case pos\na✝ : PosNum\n⊢ (pos a✝).mod 0 = pos a✝",
"usedConstants": [
"Num",
"eq_self",
"Num.pos",
"of_eq_true",
"Eq"
]
}
] | simp [Num.mod] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Num.ZNum | {
"line": 592,
"column": 6
} | {
"line": 592,
"column": 20
} | [
{
"pp": "case pos\na✝ : PosNum\n⊢ (pos a✝).mod 0 = pos a✝",
"usedConstants": [
"Num",
"eq_self",
"Num.pos",
"of_eq_true",
"Eq"
]
}
] | simp [Num.mod] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.ZNum | {
"line": 592,
"column": 6
} | {
"line": 592,
"column": 20
} | [
{
"pp": "case pos\na✝ : PosNum\n⊢ (pos a✝).mod 0 = pos a✝",
"usedConstants": [
"Num",
"eq_self",
"Num.pos",
"of_eq_true",
"Eq"
]
}
] | simp [Num.mod] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.ZNum | {
"line": 681,
"column": 10
} | {
"line": 681,
"column": 30
} | [
{
"pp": "n : PosNum\nd : ZNum\n⊢ ↑(Num.pos n % d.abs) = ↑(pos n) % ↑d",
"usedConstants": [
"Eq.mpr",
"castZNum",
"Nat.instMulZeroClass",
"Nat.instOne",
"congrArg",
"AddGroupWithOne.toAddMonoidWithOne",
"ZNum.abs",
"ZNum.pos",
"id",
"instHMod",
... | ← Num.to_nat_to_int, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.ZNum | {
"line": 685,
"column": 10
} | {
"line": 685,
"column": 30
} | [
{
"pp": "n : PosNum\nd : ZNum\n⊢ ↑d.abs - ↑(n.pred' % d.abs).succ = ↑(neg n) % ↑d",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"castZNum",
"Nat.instMulZeroClass",
"Nat.instOne",
"AddMonoid.toAddSemigroup",
"PosNum.pred'",
"AddGroupWithOne.toA... | ← Num.to_nat_to_int, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.ZNum | {
"line": 685,
"column": 41
} | {
"line": 685,
"column": 61
} | [
{
"pp": "n : PosNum\nd : ZNum\n⊢ ↑↑d.abs - ↑(n.pred' % d.abs).succ = -↑n % ↑d",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"castZNum",
"castPosNum",
"Nat.instMulZeroClass",
"Nat.instOne",
"AddMonoid.toAddSemigroup",
"PosNum.pred'",
"Add... | ← Num.to_nat_to_int, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Ordmap.Ordset | {
"line": 217,
"column": 6
} | {
"line": 217,
"column": 17
} | [
{
"pp": "case neg.inr.refine_1\nα : Type u_1\ninst✝ : Preorder α\nl : Ordnode α\nx y : α\nr : Ordnode α\no₁ : WithBot α\no₂ : WithTop α\nhl : Valid' o₁ l ↑x\nhr : Valid' (↑y) r o₂\ns : ℕ\nml : Ordnode α\nz : α\nmr : Ordnode α\nhm : Valid' (↑x) (Ordnode.node s ml z mr) ↑y\nHm : 0 < (Ordnode.node s ml z mr).size\... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.PFunctor.Multivariate.M | {
"line": 267,
"column": 4
} | {
"line": 267,
"column": 15
} | [
{
"pp": "n : ℕ\nP : MvPFunctor.{u} (n + 1)\nα : TypeVec.{u} n\nR : P.M α → P.M α → Prop\nh₀ : Equivalence R\nx y : P.M α\nax : P.A\nfx fy : P.B ax ⟹ α ::: P.M α\nh₁ : dropFun ((TypeVec.id ::: Quot.mk R) ⊚ fx) = dropFun ((TypeVec.id ::: Quot.mk R) ⊚ fy)\n⊢ dropFun fx = dropFun fy",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Ordmap.Invariants | {
"line": 548,
"column": 4
} | {
"line": 551,
"column": 69
} | [
{
"pp": "α : Type u_1\ninst✝² : LE α\ninst✝¹ : Std.Total fun x1 x2 ↦ x1 ≤ x2\ninst✝ : DecidableLE α\nx : α\nsize✝ : ℕ\nl : Ordnode α\ny : α\nr : Ordnode α\n⊢ (Ordnode.insert x (node size✝ l y r)).dual = Ordnode.insert x (node size✝ l y r).dual",
"usedConstants": [
"Ordnode.insert.eq_2",
"Orderin... | have : @cmpLE αᵒᵈ _ _ x y = cmpLE y x := rfl
rw [Ordnode.insert, dual, Ordnode.insert, this, ← cmpLE_swap x y]
cases cmpLE x y <;>
simp [Ordering.swap, dual_balanceL, dual_balanceR, dual_insert] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Ordmap.Invariants | {
"line": 548,
"column": 4
} | {
"line": 551,
"column": 69
} | [
{
"pp": "α : Type u_1\ninst✝² : LE α\ninst✝¹ : Std.Total fun x1 x2 ↦ x1 ≤ x2\ninst✝ : DecidableLE α\nx : α\nsize✝ : ℕ\nl : Ordnode α\ny : α\nr : Ordnode α\n⊢ (Ordnode.insert x (node size✝ l y r)).dual = Ordnode.insert x (node size✝ l y r).dual",
"usedConstants": [
"Ordnode.insert.eq_2",
"Orderin... | have : @cmpLE αᵒᵈ _ _ x y = cmpLE y x := rfl
rw [Ordnode.insert, dual, Ordnode.insert, this, ← cmpLE_swap x y]
cases cmpLE x y <;>
simp [Ordering.swap, dual_balanceL, dual_balanceR, dual_insert] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Ordmap.Invariants | {
"line": 565,
"column": 6
} | {
"line": 572,
"column": 43
} | [
{
"pp": "case nil.node.nil.node\nα : Type u_1\nx : α\nhl : nil.Balanced\nsl : nil.Sized\nrs : ℕ\nrx : α\nrrs : ℕ\nrrl : Ordnode α\nrrx : α\nrrr : Ordnode α\nhr : (nil.node' rx (node rrs rrl rrx rrr)).Balanced\nsr : (node rs nil rx (node rrs rrl rrx rrr)).Sized\n⊢ node 3 (Ordnode.singleton x) rx (node rrs rrl rr... | · have : size rrl = 0 ∧ size rrr = 0 := by
have := balancedSz_zero.1 hr.1.symm
rwa [size, sr.2.2.1, Nat.succ_le_succ_iff, Nat.le_zero, add_eq_zero] at this
cases sr.2.2.2.1.size_eq_zero.1 this.1
cases sr.2.2.2.2.size_eq_zero.1 this.2
obtain rfl : rrs = 1 := sr.2.2.1
r... | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.PNat.Factors | {
"line": 122,
"column": 2
} | {
"line": 122,
"column": 32
} | [
{
"pp": "v : PrimeMultiset\nh : ↑v.prod = (Multiset.map PNat.val (Multiset.map Nat.Primes.toPNat v)).prod\n⊢ ↑v.prod = v.toNatMultiset.prod",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.PNat.Find | {
"line": 40,
"column": 4
} | {
"line": 40,
"column": 38
} | [
{
"pp": "case refine_2\np q : ℕ+ → Prop\ninst✝¹ : DecidablePred p\ninst✝ : DecidablePred q\nh : ∃ n, p n\nthis : ∃ n' n x, p n\nn : { n // (∃ n_1 x, p n_1) ∧ ∀ (m : ℕ), m < n → ¬∃ n x, p n }\nn' : ℕ+\nhn' : ↑n = ↑n'\npn' : p n'\n⊢ p ⟨↑n, ⋯⟩",
"usedConstants": [
"PNat.val",
"Eq.mpr",
"Subty... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.PNat.Factors | {
"line": 312,
"column": 4
} | {
"line": 312,
"column": 46
} | [
{
"pp": "case mpr\nm n : ℕ+\nh : m ∣ n\n⊢ m.factorMultiset ≤ n.factorMultiset",
"usedConstants": [
"Eq.mpr",
"PNat.factorMultiset_mul",
"HMul.hMul",
"instDistribLatticePrimeMultiset",
"congrArg",
"instAddCommMonoidPrimeMultiset",
"PartialOrder.toPreorder",
"Pr... | rw [← mul_div_exact h, factorMultiset_mul] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Ordmap.Ordset | {
"line": 324,
"column": 4
} | {
"line": 325,
"column": 86
} | [
{
"pp": "case inr.inr\nα : Type u_2\nl r : Ordnode α\nr' : ℕ\nhr : r.size.dist r' ≤ 1\nleft✝ : l.size ≤ delta * r'\nh₂ : r' ≤ delta * l.size\n⊢ r.size ≤ 3 * (l.size + 1)",
"usedConstants": [
"Eq.mpr",
"Nat.mul_succ",
"Nat.instIsOrderedAddMonoid",
"HMul.hMul",
"of_decide_eq_true... | rw [Nat.mul_succ]
exact le_trans (Nat.dist_tri_right' _ _) (add_le_add h₂ (le_trans hr (by decide))) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Ordmap.Ordset | {
"line": 324,
"column": 4
} | {
"line": 325,
"column": 86
} | [
{
"pp": "case inr.inr\nα : Type u_2\nl r : Ordnode α\nr' : ℕ\nhr : r.size.dist r' ≤ 1\nleft✝ : l.size ≤ delta * r'\nh₂ : r' ≤ delta * l.size\n⊢ r.size ≤ 3 * (l.size + 1)",
"usedConstants": [
"Eq.mpr",
"Nat.mul_succ",
"Nat.instIsOrderedAddMonoid",
"HMul.hMul",
"of_decide_eq_true... | rw [Nat.mul_succ]
exact le_trans (Nat.dist_tri_right' _ _) (add_le_add h₂ (le_trans hr (by decide))) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Ordmap.Invariants | {
"line": 685,
"column": 24
} | {
"line": 685,
"column": 33
} | [
{
"pp": "α : Type u_1\nl : Ordnode α\nx₁ x₂ : α\nr₁ r₂ : Ordnode α\nH : Raised r₁.size r₂.size\n⊢ Raised (l.size + r₁.size + 1) (l.node' x₂ r₂).size",
"usedConstants": [
"Ordnode.node'",
"Eq.mpr",
"Ordnode.size_node",
"congrArg",
"id",
"instOfNatNat",
"Ordnode.size"... | size_node | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PNat.Xgcd | {
"line": 289,
"column": 4
} | {
"line": 289,
"column": 17
} | [
{
"pp": "case fst\nu : XgcdType\nhr✝ : u.r ≠ 0\nha : u.r + ↑u.b * u.q = ↑u.a := rq_eq u\nhr : u.r - 1 + 1 = u.r := Eq.trans (add_comm (u.r - 1) 1) (add_tsub_cancel_of_le (Nat.pos_of_ne_zero hr✝))\n⊢ (u.y * u.q + ↑u.z) * ↑u.b + u.y * (u.r - 1 + 1) = u.y * ↑u.a + ↑u.z * ↑u.b",
"usedConstants": [
"PNat.v... | rw [← ha, hr] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.PNat.Xgcd | {
"line": 292,
"column": 4
} | {
"line": 292,
"column": 17
} | [
{
"pp": "case snd\nu : XgcdType\nhr✝ : u.r ≠ 0\nha : u.r + ↑u.b * u.q = ↑u.a := rq_eq u\nhr : u.r - 1 + 1 = u.r := Eq.trans (add_comm (u.r - 1) 1) (add_tsub_cancel_of_le (Nat.pos_of_ne_zero hr✝))\n⊢ (↑u.w * u.q + u.x) * ↑u.b + ↑u.w * (u.r - 1 + 1) = ↑u.w * ↑u.a + u.x * ↑u.b",
"usedConstants": [
"PNat.... | rw [← ha, hr] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.PNat.Xgcd | {
"line": 291,
"column": 2
} | {
"line": 293,
"column": 8
} | [
{
"pp": "case snd\nu : XgcdType\nhr✝ : u.r ≠ 0\nha : u.r + ↑u.b * u.q = ↑u.a := ⋯\nhr : u.r - 1 + 1 = u.r := ⋯\n⊢ u.step.v.2 = u.v.swap.2",
"usedConstants": [
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"PNat.val",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Mathlib.Tac... | · change ((u.w * u.q + u.x) * u.b + u.w * (u.r - 1 + 1) : ℕ) = u.w * u.a + u.x * u.b
rw [← ha, hr]
ring | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.QPF.Multivariate.Constructions.Cofix | {
"line": 101,
"column": 6
} | {
"line": 101,
"column": 35
} | [
{
"pp": "n : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nα β : TypeVec.{u} n\ng : α ⟹ β\n⊢ ∀ (a b : (P F).M α), Mcongr a b → (fun x ↦ Quot.mk Mcongr (g <$$> x)) a = (fun x ↦ Quot.mk Mcongr (g <$$> x)) b",
"usedConstants": [
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
... | rintro aa₁ aa₂ ⟨r, pr, ra₁a₂⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.Data.QPF.Multivariate.Constructions.Cofix | {
"line": 115,
"column": 64
} | {
"line": 115,
"column": 78
} | [
{
"pp": "case h.left\nn : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nα β : TypeVec.{u} n\ng : α ⟹ β\naa₁ aa₂ : (P F).M α\nr : (P F).M α → (P F).M α → Prop\npr : IsPrecongr r\nra₁a₂✝ : r aa₁ aa₂\nr' : (P F).M β → (P F).M β → Prop := fun b₁ b₂ ↦ ∃ a₁ a₂, r a₁ a₂ ∧ b₁ = g <$$> a₁ ∧ b₂ = g <$$> a₂\nb₁ b₂ : (... | ← q.P.comp_map | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.QPF.Univariate.Basic | {
"line": 103,
"column": 4
} | {
"line": 103,
"column": 29
} | [
{
"pp": "case mp\nF : Type u → Type v\nq : QPF F\nα : Type u\np : α → Prop\nx : F α\ny : F (Subtype p)\nhy : Subtype.val <$> y = x\na : (P F).A\nf : (P F).B a → Subtype p\nh : repr y = ⟨a, f⟩\n⊢ ∃ a f, x = abs ⟨a, f⟩ ∧ ∀ (i : (P F).B a), p (f i)",
"usedConstants": [
"PFunctor.A",
"PFunctor.B",
... | use a, fun i => (f i).val | Mathlib.Tactic._aux_Mathlib_Tactic_Use___elabRules_Mathlib_Tactic_useSyntax_1 | Mathlib.Tactic.useSyntax |
Mathlib.Data.QPF.Univariate.Basic | {
"line": 197,
"column": 2
} | {
"line": 201,
"column": 67
} | [
{
"pp": "F : Type u → Type v\nq : QPF F\nx y : (P F).W\n⊢ Wequiv x y → Wequiv y x",
"usedConstants": [
"QPF.Wequiv.trans",
"PFunctor.A",
"QPF.Wequiv.rec",
"PFunctor.B",
"PFunctor.W",
"QPF.Wequiv",
"QPF.P",
"QPF.Wequiv.abs",
"QPF.Wequiv.ind",
"QPF.a... | intro h
induction h with
| ind a f f' _ ih => exact Wequiv.ind _ _ _ ih
| abs a f a' f' h => exact Wequiv.abs _ _ _ _ h.symm
| trans x y z _ _ ih₁ ih₂ => exact QPF.Wequiv.trans _ _ _ ih₂ ih₁ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.QPF.Univariate.Basic | {
"line": 197,
"column": 2
} | {
"line": 201,
"column": 67
} | [
{
"pp": "F : Type u → Type v\nq : QPF F\nx y : (P F).W\n⊢ Wequiv x y → Wequiv y x",
"usedConstants": [
"QPF.Wequiv.trans",
"PFunctor.A",
"QPF.Wequiv.rec",
"PFunctor.B",
"PFunctor.W",
"QPF.Wequiv",
"QPF.P",
"QPF.Wequiv.abs",
"QPF.Wequiv.ind",
"QPF.a... | intro h
induction h with
| ind a f f' _ ih => exact Wequiv.ind _ _ _ ih
| abs a f a' f' h => exact Wequiv.abs _ _ _ _ h.symm
| trans x y z _ _ ih₁ ih₂ => exact QPF.Wequiv.trans _ _ _ ih₂ ih₁ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.QPF.Univariate.Basic | {
"line": 252,
"column": 4
} | {
"line": 252,
"column": 21
} | [
{
"pp": "case h.mk.a\nF : Type u → Type u\nq : QPF F\nα : Type u\ng : F α → α\nx✝¹ : F (Fix F)\nx✝ : Fix F\nx : (P F).W\n⊢ Wequiv (Quotient.lift Wrepr ⋯ (Quot.mk (⇑Wsetoid) x)) x",
"usedConstants": [
"QPF.Wrepr_equiv"
]
}
] | apply Wrepr_equiv | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Data.QPF.Univariate.Basic | {
"line": 270,
"column": 2
} | {
"line": 270,
"column": 19
} | [
{
"pp": "case a\nF : Type u → Type u\nq : QPF F\na : (P F).A\nf : (P F).B a → (P F).W\nthis : mk (abs ⟨a, fun x ↦ ⟦f x⟧⟩) = ⟦Wrepr (WType.mk a f)⟧\n⊢ Wsetoid (Wrepr (WType.mk a f)) (WType.mk a f)",
"usedConstants": [
"PFunctor.A",
"PFunctor.B",
"QPF.Wrepr_equiv",
"QPF.P",
"WTyp... | apply Wrepr_equiv | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Data.Rat.NatSqrt.Real | {
"line": 25,
"column": 2
} | {
"line": 25,
"column": 36
} | [
{
"pp": "x prec : ℕ\nh : 0 < prec\nthis✝¹ : x.ratSqrt prec ^ 2 ≤ ↑x\nthis✝ : ↑(x.ratSqrt prec) ^ 2 ≤ ↑x\nthis : √(↑(x.ratSqrt prec) ^ 2) ≤ √↑x\n⊢ 0 ≤ ↑(x.ratSqrt prec)",
"usedConstants": [
"Rat.instOfNat",
"Eq.mpr",
"_private.Mathlib.Data.Rat.NatSqrt.Real.0.Nat.ratSqrt_le_realSqrt._simp_1_... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Rat.NatSqrt.Real | {
"line": 36,
"column": 25
} | {
"line": 36,
"column": 36
} | [
{
"pp": "x prec : ℕ\nh : 0 < prec\nthis✝¹ : ↑x < (x.ratSqrt prec + 1 / ↑prec) ^ 2\nthis✝ : ↑x < ↑((x.ratSqrt prec + 1 / ↑prec) ^ 2)\nthis : √↑x < √(↑(x.ratSqrt prec + 1 / ↑prec) ^ 2)\n⊢ 0 ≤ ↑(x.ratSqrt prec)",
"usedConstants": [
"Rat.instOfNat",
"Eq.mpr",
"Real",
"Rat.cast_nonneg._si... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Rat.Star | {
"line": 41,
"column": 2
} | {
"line": 41,
"column": 23
} | [
{
"pp": "⊢ closure (range fun x ↦ x * x) = ⊤",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Rat.Star | {
"line": 60,
"column": 2
} | {
"line": 60,
"column": 23
} | [
{
"pp": "⊢ closure (range fun x ↦ x * x) = nonneg ℚ",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Rat.Star | {
"line": 59,
"column": 92
} | {
"line": 60,
"column": 75
} | [
{
"pp": "⊢ closure (range fun x ↦ x * x) = nonneg ℚ",
"usedConstants": [
"Nat.instMulZeroClass",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"even_two",
"AddMonoid.toAddZeroClass",
"Rat",
"Rat.instAddLeftMono",
"Rat.addMonoid",
"Rat.instPowNat... | by
simpa only [sq] using addSubmonoid_closure_range_pow two_ne_zero even_two | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.QPF.Univariate.Basic | {
"line": 609,
"column": 2
} | {
"line": 613,
"column": 12
} | [
{
"pp": "case mp\nF : Type u → Type u\nq : QPF F\nh : IsUniform\nα : Type u\nx : F α\np : α → Prop\na : (P F).A\nf : (P F).B a → α\n⊢ (∃ a_1 f_1, abs ⟨a, f⟩ = abs ⟨a_1, f_1⟩ ∧ ∀ (i : (P F).B a_1), p (f_1 i)) → ∀ u ∈ supp (abs ⟨a, f⟩), p u",
"usedConstants": [
"Eq.mpr",
"PFunctor.A",
"congr... | · rintro ⟨a', f', abseq, hf⟩ u
rw [supp_eq_of_isUniform h, h _ _ _ _ abseq]
rintro ⟨i, _, hi⟩
rw [← hi]
apply hf | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Set.Enumerate | {
"line": 67,
"column": 6
} | {
"line": 69,
"column": 17
} | [
{
"pp": "case some\nα : Type u_1\nsel : Set α → Option α\nh_sel : ∀ (s : Set α) (a : α), sel s = some a → a ∈ s\ns : Set α\nn : ℕ\na a' : α\nh : sel s = some a'\n⊢ (do\n let a ← some a'\n enumerate sel (s \\ {a}) n) =\n some a →\n a ∈ s",
"usedConstants": [
"Option.some",
"... | exact fun h' : enumerate sel (s \ {a'}) n = some a ↦
have : a ∈ s \ {a'} := enumerate_mem h_sel h'
this.left | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Set.Finite.List | {
"line": 35,
"column": 2
} | {
"line": 35,
"column": 31
} | [
{
"pp": "α : Type u_1\ninst✝ : Finite α\nn : ℕ\n⊢ {l | l.length ≤ n}.Finite",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.WSeq.Basic | {
"line": 246,
"column": 20
} | {
"line": 246,
"column": 31
} | [
{
"pp": "case think\nα : Type u\nc : Computation (WSeq α)\nc1 c2 : Computation (Option (α × WSeq α))\nh : c1 = c2 ∨ ∃ c, c1 = (flatten c).destruct ∧ c2 = c.bind destruct\nc' : Computation (WSeq α)\n⊢ BisimO (fun c1 c2 ↦ c1 = c2 ∨ ∃ c, c1 = (flatten c).destruct ∧ c2 = c.bind destruct)\n (flatten c'.think).des... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.WSeq.Relation | {
"line": 204,
"column": 48
} | {
"line": 204,
"column": 70
} | [
{
"pp": "α : Type u\nβ : Type v\nR : α → β → Prop\ns✝ : WSeq α\nt✝ : WSeq β\nH : LiftRel R s✝ t✝\nn : ℕ\na✝ : Option (α × WSeq α)\nb✝ : Option (β × WSeq β)\no : LiftRelO R (LiftRel R) a✝ b✝\na : α\ns : WSeq α\nb : β\nt : WSeq β\nleft✝ : R a b\nh2 : LiftRel R s t\n⊢ Computation.LiftRel (LiftRelO R (LiftRel R)) (... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.WSeq.Relation | {
"line": 234,
"column": 16
} | {
"line": 234,
"column": 27
} | [
{
"pp": "α : Type u\ns t : WSeq α\na : α\nh : s ~ʷ t\n⊢ LiftRel (fun x1 x2 ↦ x1 = x2) (cons a s) (cons a t)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Stream'.WSeq.cons",
"Stream'.WSeq.liftRel_cons._simp_1",
"id",
"Stream'.WSeq.LiftRel",
"And",
"True",
... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.WSeq.Relation | {
"line": 236,
"column": 68
} | {
"line": 236,
"column": 79
} | [
{
"pp": "α : Type u\ns : WSeq α\n⊢ LiftRel (fun x1 x2 ↦ x1 = x2) s.think s",
"usedConstants": [
"Eq.mpr",
"id",
"Stream'.WSeq.LiftRel",
"Stream'.WSeq.think",
"Eq",
"Stream'.WSeq.liftRel_think_left._simp_1"
]
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.WSeq.Relation | {
"line": 239,
"column": 16
} | {
"line": 239,
"column": 27
} | [
{
"pp": "α : Type u\ns t : WSeq α\nh : s ~ʷ t\n⊢ LiftRel (fun x1 x2 ↦ x1 = x2) s.think t.think",
"usedConstants": [
"Eq.mpr",
"id",
"Stream'.WSeq.LiftRel",
"Stream'.WSeq.think",
"Stream'.WSeq.liftRel_think_right._simp_1",
"Eq",
"Stream'.WSeq.liftRel_think_left._simp... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Setoid.Partition.Card | {
"line": 65,
"column": 2
} | {
"line": 65,
"column": 14
} | [
{
"pp": "α : Type u_1\nP : Set (Set α)\nhP : IsPartition P\ns : Set α\nhs : s.Finite\nhst : ∀ (t : Set α), (s ∩ t).Finite\nhst' : ∀ (t : Set α), Nat.card ↑(s ∩ t) = ⋯.toFinset.card\nf : ↑(Function.support fun t ↦ (s ∩ ↑t).ncard) → ↑s := ⋯\nhf : ∀ (t : ↑(Function.support fun t ↦ (s ∩ ↑t).ncard)), ↑↑t ∈ P ∧ ↑(f t... | intro t t' h | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.Data.WSeq.Basic | {
"line": 624,
"column": 19
} | {
"line": 624,
"column": 40
} | [
{
"pp": "case cons\nα : Type u\na : α\nl : List α\nIH : l ∈ (↑l).toList\n⊢ a :: l ∈ (↑(a :: l)).toList",
"usedConstants": [
"Eq.mpr",
"Computation.think",
"congrArg",
"Stream'.WSeq.ofList",
"Stream'.WSeq.cons",
"Stream'.WSeq.toList",
"Membership.mem",
"Stream'... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.WSeq.Relation | {
"line": 376,
"column": 8
} | {
"line": 376,
"column": 19
} | [
{
"pp": "case some.some\nα : Type u\nβ : Type v\nR : α → β → Prop\ns1✝ s2 : WSeq α\nt1✝ t2 : WSeq β\nh1 : LiftRel R s1✝ t1✝\nh2 : LiftRel R s2 t2\ns✝ : WSeq α\nt✝ : WSeq β\nh✝¹ : (fun s t ↦ LiftRel R s t ∨ ∃ s1 t1, s = s1.append s2 ∧ t = t1.append t2 ∧ LiftRel R s1 t1) s✝ t✝\ns1 : WSeq α\nt1 : WSeq β\nh✝ : Lift... | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Mathlib.Data.Sigma.Interval | {
"line": 132,
"column": 4
} | {
"line": 132,
"column": 24
} | [
{
"pp": "case inr\nι : Type u_1\nα : ι → Type u_2\ninst✝¹ : (i : ι) → Preorder (α i)\ninst✝ : (i : ι) → LocallyFiniteOrderTop (α i)\nx✝¹ x✝ : (i : ι) × α i\ni : ι\na : α i\nj : ι\nb : α j\nhij : i ≠ j\n⊢ (⟨j, b⟩ ∈\n match ⟨i, a⟩ with\n | ⟨i, a⟩ => Finset.map (Embedding.sigmaMk i) (Ioi a)) ↔\n ⟨i, a... | · simp [hij, lt_def] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.WSeq.Basic | {
"line": 721,
"column": 35
} | {
"line": 721,
"column": 46
} | [
{
"pp": "α : Type u\na : α\nss : WSeq α\nh : a ∈ ss\nS : WSeq (WSeq α)\nm : a ∈ nil.append S.think.join\nIH : ∀ (s : WSeq α) (S_1 : WSeq (WSeq α)), s.append S_1.join = S.join → a ∈ s.append S_1.join → a ∈ s ∨ ∃ s ∈ S_1, a ∈ s\nej : S.join.think = S.join.think\n⊢ a ∈ S.join",
"usedConstants": []
}
] | simpa using | Lean.Elab.Tactic.Simpa.evalSimpa | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.