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.Finsupp.Sigma | {
"line": 57,
"column": 4
} | {
"line": 57,
"column": 12
} | [
{
"pp": "case neg.h\nκ : Type u_1\nι : κ → Type u_2\nM : Type u_3\ninst✝¹ : Zero M\ninst✝ : DecidableEq κ\nk✝ : κ\nf : ι k✝ →₀ M\nk : κ\ni : ι k\nh : ¬⟨k, i⟩.fst = k✝\n⊢ ⟨k, i⟩ ∉ Set.range ⇑{ toFun := Sigma.mk k✝, inj' := ⋯ }",
"usedConstants": [
"False",
"eq_false",
"congrArg",
"Mem... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Int.Lemmas | {
"line": 39,
"column": 79
} | {
"line": 41,
"column": 33
} | [
{
"pp": "a b : ℤ\n⊢ a.natAbs = b.natAbs ↔ a ^ 2 = b ^ 2",
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"id",
"MulOne.toMul",
"instOfNatNat",
"Int",
"sq",
"Int.instMonoid",
"Monoid.toPow",
"MulOneClass.to... | by
rw [sq, sq]
exact natAbs_eq_iff_mul_self_eq | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Int.Lemmas | {
"line": 72,
"column": 2
} | {
"line": 73,
"column": 44
} | [
{
"pp": "a b n : ℕ\na_le_n : a ≤ n\nb_le_n : b ≤ n\n⊢ |↑a - ↑b| ≤ ↑n",
"usedConstants": [
"Int.instAddCommGroup",
"Iff.mpr",
"Int.instLinearOrder",
"AddGroupWithOne.toAddMonoidWithOne",
"AddMonoidWithOne.toNatCast",
"Int",
"LE.le",
"instLENat",
"Nat.cast... | exact abs_sub_le_of_nonneg_of_le (natCast_nonneg a) (ofNat_le.mpr a_le_n)
(natCast_nonneg b) (ofNat_le.mpr b_le_n) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Int.Bitwise | {
"line": 159,
"column": 18
} | {
"line": 159,
"column": 34
} | [
{
"pp": "n : ℕ\n⊢ (bif !n.bodd then 1 else 0) + 2 * -[n+1].div2 = -[n.bodd.toNat + 2 * n.div2+1]",
"usedConstants": [
"Nat.bodd"
]
}
] | cases Nat.bodd n | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Data.Int.Bitwise | {
"line": 210,
"column": 36
} | {
"line": 210,
"column": 62
} | [
{
"pp": "m : ℕ\nb : Bool\nn : ℕ\n⊢ (↑(Nat.bit b n)).testBit m.succ = (↑n).testBit m",
"usedConstants": [
"Nat.testBit_bit_succ"
]
}
] | apply Nat.testBit_bit_succ | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Data.Int.CardIntervalMod | {
"line": 133,
"column": 8
} | {
"line": 133,
"column": 26
} | [
{
"pp": "b r : ℕ\nhr : 0 < r\nv : ℕ\nhr' : 0 < ↑r\n| ⌈(↑b - ↑v) / ↑r⌉ - ⌈(↑0 - ↑v) / ↑r⌉",
"usedConstants": [
"Rat.instSub",
"instHDiv",
"HMul.hMul",
"congrArg",
"Nat.div_add_mod",
"Rat",
"Rat.instFloorRing",
"HSub.hSub",
"Rat.linearOrder",
"HDiv.h... | ← div_add_mod v r, | Lean.Elab.Tactic.Conv.evalRewrite | null |
Mathlib.Data.List.TakeWhile | {
"line": 103,
"column": 2
} | {
"line": 103,
"column": 18
} | [
{
"pp": "case nil\nα : Type u_1\np : α → Bool\nl : List α\n⊢ find? p [] = (dropWhile (fun x ↦ !p x) []).head?",
"usedConstants": [
"Option.none",
"eq_self",
"of_eq_true",
"Eq",
"Option"
]
},
{
"pp": "case cons\nα : Type u_1\np : α → Bool\nl : List α\nhead✝ : α\ntail... | case nil => simp | Lean.Elab.Tactic.evalCase | Lean.Parser.Tactic.case |
Mathlib.Data.List.DropRight | {
"line": 210,
"column": 2
} | {
"line": 210,
"column": 29
} | [
{
"pp": "α : Type u_1\nl₁ l₂ : List α\nk : ℕ\nhk : k ≤ l₂.length\n⊢ (l₁ ++ l₂).rdrop k = l₁ ++ l₂.rdrop k",
"usedConstants": [
"congrArg",
"List.length_reverse",
"Eq.mp",
"LE.le",
"instLENat",
"Nat",
"List.reverse",
"Eq.symm",
"List.length"
]
}
] | rw [← length_reverse] at hk | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.List.Map2 | {
"line": 62,
"column": 79
} | {
"line": 62,
"column": 95
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\nf : Option α → β → γ\nbs : List β\n⊢ map₂Right' f [] bs = (map (f none) bs, [])",
"usedConstants": [
"List.map",
"Prod.mk",
"List.cons",
"Option.none",
"List",
"List.casesOn",
"List.map₂Right'",
"Eq.ndrec",
"E... | cases bs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.List.Map2 | {
"line": 62,
"column": 79
} | {
"line": 62,
"column": 95
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\nf : Option α → β → γ\nbs : List β\n⊢ map₂Right' f [] bs = (map (f none) bs, [])",
"usedConstants": [
"List.map",
"Prod.mk",
"List.cons",
"Option.none",
"List",
"List.casesOn",
"List.map₂Right'",
"Eq.ndrec",
"E... | cases bs <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Map2 | {
"line": 62,
"column": 79
} | {
"line": 62,
"column": 95
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\nf : Option α → β → γ\nbs : List β\n⊢ map₂Right' f [] bs = (map (f none) bs, [])",
"usedConstants": [
"List.map",
"Prod.mk",
"List.cons",
"Option.none",
"List",
"List.casesOn",
"List.map₂Right'",
"Eq.ndrec",
"E... | cases bs <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Map2 | {
"line": 133,
"column": 2
} | {
"line": 133,
"column": 18
} | [
{
"pp": "α : Type u\nβ : Type v\nbs : List β\n⊢ [].zipRight' bs = (map (fun b ↦ (none, b)) bs, [])",
"usedConstants": [
"List.map",
"Prod.mk",
"List.cons",
"Option.none",
"List",
"List.zipRight'",
"List.casesOn",
"Eq.ndrec",
"Eq.refl",
"Prod",
... | cases bs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.List.Map2 | {
"line": 133,
"column": 2
} | {
"line": 133,
"column": 18
} | [
{
"pp": "α : Type u\nβ : Type v\nbs : List β\n⊢ [].zipRight' bs = (map (fun b ↦ (none, b)) bs, [])",
"usedConstants": [
"List.map",
"Prod.mk",
"List.cons",
"Option.none",
"List",
"List.zipRight'",
"List.casesOn",
"Eq.ndrec",
"Eq.refl",
"Prod",
... | cases bs <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Map2 | {
"line": 133,
"column": 2
} | {
"line": 133,
"column": 18
} | [
{
"pp": "α : Type u\nβ : Type v\nbs : List β\n⊢ [].zipRight' bs = (map (fun b ↦ (none, b)) bs, [])",
"usedConstants": [
"List.map",
"Prod.mk",
"List.cons",
"Option.none",
"List",
"List.zipRight'",
"List.casesOn",
"Eq.ndrec",
"Eq.refl",
"Prod",
... | cases bs <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Map2 | {
"line": 188,
"column": 71
} | {
"line": 188,
"column": 87
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\nf : Option α → β → γ\nbs : List β\n⊢ map₂Right f [] bs = map (f none) bs",
"usedConstants": [
"List.map",
"List.cons",
"Option.none",
"List",
"List.casesOn",
"List.map₂Right",
"Eq.ndrec",
"Eq.refl",
"Eq.symm",... | cases bs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.List.Map2 | {
"line": 188,
"column": 71
} | {
"line": 188,
"column": 87
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\nf : Option α → β → γ\nbs : List β\n⊢ map₂Right f [] bs = map (f none) bs",
"usedConstants": [
"List.map",
"List.cons",
"Option.none",
"List",
"List.casesOn",
"List.map₂Right",
"Eq.ndrec",
"Eq.refl",
"Eq.symm",... | cases bs <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Map2 | {
"line": 188,
"column": 71
} | {
"line": 188,
"column": 87
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\nf : Option α → β → γ\nbs : List β\n⊢ map₂Right f [] bs = map (f none) bs",
"usedConstants": [
"List.map",
"List.cons",
"Option.none",
"List",
"List.casesOn",
"List.map₂Right",
"Eq.ndrec",
"Eq.refl",
"Eq.symm",... | cases bs <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Map2 | {
"line": 257,
"column": 2
} | {
"line": 257,
"column": 18
} | [
{
"pp": "α : Type u\nβ : Type v\nbs : List β\n⊢ [].zipRight bs = map (fun b ↦ (none, b)) bs",
"usedConstants": [
"List.map",
"Prod.mk",
"List.zipRight",
"List.cons",
"Option.none",
"List",
"List.casesOn",
"Eq.ndrec",
"Eq.refl",
"Prod",
"Eq.sy... | cases bs <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.List.Map2 | {
"line": 257,
"column": 2
} | {
"line": 257,
"column": 18
} | [
{
"pp": "α : Type u\nβ : Type v\nbs : List β\n⊢ [].zipRight bs = map (fun b ↦ (none, b)) bs",
"usedConstants": [
"List.map",
"Prod.mk",
"List.zipRight",
"List.cons",
"Option.none",
"List",
"List.casesOn",
"Eq.ndrec",
"Eq.refl",
"Prod",
"Eq.sy... | cases bs <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Map2 | {
"line": 257,
"column": 2
} | {
"line": 257,
"column": 18
} | [
{
"pp": "α : Type u\nβ : Type v\nbs : List β\n⊢ [].zipRight bs = map (fun b ↦ (none, b)) bs",
"usedConstants": [
"List.map",
"Prod.mk",
"List.zipRight",
"List.cons",
"Option.none",
"List",
"List.casesOn",
"Eq.ndrec",
"Eq.refl",
"Prod",
"Eq.sy... | cases bs <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.SplitLengths | {
"line": 64,
"column": 4
} | {
"line": 64,
"column": 12
} | [
{
"pp": "case nil\nα : Type u_1\nl : List α\nh : l.length ≤ [].sum\n⊢ ([].splitLengths l).flatten = l",
"usedConstants": [
"congrArg",
"AddMonoid.toAddZeroClass",
"List.sum",
"Nat.instAddMonoid",
"AddZeroClass.toAddZero",
"List.length_eq_zero_iff._simp_1",
"Eq.mp",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.SplitLengths | {
"line": 64,
"column": 4
} | {
"line": 64,
"column": 12
} | [
{
"pp": "case nil\nα : Type u_1\nl : List α\nh : l.length ≤ [].sum\n⊢ ([].splitLengths l).flatten = l",
"usedConstants": [
"congrArg",
"AddMonoid.toAddZeroClass",
"List.sum",
"Nat.instAddMonoid",
"AddZeroClass.toAddZero",
"List.length_eq_zero_iff._simp_1",
"Eq.mp",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.SplitLengths | {
"line": 64,
"column": 4
} | {
"line": 64,
"column": 12
} | [
{
"pp": "case nil\nα : Type u_1\nl : List α\nh : l.length ≤ [].sum\n⊢ ([].splitLengths l).flatten = l",
"usedConstants": [
"congrArg",
"AddMonoid.toAddZeroClass",
"List.sum",
"Nat.instAddMonoid",
"AddZeroClass.toAddZero",
"List.length_eq_zero_iff._simp_1",
"Eq.mp",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Shortlex | {
"line": 105,
"column": 4
} | {
"line": 107,
"column": 7
} | [
{
"pp": "case inr.cons\nα : Type u_1\nr : α → α → Prop\ns₁ s₂ : List α\nh : Shortlex r s₁ s₂\nh2 : s₁.length = s₂.length ∧ Lex r s₁ s₂\nhead : α\ntail : List α\n⊢ Shortlex r s₁ (s₂ ++ head :: tail)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.length_cons",
"List.length_append",
... | apply of_length_lt
rw [List.length_append, List.length_cons]
lia | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Shortlex | {
"line": 105,
"column": 4
} | {
"line": 107,
"column": 7
} | [
{
"pp": "case inr.cons\nα : Type u_1\nr : α → α → Prop\ns₁ s₂ : List α\nh : Shortlex r s₁ s₂\nh2 : s₁.length = s₂.length ∧ Lex r s₁ s₂\nhead : α\ntail : List α\n⊢ Shortlex r s₁ (s₂ ++ head :: tail)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.length_cons",
"List.length_append",
... | apply of_length_lt
rw [List.length_append, List.length_cons]
lia | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.PeriodicityLemma | {
"line": 64,
"column": 4
} | {
"line": 64,
"column": 12
} | [
{
"pp": "case mpr\nα : Type u_1\np : ℕ\nw : List α\nlhs : ∀ i < w.length - p, w[i]? = w[i + p]?\ndrop : take p w ++ List.drop p w <+: take p w ++ w\n⊢ w <+: take p w ++ w",
"usedConstants": [
"congrArg",
"List.take_append_drop",
"Eq.mp",
"id",
"instHAppendOfAppend",
"List... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.SplitBy | {
"line": 62,
"column": 30
} | {
"line": 62,
"column": 38
} | [
{
"pp": "case refine_1\nα : Type u_1\nr : α → α → Bool\nl : List α\nthis : (splitBy r l).flatten = l\nx✝ : splitBy r l = []\n⊢ l = []",
"usedConstants": [
"congrArg",
"Eq.mp",
"id",
"List.nil_eq._simp_1",
"List.splitBy",
"List",
"True",
"eq_self",
"of_eq... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.SplitBy | {
"line": 62,
"column": 30
} | {
"line": 62,
"column": 38
} | [
{
"pp": "case refine_2\nα : Type u_1\nr : α → α → Bool\nl : List α\nthis : (splitBy r l).flatten = l\n⊢ l = [] → splitBy r l = []",
"usedConstants": [
"congrArg",
"List.splitBy",
"List",
"True",
"eq_self",
"of_eq_true",
"Eq.refl",
"congrFun'",
"implies_t... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.SplitBy | {
"line": 68,
"column": 36
} | {
"line": 76,
"column": 20
} | [
{
"pp": "α : Type u_1\nr : α → α → Bool\nl : List α\na : α\ng : List α\n⊢ ¬[] ∈ splitBy.loop r l a g []",
"usedConstants": [
"Eq.mpr",
"_private.Mathlib.Data.List.SplitBy.0.List.filter.match_1.splitter",
"False",
"_private.Mathlib.Data.List.SplitBy.0.List.splitByLoop_eq_append",
... | by
induction l generalizing a g with
| nil => simp [splitBy.loop]
| cons b l IH =>
rw [splitBy.loop]
split
· exact IH
· rw [splitByLoop_eq_append, mem_append]
simpa using IH | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.SplitBy | {
"line": 85,
"column": 13
} | {
"line": 85,
"column": 21
} | [
{
"pp": "α : Type u_1\nm : List α\nr : α → α → Bool\nl : List α\nh : m ∈ splitBy r l\nx✝ : m = []\n⊢ False",
"usedConstants": [
"False",
"congrArg",
"False.elim",
"List.nil_notMem_splitBy._simp_1",
"Membership.mem",
"Eq.mp",
"List.splitBy",
"List",
"List... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.SplitBy | {
"line": 85,
"column": 13
} | {
"line": 85,
"column": 21
} | [
{
"pp": "α : Type u_1\nm : List α\nr : α → α → Bool\nl : List α\nh : m ∈ splitBy r l\nx✝ : m = []\n⊢ False",
"usedConstants": [
"False",
"congrArg",
"False.elim",
"List.nil_notMem_splitBy._simp_1",
"Membership.mem",
"Eq.mp",
"List.splitBy",
"List",
"List... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.SplitBy | {
"line": 85,
"column": 13
} | {
"line": 85,
"column": 21
} | [
{
"pp": "α : Type u_1\nm : List α\nr : α → α → Bool\nl : List α\nh : m ∈ splitBy r l\nx✝ : m = []\n⊢ False",
"usedConstants": [
"False",
"congrArg",
"False.elim",
"List.nil_notMem_splitBy._simp_1",
"Membership.mem",
"Eq.mp",
"List.splitBy",
"List",
"List... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.PeriodicityLemma | {
"line": 144,
"column": 4
} | {
"line": 144,
"column": 12
} | [
{
"pp": "case inr.inl\nα : Type u_1\np : ℕ\nw : List α\nper : w.HasPeriod p\np_pos : p > 0\ndvd : p ∣ 0\nlen : 0 ≤ w.length\n⊢ (take 0 w ++ w).HasPeriod p",
"usedConstants": []
}
] | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.PeriodicityLemma | {
"line": 144,
"column": 4
} | {
"line": 144,
"column": 12
} | [
{
"pp": "case inr.inl\nα : Type u_1\np : ℕ\nw : List α\nper : w.HasPeriod p\np_pos : p > 0\ndvd : p ∣ 0\nlen : 0 ≤ w.length\n⊢ (take 0 w ++ w).HasPeriod p",
"usedConstants": []
}
] | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.PeriodicityLemma | {
"line": 144,
"column": 4
} | {
"line": 144,
"column": 12
} | [
{
"pp": "case inr.inl\nα : Type u_1\np : ℕ\nw : List α\nper : w.HasPeriod p\np_pos : p > 0\ndvd : p ∣ 0\nlen : 0 ≤ w.length\n⊢ (take 0 w ++ w).HasPeriod p",
"usedConstants": []
}
] | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.PeriodicityLemma | {
"line": 147,
"column": 80
} | {
"line": 147,
"column": 88
} | [
{
"pp": "α : Type u_1\np n : ℕ\nw : List α\ndvd : p ∣ n\nlen : n ≤ w.length\nper : w.HasPeriod p\np_pos : p > 0\npos : n > 0\nmod_w : ∀ i < w.length, w[i % p]? = w[i]?\nthis : ∀ i < n + w.length, (take n w ++ w)[i]? = (take n w ++ w)[i % p]?\n⊢ ∀ i < (take n w ++ w).length, (take n w ++ w)[i]? = (take n w ++ w)... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.PeriodicityLemma | {
"line": 147,
"column": 80
} | {
"line": 147,
"column": 88
} | [
{
"pp": "α : Type u_1\np n : ℕ\nw : List α\ndvd : p ∣ n\nlen : n ≤ w.length\nper : w.HasPeriod p\np_pos : p > 0\npos : n > 0\nmod_w : ∀ i < w.length, w[i % p]? = w[i]?\nthis : ∀ i < n + w.length, (take n w ++ w)[i]? = (take n w ++ w)[i % p]?\n⊢ ∀ i < (take n w ++ w).length, (take n w ++ w)[i]? = (take n w ++ w)... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.PeriodicityLemma | {
"line": 147,
"column": 80
} | {
"line": 147,
"column": 88
} | [
{
"pp": "α : Type u_1\np n : ℕ\nw : List α\ndvd : p ∣ n\nlen : n ≤ w.length\nper : w.HasPeriod p\np_pos : p > 0\npos : n > 0\nmod_w : ∀ i < w.length, w[i % p]? = w[i]?\nthis : ∀ i < n + w.length, (take n w ++ w)[i]? = (take n w ++ w)[i % p]?\n⊢ ∀ i < (take n w ++ w).length, (take n w ++ w)[i]? = (take n w ++ w)... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.PeriodicityLemma | {
"line": 154,
"column": 73
} | {
"line": 154,
"column": 81
} | [
{
"pp": "α : Type u_1\np n : ℕ\nw : List α\ndvd : p ∣ n\nlen : n ≤ w.length\nper : w.HasPeriod p\np_pos : p > 0\npos : n > 0\nmod_w : ∀ i < w.length, w[i % p]? = w[i]?\ni : ℕ\nless_i : i < n + w.length\nj : ℕ\nless_j : j < n + w.length\nj_lt_n : j < n\n⊢ j < (take n w).length",
"usedConstants": [
"Nat... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.PeriodicityLemma | {
"line": 154,
"column": 73
} | {
"line": 154,
"column": 81
} | [
{
"pp": "α : Type u_1\np n : ℕ\nw : List α\ndvd : p ∣ n\nlen : n ≤ w.length\nper : w.HasPeriod p\np_pos : p > 0\npos : n > 0\nmod_w : ∀ i < w.length, w[i % p]? = w[i]?\ni : ℕ\nless_i : i < n + w.length\nj : ℕ\nless_j : j < n + w.length\nj_lt_n : j < n\n⊢ j < (take n w).length",
"usedConstants": [
"Nat... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.PeriodicityLemma | {
"line": 154,
"column": 73
} | {
"line": 154,
"column": 81
} | [
{
"pp": "α : Type u_1\np n : ℕ\nw : List α\ndvd : p ∣ n\nlen : n ≤ w.length\nper : w.HasPeriod p\np_pos : p > 0\npos : n > 0\nmod_w : ∀ i < w.length, w[i % p]? = w[i]?\ni : ℕ\nless_i : i < n + w.length\nj : ℕ\nless_j : j < n + w.length\nj_lt_n : j < n\n⊢ j < (take n w).length",
"usedConstants": [
"Nat... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.PeriodicityLemma | {
"line": 165,
"column": 85
} | {
"line": 165,
"column": 93
} | [
{
"pp": "α : Type u_1\np n : ℕ\nw : List α\ndvd : p ∣ n\nlen : n ≤ w.length\nper : w.HasPeriod p\np_pos : p > 0\npos : n > 0\nmod_w : ∀ i < w.length, w[i % p]? = w[i]?\ni : ℕ\nless_i : i < n + w.length\nj : ℕ\nless_j : j < n + w.length\nj_minus : j - n < w.length\nn_le_j : n ≤ j\nj_mod : (j - n) % p = j % p\n⊢ ... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.PeriodicityLemma | {
"line": 165,
"column": 85
} | {
"line": 165,
"column": 93
} | [
{
"pp": "α : Type u_1\np n : ℕ\nw : List α\ndvd : p ∣ n\nlen : n ≤ w.length\nper : w.HasPeriod p\np_pos : p > 0\npos : n > 0\nmod_w : ∀ i < w.length, w[i % p]? = w[i]?\ni : ℕ\nless_i : i < n + w.length\nj : ℕ\nless_j : j < n + w.length\nj_minus : j - n < w.length\nn_le_j : n ≤ j\nj_mod : (j - n) % p = j % p\n⊢ ... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.PeriodicityLemma | {
"line": 165,
"column": 85
} | {
"line": 165,
"column": 93
} | [
{
"pp": "α : Type u_1\np n : ℕ\nw : List α\ndvd : p ∣ n\nlen : n ≤ w.length\nper : w.HasPeriod p\np_pos : p > 0\npos : n > 0\nmod_w : ∀ i < w.length, w[i % p]? = w[i]?\ni : ℕ\nless_i : i < n + w.length\nj : ℕ\nless_j : j < n + w.length\nj_minus : j - n < w.length\nn_le_j : n ≤ j\nj_mod : (j - n) % p = j % p\n⊢ ... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.PeriodicityLemma | {
"line": 166,
"column": 28
} | {
"line": 166,
"column": 36
} | [
{
"pp": "α : Type u_1\np n : ℕ\nw : List α\ndvd : p ∣ n\nlen : n ≤ w.length\nper : w.HasPeriod p\np_pos : p > 0\npos : n > 0\nmod_w : ∀ i < w.length, w[i % p]? = w[i]?\ni : ℕ\nless_i : i < n + w.length\nj : ℕ\nless_j : j < n + w.length\nj_minus : j - n < w.length\nn_le_j : n ≤ j\nj_mod : (j - n) % p = j % p\n⊢ ... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.PeriodicityLemma | {
"line": 166,
"column": 28
} | {
"line": 166,
"column": 36
} | [
{
"pp": "α : Type u_1\np n : ℕ\nw : List α\ndvd : p ∣ n\nlen : n ≤ w.length\nper : w.HasPeriod p\np_pos : p > 0\npos : n > 0\nmod_w : ∀ i < w.length, w[i % p]? = w[i]?\ni : ℕ\nless_i : i < n + w.length\nj : ℕ\nless_j : j < n + w.length\nj_minus : j - n < w.length\nn_le_j : n ≤ j\nj_mod : (j - n) % p = j % p\n⊢ ... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.PeriodicityLemma | {
"line": 166,
"column": 28
} | {
"line": 166,
"column": 36
} | [
{
"pp": "α : Type u_1\np n : ℕ\nw : List α\ndvd : p ∣ n\nlen : n ≤ w.length\nper : w.HasPeriod p\np_pos : p > 0\npos : n > 0\nmod_w : ∀ i < w.length, w[i % p]? = w[i]?\ni : ℕ\nless_i : i < n + w.length\nj : ℕ\nless_j : j < n + w.length\nj_minus : j - n < w.length\nn_le_j : n ≤ j\nj_mod : (j - n) % p = j % p\n⊢ ... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.SplitBy | {
"line": 132,
"column": 4
} | {
"line": 132,
"column": 35
} | [
{
"pp": "case nil\nα : Type u_1\nr : α → α → Bool\na : α\ng : List α\ngs : List (List α)\nhgs' : ¬[] ∈ gs\nhgs : IsChain (fun b a ↦ ∃ ha hb, r (a.getLast ha) (b.head hb) = false) gs\nhga : ∀ (m : List α), m ∈ gs.head? → ∃ ha hb, r (m.getLast ha) ((g.reverse ++ [a]).head hb) = false\n⊢ IsChain (fun a b ↦ ∃ ha hb... | rw [splitBy.loop, reverse_cons] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.List.PeriodicityLemma | {
"line": 196,
"column": 4
} | {
"line": 196,
"column": 12
} | [
{
"pp": "case inr.inl\nα : Type u_1\nw : List α\np : ℕ\nper_p : w.HasPeriod p\np_pos : p > 0\nper_q : w.HasPeriod 0\nlen : p + 0 - p.gcd 0 ≤ w.length\n⊢ w.HasPeriod (p.gcd 0)",
"usedConstants": [
"Nat.gcd",
"Nat.gcd_zero_right",
"congrArg",
"List.HasPeriod",
"instOfNatNat",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.PeriodicityLemma | {
"line": 196,
"column": 4
} | {
"line": 196,
"column": 12
} | [
{
"pp": "case inr.inl\nα : Type u_1\nw : List α\np : ℕ\nper_p : w.HasPeriod p\np_pos : p > 0\nper_q : w.HasPeriod 0\nlen : p + 0 - p.gcd 0 ≤ w.length\n⊢ w.HasPeriod (p.gcd 0)",
"usedConstants": [
"Nat.gcd",
"Nat.gcd_zero_right",
"congrArg",
"List.HasPeriod",
"instOfNatNat",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.PeriodicityLemma | {
"line": 196,
"column": 4
} | {
"line": 196,
"column": 12
} | [
{
"pp": "case inr.inl\nα : Type u_1\nw : List α\np : ℕ\nper_p : w.HasPeriod p\np_pos : p > 0\nper_q : w.HasPeriod 0\nlen : p + 0 - p.gcd 0 ≤ w.length\n⊢ w.HasPeriod (p.gcd 0)",
"usedConstants": [
"Nat.gcd",
"Nat.gcd_zero_right",
"congrArg",
"List.HasPeriod",
"instOfNatNat",
... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.PeriodicityLemma | {
"line": 213,
"column": 18
} | {
"line": 213,
"column": 26
} | [
{
"pp": "α : Type u_1\nw : List α\np q : ℕ\nper_p : w.HasPeriod p\nper_q : w.HasPeriod q\nlen : p + q - p.gcd q ≤ w.length\np_pos : p > 0\nq_pos : q > 0\nhyp : compare p q = Ordering.gt\nq_lt_p : q < p\ngcd_lt_p : p.gcd q < p\nper_diff : (drop q w).HasPeriod (p - q)\n⊢ (take q w ++ drop q w ++ []).HasPeriod q",... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.PeriodicityLemma | {
"line": 213,
"column": 18
} | {
"line": 213,
"column": 26
} | [
{
"pp": "α : Type u_1\nw : List α\np q : ℕ\nper_p : w.HasPeriod p\nper_q : w.HasPeriod q\nlen : p + q - p.gcd q ≤ w.length\np_pos : p > 0\nq_pos : q > 0\nhyp : compare p q = Ordering.gt\nq_lt_p : q < p\ngcd_lt_p : p.gcd q < p\nper_diff : (drop q w).HasPeriod (p - q)\n⊢ (take q w ++ drop q w ++ []).HasPeriod q",... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.PeriodicityLemma | {
"line": 213,
"column": 18
} | {
"line": 213,
"column": 26
} | [
{
"pp": "α : Type u_1\nw : List α\np q : ℕ\nper_p : w.HasPeriod p\nper_q : w.HasPeriod q\nlen : p + q - p.gcd q ≤ w.length\np_pos : p > 0\nq_pos : q > 0\nhyp : compare p q = Ordering.gt\nq_lt_p : q < p\ngcd_lt_p : p.gcd q < p\nper_diff : (drop q w).HasPeriod (p - q)\n⊢ (take q w ++ drop q w ++ []).HasPeriod q",... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Matrix.ColumnRowPartitioned | {
"line": 111,
"column": 66
} | {
"line": 113,
"column": 25
} | [
{
"pp": "R : Type u_1\nm₁ : Type u_3\nm₂ : Type u_4\nn : Type u_5\n⊢ Function.Injective2 fromRows",
"usedConstants": [
"congrArg",
"Matrix",
"Sum",
"Sum.inl",
"imp_self._simp_1",
"And",
"Sum.inr",
"implies_congr",
"congr",
"True",
"Matrix.fro... | by
intro x1 x2 y1 y2
simp [← Matrix.ext_iff] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Matrix.ColumnRowPartitioned | {
"line": 118,
"column": 2
} | {
"line": 118,
"column": 10
} | [
{
"pp": "R : Type u_1\nm : Type u_2\nn₁ : Type u_6\nn₂ : Type u_7\nx1 x2 : Matrix m n₁ R\ny1 y2 : Matrix m n₂ R\n⊢ (∀ (i : m) (j : n₁ ⊕ n₂), x1.fromCols y1 i j = x2.fromCols y2 i j) →\n (∀ (i : m) (j : n₁), x1 i j = x2 i j) ∧ ∀ (i : m) (j : n₂), y1 i j = y2 i j",
"usedConstants": [
"Matrix.fromCols... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.SplitBy | {
"line": 166,
"column": 19
} | {
"line": 166,
"column": 42
} | [
{
"pp": "case cons\nα : Type u_1\nm : List α\nr : α → α → Bool\nb : α\nl : List α\nIH :\n ∀ {g : List α} {a : α},\n IsChain (fun x y ↦ r x y = true) (g.reverse ++ a :: l) →\n (∀ (x : α), x ∈ m.head? → r ((a :: l).getLast ⋯) x = false) →\n splitBy.loop r (l ++ m) a g [] = (g.reverse ++ a :: l) ::... | simp_all [splitBy.loop] | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.List.SplitBy | {
"line": 166,
"column": 19
} | {
"line": 166,
"column": 42
} | [
{
"pp": "case cons\nα : Type u_1\nm : List α\nr : α → α → Bool\nb : α\nl : List α\nIH :\n ∀ {g : List α} {a : α},\n IsChain (fun x y ↦ r x y = true) (g.reverse ++ a :: l) →\n (∀ (x : α), x ∈ m.head? → r ((a :: l).getLast ⋯) x = false) →\n splitBy.loop r (l ++ m) a g [] = (g.reverse ++ a :: l) ::... | simp_all [splitBy.loop] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.SplitBy | {
"line": 166,
"column": 19
} | {
"line": 166,
"column": 42
} | [
{
"pp": "case cons\nα : Type u_1\nm : List α\nr : α → α → Bool\nb : α\nl : List α\nIH :\n ∀ {g : List α} {a : α},\n IsChain (fun x y ↦ r x y = true) (g.reverse ++ a :: l) →\n (∀ (x : α), x ∈ m.head? → r ((a :: l).getLast ⋯) x = false) →\n splitBy.loop r (l ++ m) a g [] = (g.reverse ++ a :: l) ::... | simp_all [splitBy.loop] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.DershowitzManna | {
"line": 151,
"column": 33
} | {
"line": 151,
"column": 41
} | [
{
"pp": "α : 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\nhYZ : ∀ (y : α), ... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Multiset.DershowitzManna | {
"line": 151,
"column": 33
} | {
"line": 151,
"column": 41
} | [
{
"pp": "α : 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\nhYZ : ∀ (y : α), ... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Multiset.DershowitzManna | {
"line": 151,
"column": 33
} | {
"line": 151,
"column": 41
} | [
{
"pp": "α : 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\nhYZ : ∀ (y : α), ... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 45,
"column": 6
} | {
"line": 45,
"column": 29
} | [
{
"pp": "case cons.mp\na b m : ℕ\nl : List ℕ\nih : List.Pairwise Coprime l → (a ≡ b [MOD l.prod] ↔ ∀ (i : Fin l.length), a ≡ b [MOD l.get i])\nco : List.Pairwise Coprime (m :: l)\nthis : m.Coprime l.prod\nh0 : a ≡ b [MOD m]\nhs : ∀ (i : Fin l.length), a ≡ b [MOD l.get i]\ni : Fin (l.length + 1)\n⊢ a ≡ b [MOD (m... | cases i using Fin.cases | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 45,
"column": 34
} | {
"line": 45,
"column": 42
} | [
{
"pp": "case cons.mp.zero\na b m : ℕ\nl : List ℕ\nih : List.Pairwise Coprime l → (a ≡ b [MOD l.prod] ↔ ∀ (i : Fin l.length), a ≡ b [MOD l.get i])\nco : List.Pairwise Coprime (m :: l)\nthis : m.Coprime l.prod\nh0 : a ≡ b [MOD m]\nhs : ∀ (i : Fin l.length), a ≡ b [MOD l.get i]\n⊢ a ≡ b [MOD (m :: l).get 0]",
... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 45,
"column": 34
} | {
"line": 45,
"column": 42
} | [
{
"pp": "case cons.mp.succ\na b m : ℕ\nl : List ℕ\nih : List.Pairwise Coprime l → (a ≡ b [MOD l.prod] ↔ ∀ (i : Fin l.length), a ≡ b [MOD l.get i])\nco : List.Pairwise Coprime (m :: l)\nthis : m.Coprime l.prod\nh0 : a ≡ b [MOD m]\nhs : ∀ (i : Fin l.length), a ≡ b [MOD l.get i]\ni✝ : Fin l.length\n⊢ a ≡ b [MOD (m... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 127,
"column": 10
} | {
"line": 128,
"column": 59
} | [
{
"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⊢ ↑z < (List.map s l').prod",
"usedConstants": [
... | exact chineseRemainderOfList_lt_prod _ _ _ _
(by simpa [List.Perm.mem_iff hl.symm] using hs) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Nat.Choose.Lucas | {
"line": 59,
"column": 4
} | {
"line": 59,
"column": 43
} | [
{
"pp": "case mpr\nn k p : ℕ\ninst✝ : Fact (Nat.Prime p)\ndecompose : (X + 1) ^ n = (X + 1) ^ (n % p) * (X ^ p + 1) ^ (n / p)\nx₁ x₂ : ℕ\nhx : (x₁, x₂) ∈ range (n % p + 1) ×ˢ range (n / p + 1)\nh : k % p = x₁ ∧ k / p = x₂\n⊢ k = (x₁, x₂).1 + p * (x₁, x₂).2",
"usedConstants": [
"Eq.mpr",
"instHDi... | · rw [← h.left, ← h.right, mod_add_div] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Nat.Fib.Zeckendorf | {
"line": 167,
"column": 4
} | {
"line": 167,
"column": 68
} | [
{
"pp": "a : ℕ\nl : List ℕ\nhl' : (a :: l).IsZeckendorfRep\nhl : ((∀ x ∈ l, x + 2 ≤ a) ∧ 2 ≤ a) ∧ IsChain (fun a b ↦ b + 2 ≤ a) (l ++ [0])\nha : 0 < a\n⊢ a ≤ (map fib l).sum + (fib a + 1) ∧\n ∀ ⦃n : ℕ⦄, a < n → n ≤ (map fib l).sum + (fib a + 1) → (map fib l).sum + fib a < fib n",
"usedConstants": [
... | refine ⟨le_add_of_le_right <| le_fib_add_one _, fun n hn _ ↦ ?_⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Nat.Factorization.Divisors | {
"line": 24,
"column": 2
} | {
"line": 29,
"column": 96
} | [
{
"pp": "n : ℕ\nhn : n ≠ 0\n⊢ ↑n.divisors = {x | ∃ f ≤ n.factorization, (f.prod fun x1 x2 ↦ x1 ^ x2) = x}",
"usedConstants": [
"Iff.mpr",
"Finsupp.instFunLike",
"Set.ext",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"Finsupp.instLE",
"Nat.instMulZeroClass",
"_p... | refine Set.ext fun k ↦ ⟨fun h ↦ ?_, fun ⟨f, hle, h⟩ ↦ mem_divisors.mpr ⟨?_, hn⟩⟩
· have hdvd := dvd_of_mem_divisors h
have hk := ne_zero_of_dvd_ne_zero hn hdvd
exact ⟨_, factorization_le_iff_dvd hk hn |>.mpr hdvd, prod_factorization_pow_eq_self hk⟩
· rw [← h, ← prod_factorization_pow_eq_self hn]
exact p... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Factorization.Divisors | {
"line": 24,
"column": 2
} | {
"line": 29,
"column": 96
} | [
{
"pp": "n : ℕ\nhn : n ≠ 0\n⊢ ↑n.divisors = {x | ∃ f ≤ n.factorization, (f.prod fun x1 x2 ↦ x1 ^ x2) = x}",
"usedConstants": [
"Iff.mpr",
"Finsupp.instFunLike",
"Set.ext",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"Finsupp.instLE",
"Nat.instMulZeroClass",
"_p... | refine Set.ext fun k ↦ ⟨fun h ↦ ?_, fun ⟨f, hle, h⟩ ↦ mem_divisors.mpr ⟨?_, hn⟩⟩
· have hdvd := dvd_of_mem_divisors h
have hk := ne_zero_of_dvd_ne_zero hn hdvd
exact ⟨_, factorization_le_iff_dvd hk hn |>.mpr hdvd, prod_factorization_pow_eq_self hk⟩
· rw [← h, ← prod_factorization_pow_eq_self hn]
exact p... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Nth | {
"line": 87,
"column": 2
} | {
"line": 87,
"column": 37
} | [
{
"pp": "p : ℕ → Prop\nhf : (setOf p).Finite\nm : ℕ\nhm : m < #hf.toFinset\nn : ℕ\nhn : n < #hf.toFinset\nh : m < n\n⊢ (hf.toFinset.orderEmbOfFin ⋯) ⟨m, hm⟩ < (hf.toFinset.orderEmbOfFin ⋯) ⟨n, hn⟩",
"usedConstants": [
"Finset.orderEmbOfFin",
"PartialOrder.toPreorder",
"setOf",
"Order... | exact OrderEmbedding.strictMono _ h | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Nat.Nth | {
"line": 239,
"column": 6
} | {
"line": 239,
"column": 14
} | [
{
"pp": "p : ℕ → Prop\ninst✝ : DecidablePred p\nh : ∃ n, p n\n⊢ nth p 0 = Nat.find h",
"usedConstants": [
"Eq.mpr",
"congrArg",
"setOf",
"Nat.nth_zero",
"id",
"instOfNatNat",
"Nat.instInfSet",
"Nat",
"Nat.find",
"Nat.nth",
"OfNat.ofNat",
... | nth_zero | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Nat.Nth | {
"line": 293,
"column": 51
} | {
"line": 293,
"column": 62
} | [
{
"pp": "case pos.h\np : ℕ → Prop\nf : ℕ → ℕ\nhmaps : Set.MapsTo f {n | ∀ (hf : (setOf p).Finite), n < #hf.toFinset} (setOf p)\nhmono : StrictMonoOn f {n | ∀ (hf : (setOf p).Finite), n < #hf.toFinset}\nn : ℕ\nih : ∀ m < n, (∀ (hf : (setOf p).Finite), m < #hf.toFinset) → nth p m ≤ f m\nhn : ∀ (hf : (setOf p).Fin... | | _ n ih => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.Nat.Nth | {
"line": 345,
"column": 13
} | {
"line": 345,
"column": 21
} | [
{
"pp": "p : ℕ → Prop\nf : ℕ → ℕ\nhf : StrictMono f\nh0 : ∀ (k : ℕ), p k → k ∈ Set.range f\nhs : ∀ {p' : ℕ → Prop}, (∀ (k : ℕ), p' k → k ∈ Set.range f) → f '' {i | p' (f i)} = setOf p'\nh : ∀ (hfi : (setOf p).Finite), 0 < #hfi.toFinset\n⊢ f (nth (fun i ↦ p (f i)) 0) = nth p 0",
"usedConstants": [
"Eq.... | nth_zero | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Nat.Nth | {
"line": 387,
"column": 69
} | {
"line": 387,
"column": 77
} | [
{
"pp": "p : ℕ → Prop\ninst✝ : DecidablePred p\n⊢ ∀ ⦃x : ℕ⦄, x ∈ range (nth p 0) → ¬p x",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Finset",
"setOf",
"Nat.nth_zero",
"Membership.mem",
"id",
"instOfNatNat",
"Nat.instInfSet",
"Finset.range",
"F... | nth_zero | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Ordmap.Ordset | {
"line": 111,
"column": 25
} | {
"line": 112,
"column": 80
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\nt : Ordnode α\no₁ : WithBot α\no₂ : WithTop α\nh : Valid' o₂ t.dual o₁\n⊢ Valid' o₁ t o₂",
"usedConstants": [
"OrderDual.Preorder.dual_dual",
"Ordnode",
"congrArg",
"Ordnode.Valid'",
"Eq.mp",
"Ordnode.dual",
"OrderDual",
... | by
have := Valid'.dual h; rwa [dual_dual, OrderDual.Preorder.dual_dual] at this | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.PFunctor.Univariate.Basic | {
"line": 200,
"column": 4
} | {
"line": 201,
"column": 9
} | [
{
"pp": "case h.left\nP : PFunctor.{uA, uB}\nα : Type u\nr : α → α → Prop\nx y : ↑P α\nu : ↑P { p // r p.1 p.2 }\nxeq : (fun t ↦ (↑t).1) <$> u = x\nyeq : (fun t ↦ (↑t).2) <$> u = y\na : P.A\nf : P.B a → { p // r p.1 p.2 }\nh : u = ⟨a, f⟩\n⊢ x = ⟨a, fun i ↦ (↑(f i)).1⟩",
"usedConstants": [
"Eq.mpr",
... | · rw [← xeq, h]
rfl | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.PFunctor.Multivariate.Basic | {
"line": 170,
"column": 4
} | {
"line": 171,
"column": 9
} | [
{
"pp": "case h.left\nn : ℕ\nP : MvPFunctor.{u} n\nα : TypeVec.{u} n\nr : ⦃i : Fin2 n⦄ → α i → α i → Prop\nx y : ↑P α\nu : ↑P fun i ↦ { p // r p.1 p.2 }\nxeq : (fun i t ↦ (↑t).1) <$$> u = x\nyeq : (fun i t ↦ (↑t).2) <$$> u = y\na : P.A\nf : P.B a ⟹ fun i ↦ { p // r p.1 p.2 }\nh : u = ⟨a, f⟩\n⊢ x = ⟨a, fun i j ↦... | · rw [← xeq, h]
rfl | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Num.ZNum | {
"line": 154,
"column": 6
} | {
"line": 155,
"column": 39
} | [
{
"pp": "p : PosNum\n⊢ ↑p.bit0 = ZNum.pos p.bit0",
"usedConstants": [
"castPosNum",
"congrArg",
"ZNum.pos",
"Eq.mp",
"ZNum.bit0_of_bit0",
"ZNum",
"congr_arg",
"instHAdd",
"ZNum.instAdd",
"HAdd.hAdd",
"ZNum.bit0",
"instOneZNum",
"E... | have := congr_arg ZNum.bit0 (cast_to_znum p)
rwa [← ZNum.bit0_of_bit0] at this | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.ZNum | {
"line": 154,
"column": 6
} | {
"line": 155,
"column": 39
} | [
{
"pp": "p : PosNum\n⊢ ↑p.bit0 = ZNum.pos p.bit0",
"usedConstants": [
"castPosNum",
"congrArg",
"ZNum.pos",
"Eq.mp",
"ZNum.bit0_of_bit0",
"ZNum",
"congr_arg",
"instHAdd",
"ZNum.instAdd",
"HAdd.hAdd",
"ZNum.bit0",
"instOneZNum",
"E... | have := congr_arg ZNum.bit0 (cast_to_znum p)
rwa [← ZNum.bit0_of_bit0] at this | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Ordmap.Ordset | {
"line": 206,
"column": 15
} | {
"line": 206,
"column": 18
} | [
{
"pp": "case neg.inl\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\nl0 : 0 <... | mm₂ | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Ordmap.Invariants | {
"line": 494,
"column": 84
} | {
"line": 494,
"column": 92
} | [
{
"pp": "α : Type u_1\nsize✝ sz : ℕ\nl' : Ordnode α\ny : α\nr' : Ordnode α\nx : α\nr : Ordnode α\n⊢ r.dual.balanceL x (node sz r'.dual y l'.dual).eraseMax = (node size✝ r.dual x (node sz r'.dual y l'.dual)).eraseMax",
"usedConstants": [
"Eq.mpr",
"Ordnode",
"congrArg",
"id",
"O... | eraseMax | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Ordmap.Invariants | {
"line": 507,
"column": 86
} | {
"line": 507,
"column": 94
} | [
{
"pp": "α : Type u_1\nx✝ : ℕ\nl : Ordnode α\nx : α\nls : ℕ\nll : Ordnode α\nlx : α\nlr : Ordnode α\n⊢ (match ((node ls ll lx lr).eraseMax, findMax' lx lr) with\n | (r', xm) => (l.balanceL x r', xm)) =\n ((node x✝ l x (node ls ll lx lr)).eraseMax, findMax' lx lr)",
"usedConstants": [
"Eq.mpr",
... | eraseMax | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Ordmap.Invariants | {
"line": 549,
"column": 8
} | {
"line": 549,
"column": 23
} | [
{
"pp": "α : Type u_1\ninst✝² : LE α\ninst✝¹ : Std.Total fun x1 x2 ↦ x1 ≤ x2\ninst✝ : DecidableLE α\nx : α\nsize✝ : ℕ\nl : Ordnode α\ny : α\nr : Ordnode α\nthis : cmpLE x y = cmpLE y x\n⊢ (Ordnode.insert x (node size✝ l y r)).dual = Ordnode.insert x (node size✝ l y r).dual",
"usedConstants": [
"Ordnod... | Ordnode.insert, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Ordmap.Invariants | {
"line": 549,
"column": 30
} | {
"line": 549,
"column": 45
} | [
{
"pp": "α : Type u_1\ninst✝² : LE α\ninst✝¹ : Std.Total fun x1 x2 ↦ x1 ≤ x2\ninst✝ : DecidableLE α\nx : α\nsize✝ : ℕ\nl : Ordnode α\ny : α\nr : Ordnode α\nthis : cmpLE x y = cmpLE y x\n⊢ (match cmpLE x y with\n | Ordering.lt => (Ordnode.insert x l).balanceL y r\n | Ordering.eq => node size✝ l x r\n ... | Ordnode.insert, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PFunctor.Multivariate.M | {
"line": 290,
"column": 14
} | {
"line": 290,
"column": 22
} | [
{
"pp": "case refine_2.refl\nn : ℕ\nP : MvPFunctor.{u} (n + 1)\nα : TypeVec.{u} n\nR : P.M α → P.M α → Prop\nh : ∀ (x y : P.M α), R x y → (TypeVec.id ::: Quot.mk R) <$$> dest P x = (TypeVec.id ::: Quot.mk R) <$$> dest P y\nx y : P.M α\nthis : ∀ (x y : P.M α), R x y → Relation.EqvGen R x y\nx✝ : P.M α\n⊢ (TypeVe... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.PFunctor.Multivariate.M | {
"line": 290,
"column": 14
} | {
"line": 290,
"column": 22
} | [
{
"pp": "case refine_2.refl\nn : ℕ\nP : MvPFunctor.{u} (n + 1)\nα : TypeVec.{u} n\nR : P.M α → P.M α → Prop\nh : ∀ (x y : P.M α), R x y → (TypeVec.id ::: Quot.mk R) <$$> dest P x = (TypeVec.id ::: Quot.mk R) <$$> dest P y\nx y : P.M α\nthis : ∀ (x y : P.M α), R x y → Relation.EqvGen R x y\nx✝ : P.M α\n⊢ (TypeVe... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.PFunctor.Multivariate.M | {
"line": 290,
"column": 14
} | {
"line": 290,
"column": 22
} | [
{
"pp": "case refine_2.refl\nn : ℕ\nP : MvPFunctor.{u} (n + 1)\nα : TypeVec.{u} n\nR : P.M α → P.M α → Prop\nh : ∀ (x y : P.M α), R x y → (TypeVec.id ::: Quot.mk R) <$$> dest P x = (TypeVec.id ::: Quot.mk R) <$$> dest P y\nx y : P.M α\nthis : ∀ (x y : P.M α), R x y → Relation.EqvGen R x y\nx✝ : P.M α\n⊢ (TypeVe... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.PFunctor.Multivariate.M | {
"line": 290,
"column": 14
} | {
"line": 290,
"column": 22
} | [
{
"pp": "case refine_2.symm\nn : ℕ\nP : MvPFunctor.{u} (n + 1)\nα : TypeVec.{u} n\nR : P.M α → P.M α → Prop\nh : ∀ (x y : P.M α), R x y → (TypeVec.id ::: Quot.mk R) <$$> dest P x = (TypeVec.id ::: Quot.mk R) <$$> dest P y\nx y : P.M α\nthis : ∀ (x y : P.M α), R x y → Relation.EqvGen R x y\nx✝ y✝ : P.M α\na✝ : R... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.PFunctor.Multivariate.M | {
"line": 290,
"column": 14
} | {
"line": 290,
"column": 22
} | [
{
"pp": "case refine_2.symm\nn : ℕ\nP : MvPFunctor.{u} (n + 1)\nα : TypeVec.{u} n\nR : P.M α → P.M α → Prop\nh : ∀ (x y : P.M α), R x y → (TypeVec.id ::: Quot.mk R) <$$> dest P x = (TypeVec.id ::: Quot.mk R) <$$> dest P y\nx y : P.M α\nthis : ∀ (x y : P.M α), R x y → Relation.EqvGen R x y\nx✝ y✝ : P.M α\na✝ : R... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.PFunctor.Multivariate.M | {
"line": 290,
"column": 14
} | {
"line": 290,
"column": 22
} | [
{
"pp": "case refine_2.symm\nn : ℕ\nP : MvPFunctor.{u} (n + 1)\nα : TypeVec.{u} n\nR : P.M α → P.M α → Prop\nh : ∀ (x y : P.M α), R x y → (TypeVec.id ::: Quot.mk R) <$$> dest P x = (TypeVec.id ::: Quot.mk R) <$$> dest P y\nx y : P.M α\nthis : ∀ (x y : P.M α), R x y → Relation.EqvGen R x y\nx✝ y✝ : P.M α\na✝ : R... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.PFunctor.Multivariate.M | {
"line": 290,
"column": 14
} | {
"line": 290,
"column": 22
} | [
{
"pp": "case refine_2.trans\nn : ℕ\nP : MvPFunctor.{u} (n + 1)\nα : TypeVec.{u} n\nR : P.M α → P.M α → Prop\nh : ∀ (x y : P.M α), R x y → (TypeVec.id ::: Quot.mk R) <$$> dest P x = (TypeVec.id ::: Quot.mk R) <$$> dest P y\nx y : P.M α\nthis : ∀ (x y : P.M α), R x y → Relation.EqvGen R x y\nx✝ y✝ z✝ : P.M α\na✝... | simp_all | Lean.Elab.Tactic.evalSimpAll | Lean.Parser.Tactic.simpAll |
Mathlib.Data.PFunctor.Multivariate.M | {
"line": 290,
"column": 14
} | {
"line": 290,
"column": 22
} | [
{
"pp": "case refine_2.trans\nn : ℕ\nP : MvPFunctor.{u} (n + 1)\nα : TypeVec.{u} n\nR : P.M α → P.M α → Prop\nh : ∀ (x y : P.M α), R x y → (TypeVec.id ::: Quot.mk R) <$$> dest P x = (TypeVec.id ::: Quot.mk R) <$$> dest P y\nx y : P.M α\nthis : ∀ (x y : P.M α), R x y → Relation.EqvGen R x y\nx✝ y✝ z✝ : P.M α\na✝... | simp_all | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.PFunctor.Multivariate.M | {
"line": 290,
"column": 14
} | {
"line": 290,
"column": 22
} | [
{
"pp": "case refine_2.trans\nn : ℕ\nP : MvPFunctor.{u} (n + 1)\nα : TypeVec.{u} n\nR : P.M α → P.M α → Prop\nh : ∀ (x y : P.M α), R x y → (TypeVec.id ::: Quot.mk R) <$$> dest P x = (TypeVec.id ::: Quot.mk R) <$$> dest P y\nx y : P.M α\nthis : ∀ (x y : P.M α), R x y → Relation.EqvGen R x y\nx✝ y✝ z✝ : P.M α\na✝... | simp_all | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.PNat.Factors | {
"line": 249,
"column": 2
} | {
"line": 249,
"column": 37
} | [
{
"pp": "case a.mk\nv : PrimeMultiset\nl : List Nat.Primes\n⊢ ↑(toNatMultiset (Quot.mk (⇑(List.isSetoid Nat.Primes)) l)).prod.primeFactorsList =\n toNatMultiset (Quot.mk (⇑(List.isSetoid Nat.Primes)) l)",
"usedConstants": [
"Multiset.prod",
"Multiset",
"id",
"Nat.Primes",
"L... | dsimp [PrimeMultiset.toNatMultiset] | Lean.Elab.Tactic.evalDSimp | Lean.Parser.Tactic.dsimp |
Mathlib.Data.Ordmap.Invariants | {
"line": 646,
"column": 6
} | {
"line": 648,
"column": 80
} | [
{
"pp": "case node.nil\nα : Type u_1\nx : α\nrs : ℕ\nrl : Ordnode α\nrx : α\nrr : Ordnode α\nsr : (node rs rl rx rr).Sized\nsl : nil.Sized\nH1 : nil.size = 0 → (node rs rl rx rr).size ≤ 1\nH2 : 1 ≤ nil.size → 1 ≤ (node rs rl rx rr).size → (node rs rl rx rr).size ≤ delta * nil.size\n⊢ nil.balanceL x (node rs rl ... | have : size rl = 0 ∧ size rr = 0 := by
have := H1 rfl
rwa [size, sr.1, Nat.succ_le_succ_iff, Nat.le_zero, add_eq_zero] at this | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.Ordmap.Invariants | {
"line": 696,
"column": 2
} | {
"line": 706,
"column": 42
} | [
{
"pp": "α : Type u_1\nl : Ordnode α\nx : α\nr : Ordnode α\nhl : l.Balanced\nhr : r.Balanced\nsl : l.Sized\nsr : r.Sized\nH : (∃ l', Raised l' l.size ∧ BalancedSz l' r.size) ∨ ∃ r', Raised r.size r' ∧ BalancedSz l.size r'\n⊢ l.balanceL x r = l.balance' x r",
"usedConstants": [
"Eq.mpr",
"Ordnode... | rw [← balance_eq_balance' hl hr sl sr, balanceL_eq_balance sl sr]
· intro l0; rw [l0] at H
rcases H with (⟨_, ⟨⟨⟩⟩ | ⟨⟨⟩⟩, H⟩ | ⟨r', e, H⟩)
· exact balancedSz_zero.1 H.symm
exact le_trans (raised_iff.1 e).1 (balancedSz_zero.1 H.symm)
· intro l1 _
rcases H with (⟨l', e, H | ⟨_, H₂⟩⟩ | ⟨r', e, H | ⟨_,... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Ordmap.Invariants | {
"line": 696,
"column": 2
} | {
"line": 706,
"column": 42
} | [
{
"pp": "α : Type u_1\nl : Ordnode α\nx : α\nr : Ordnode α\nhl : l.Balanced\nhr : r.Balanced\nsl : l.Sized\nsr : r.Sized\nH : (∃ l', Raised l' l.size ∧ BalancedSz l' r.size) ∨ ∃ r', Raised r.size r' ∧ BalancedSz l.size r'\n⊢ l.balanceL x r = l.balance' x r",
"usedConstants": [
"Eq.mpr",
"Ordnode... | rw [← balance_eq_balance' hl hr sl sr, balanceL_eq_balance sl sr]
· intro l0; rw [l0] at H
rcases H with (⟨_, ⟨⟨⟩⟩ | ⟨⟨⟩⟩, H⟩ | ⟨r', e, H⟩)
· exact balancedSz_zero.1 H.symm
exact le_trans (raised_iff.1 e).1 (balancedSz_zero.1 H.symm)
· intro l1 _
rcases H with (⟨l', e, H | ⟨_, H₂⟩⟩ | ⟨r', e, H | ⟨_,... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Ordmap.Ordset | {
"line": 512,
"column": 8
} | {
"line": 512,
"column": 40
} | [
{
"pp": "α : Type u_1\ninst✝² : Preorder α\ninst✝¹ : Std.Total fun x1 x2 ↦ x1 ≤ x2\ninst✝ : DecidableLE α\nf : α → α\nx : α\nhf : ∀ (y : α), x ≤ y ∧ y ≤ x → x ≤ f y ∧ f y ≤ x\nsz : ℕ\nl : Ordnode α\ny : α\nr : Ordnode α\no₁ : WithBot α\no₂ : WithTop α\nh : Valid' o₁ (node sz l y r) o₂\nbl : nil.Bounded o₁ ↑x\nb... | exact (e.add_left _).add_right _ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Ordmap.Ordset | {
"line": 533,
"column": 4
} | {
"line": 533,
"column": 79
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Preorder α\ninst✝ : DecidableLE α\nx : α\nsize✝ : ℕ\nl : Ordnode α\ny : α\nr : Ordnode α\n⊢ insert' x (node size✝ l y r) = insertWith id x (node size✝ l y r)",
"usedConstants": [
"Ordnode.insertWith",
"Ordering.gt",
"Eq.mpr",
"Ordnode.insertWith.eq_def... | unfold insert' insertWith; cases cmpLE x y <;> simp [insert'_eq_insertWith] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.