module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 365
values | kind stringclasses 368
values |
|---|---|---|---|---|---|---|
Mathlib.Data.List.Sigma | {
"line": 421,
"column": 2
} | {
"line": 432,
"column": 25
} | [
{
"pp": "α : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nl : List (Sigma β)\nh : a ∈ l.keys\n⊢ ∃ b l₁ l₂, ¬a ∈ l₁.keys ∧ l = l₁ ++ ⟨a, b⟩ :: l₂ ∧ kerase a l = l₁ ++ l₂",
"usedConstants": [
"Eq.mpr",
"False",
"eq_false",
"congrArg",
"HEq.refl",
"List.Mem.tail",
... | induction l with
| nil => cases h
| cons hd tl ih =>
by_cases e : a = hd.1
· subst e
exact ⟨hd.2, [], tl, by simp, by cases hd; rfl, by simp⟩
· simp only [keys_cons, mem_cons] at h
rcases h with h | h
· exact absurd h e
rcases ih h with ⟨b, tl₁, tl₂, h₁, h₂, h₃⟩
exact ⟨b, h... | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.List.Sigma | {
"line": 421,
"column": 2
} | {
"line": 432,
"column": 25
} | [
{
"pp": "α : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nl : List (Sigma β)\nh : a ∈ l.keys\n⊢ ∃ b l₁ l₂, ¬a ∈ l₁.keys ∧ l = l₁ ++ ⟨a, b⟩ :: l₂ ∧ kerase a l = l₁ ++ l₂",
"usedConstants": [
"Eq.mpr",
"False",
"eq_false",
"congrArg",
"HEq.refl",
"List.Mem.tail",
... | induction l with
| nil => cases h
| cons hd tl ih =>
by_cases e : a = hd.1
· subst e
exact ⟨hd.2, [], tl, by simp, by cases hd; rfl, by simp⟩
· simp only [keys_cons, mem_cons] at h
rcases h with h | h
· exact absurd h e
rcases ih h with ⟨b, tl₁, tl₂, h₁, h₂, h₃⟩
exact ⟨b, h... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Sigma | {
"line": 421,
"column": 2
} | {
"line": 432,
"column": 25
} | [
{
"pp": "α : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nl : List (Sigma β)\nh : a ∈ l.keys\n⊢ ∃ b l₁ l₂, ¬a ∈ l₁.keys ∧ l = l₁ ++ ⟨a, b⟩ :: l₂ ∧ kerase a l = l₁ ++ l₂",
"usedConstants": [
"Eq.mpr",
"False",
"eq_false",
"congrArg",
"HEq.refl",
"List.Mem.tail",
... | induction l with
| nil => cases h
| cons hd tl ih =>
by_cases e : a = hd.1
· subst e
exact ⟨hd.2, [], tl, by simp, by cases hd; rfl, by simp⟩
· simp only [keys_cons, mem_cons] at h
rcases h with h | h
· exact absurd h e
rcases ih h with ⟨b, tl₁, tl₂, h₁, h₂, h₃⟩
exact ⟨b, h... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.PiInduction | {
"line": 58,
"column": 6
} | {
"line": 58,
"column": 26
} | [
{
"pp": "ι : 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 : (i ... | rw [hg, update_self] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.List.Sigma | {
"line": 734,
"column": 4
} | {
"line": 734,
"column": 24
} | [
{
"pp": "case cons\nα : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nb : β a\ntail✝ : List (Sigma β)\nih : ∀ {l₂ : List (Sigma β)}, b ∈ dlookup a (tail✝.kunion l₂) ↔ b ∈ dlookup a tail✝ ∨ ¬a ∈ tail✝.keys ∧ b ∈ dlookup a l₂\nl₂ : List (Sigma β)\na' : α\nsnd✝ : β a'\n⊢ b ∈ dlookup a ((⟨a', snd✝⟩ :: tail✝... | by_cases h₁ : a = a' | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.Data.Int.Bitwise | {
"line": 144,
"column": 2
} | {
"line": 144,
"column": 28
} | [
{
"pp": "case ofNat.ofNat\nm n : ℕ\n⊢ (↑(m + n)).bodd = ((↑m).bodd ^^ (↑n).bodd)",
"usedConstants": [
"congrArg",
"AddGroupWithOne.toAddMonoidWithOne",
"Int.bodd",
"AddMonoidWithOne.toNatCast",
"Int",
"Nat.cast",
"instHAdd",
"Bool.xor",
"HAdd.hAdd",
... | simp [bodd, Bool.xor_comm] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Int.Bitwise | {
"line": 144,
"column": 2
} | {
"line": 144,
"column": 28
} | [
{
"pp": "case ofNat.negSucc\nm n : ℕ\n⊢ (m.bodd ^^ n.succ.bodd) = ((↑m).bodd ^^ -[n+1].bodd)",
"usedConstants": [
"bne",
"Bool.not",
"congrArg",
"Int.bodd",
"instDecidableEqBool",
"Int",
"instBEqOfDecidableEq",
"Nat.cast",
"Bool.xor",
"congr",
... | simp [bodd, Bool.xor_comm] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Int.Bitwise | {
"line": 144,
"column": 2
} | {
"line": 144,
"column": 28
} | [
{
"pp": "case negSucc.ofNat\nm n : ℕ\n⊢ (n.bodd ^^ m.succ.bodd) = (-[m+1].bodd ^^ (↑n).bodd)",
"usedConstants": [
"bne",
"Bool.not",
"congrArg",
"Int.bodd",
"instDecidableEqBool",
"Int",
"instBEqOfDecidableEq",
"Nat.cast",
"Bool.xor",
"congr",
... | simp [bodd, Bool.xor_comm] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Int.Bitwise | {
"line": 144,
"column": 2
} | {
"line": 144,
"column": 28
} | [
{
"pp": "case negSucc.negSucc\nm n : ℕ\n⊢ -[(m + n).succ+1].bodd = (-[m+1].bodd ^^ -[n+1].bodd)",
"usedConstants": [
"bne",
"Bool.not",
"congrArg",
"Bool.not_not",
"Int.bodd",
"instDecidableEqBool",
"instBEqOfDecidableEq",
"instHAdd",
"Bool.xor",
"... | simp [bodd, Bool.xor_comm] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Int.Star | {
"line": 29,
"column": 2
} | {
"line": 29,
"column": 69
} | [
{
"pp": "n : ℕ\nhn : Even n\nx : ℤ\nhx : x ∈ nonneg ℤ\n⊢ x ∈ closure (range fun x ↦ x ^ n)",
"usedConstants": [
"Int.instAddCommGroup",
"one_pow",
"Eq.mpr",
"MulOne.toOne",
"instHSMul",
"HMul.hMul",
"Monoid.toMulOneClass",
"abs",
"congrArg",
"Int.i... | have : x = x.natAbs • 1 ^ n := by simpa [eq_comm (a := x)] using hx | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.List.Indexes | {
"line": 44,
"column": 2
} | {
"line": 44,
"column": 33
} | [
{
"pp": "α : Type u\nβ : Type v\nl : List α\nf : ℕ → α → β\n⊢ mapIdx f l = ofFn fun i ↦ f (↑i) (l.get i)",
"usedConstants": [
"List.mapIdx",
"Fin.succ",
"congrArg",
"List.get",
"List.ofFn",
"Fin.isLt",
"id",
"instOfNatNat",
"List.rec",
"Fin.val",
... | induction l generalizing f with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.List.Lemmas | {
"line": 33,
"column": 4
} | {
"line": 43,
"column": 45
} | [
{
"pp": "case cons\nα : Type u_1\nx hd : α\ntl : List α\nIH :\n ¬x ∈ tl →\n ∀ ⦃n : ℕ⦄,\n n ∈ {n | n ≤ tl.length} →\n ∀ ⦃m : ℕ⦄, m ∈ {n | n ≤ tl.length} → (fun k ↦ tl.insertIdx k x) n = (fun k ↦ tl.insertIdx k x) m → n = m\nhx : ¬x ∈ hd :: tl\nn : ℕ\nhn : n ∈ {n | n ≤ (hd :: tl).length}\nm : ℕ\nh... | simp only [length, Set.mem_setOf_eq] at hn hm
simp only [mem_cons, not_or] at hx
cases n <;> cases m
· rfl
· simp [hx.left] at h
· simp [Ne.symm hx.left] at h
· simp only [insertIdx_succ_cons, cons.injEq, true_and] at h
rw [Nat.succ_inj]
refine IH hx.right ?_ ?_ h
· simpa [Nat.... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Lemmas | {
"line": 33,
"column": 4
} | {
"line": 43,
"column": 45
} | [
{
"pp": "case cons\nα : Type u_1\nx hd : α\ntl : List α\nIH :\n ¬x ∈ tl →\n ∀ ⦃n : ℕ⦄,\n n ∈ {n | n ≤ tl.length} →\n ∀ ⦃m : ℕ⦄, m ∈ {n | n ≤ tl.length} → (fun k ↦ tl.insertIdx k x) n = (fun k ↦ tl.insertIdx k x) m → n = m\nhx : ¬x ∈ hd :: tl\nn : ℕ\nhn : n ∈ {n | n ≤ (hd :: tl).length}\nm : ℕ\nh... | simp only [length, Set.mem_setOf_eq] at hn hm
simp only [mem_cons, not_or] at hx
cases n <;> cases m
· rfl
· simp [hx.left] at h
· simp [Ne.symm hx.left] at h
· simp only [insertIdx_succ_cons, cons.injEq, true_and] at h
rw [Nat.succ_inj]
refine IH hx.right ?_ ?_ h
· simpa [Nat.... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Map2 | {
"line": 173,
"column": 22
} | {
"line": 174,
"column": 13
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\nf : α → Option β → γ\na : α\nas : List α\nh : (a :: as).length ≤ [].length\n⊢ map₂Left f (a :: as) [] = zipWith (fun a b ↦ f a (some b)) (a :: as) []",
"usedConstants": [
"False",
"List.zipWith",
"congrArg",
"False.elim",
"Nat.add_eq... | by
simp at h | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Shortlex | {
"line": 116,
"column": 4
} | {
"line": 116,
"column": 47
} | [
{
"pp": "case inl.h\nα : Type u_1\nr : α → α → Prop\nt₁ t₂ : List α\nh : Shortlex r t₁ t₂\ns : List α\nh1 : t₁.length < t₂.length\n⊢ (s ++ t₁).length < (s ++ t₂).length",
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.length_append",
"id",
"instHAppendOfAppend",
"List",
... | rw [List.length_append, List.length_append] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.List.PeriodicityLemma | {
"line": 116,
"column": 8
} | {
"line": 116,
"column": 29
} | [
{
"pp": "α : Type u_1\nu v w : List α\np : ℕ\nper : (u ++ v ++ w).HasPeriod p\nj : ℕ\nlen : j < v.length - p\nshift_position : (u ++ (v ++ w))[j + u.length]? = v[j]?\neq : j + u.length + p - u.length = j + p\n⊢ (u ++ (v ++ w))[j + u.length + p]? = v[j + p]?",
"usedConstants": [
"Eq.mpr",
"List.g... | getElem?_append_right | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.PeriodicityLemma | {
"line": 154,
"column": 8
} | {
"line": 156,
"column": 51
} | [] | (take n w ++ w)[j]? = (take n w)[j]? := getElem?_append_left (by simp_all)
_ = w[j]? := getElem?_take_of_lt j_lt_n
_ = w[j % p]? := Eq.symm (mod_w j (by lia)) | Lean.Elab.Tactic._aux_Mathlib_Tactic_Widget_Calc___elabRules_Lean_calcTactic_1 | Lean.calcSteps |
Mathlib.Data.Matrix.ColumnRowPartitioned | {
"line": 145,
"column": 63
} | {
"line": 146,
"column": 23
} | [
{
"pp": "R : Type u_1\nm : Type u_2\nn₁ : Type u_6\nn₂ : Type u_7\nA₁ : Matrix m n₁ R\nA₂ : Matrix m n₂ R\nR' : Type u_8\nf : R → R'\n⊢ (A₁.fromCols A₂).map f = (A₁.map f).fromCols (A₂.map f)",
"usedConstants": [
"Matrix.fromCols",
"Sum.casesOn",
"Sum",
"Sum.inl",
"Sum.inr",
... | by
ext _ (_ | _) <;> rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Multiset.DershowitzManna | {
"line": 98,
"column": 4
} | {
"line": 98,
"column": 40
} | [
{
"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\n⊢ {a} ≤ X",
"usedConstants": [
"congrArg",
"Multiset.instAddCancelCommMonoid",
"Multiset.mem_singleton._simp_1",... | have : a ∈ X + {b} := by simp [← h0] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.Multiset.DershowitzManna | {
"line": 100,
"column": 4
} | {
"line": 102,
"column": 31
} | [
{
"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\n⊢ M = M - {b} + {b}",
"usedConstants": [
"Multiset.mem_cons._simp_1",
"Eq.mpr",
"False",
"eq_false",
... | rw [tsub_add_cancel_of_le]
have : b ∈ a ::ₘ M := by simp [h0]
simpa [hab.symm] using this | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Multiset.DershowitzManna | {
"line": 100,
"column": 4
} | {
"line": 102,
"column": 31
} | [
{
"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\n⊢ M = M - {b} + {b}",
"usedConstants": [
"Multiset.mem_cons._simp_1",
"Eq.mpr",
"False",
"eq_false",
... | rw [tsub_add_cancel_of_le]
have : b ∈ a ::ₘ M := by simp [h0]
simpa [hab.symm] using this | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Digits.Div | {
"line": 33,
"column": 2
} | {
"line": 33,
"column": 78
} | [
{
"pp": "n : ℕ\n⊢ ↑n ≡ (List.map (fun n ↦ ↑n) (digits 10 n)).alternatingSum [ZMOD 11]",
"usedConstants": [
"Nat.ofDigits",
"id",
"instHMod",
"Int.instNegInt",
"instOfNatNat",
"Int",
"Nat.cast",
"HMod.hMod",
"instOfNat",
"Nat",
"Int.ModEq",
... | have t := zmodeq_ofDigits_digits 11 10 (-1 : ℤ) (by unfold Int.ModEq; rfl) n | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.Nat.Nth | {
"line": 354,
"column": 6
} | {
"line": 354,
"column": 38
} | [
{
"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'\nn : ℕ\nih : ∀ m ≤ n, (∀ (hfi : (setOf p).Finite), m < #hfi.toFinset) → f (nth (fun i ↦ p (f i)) m) = nth p m\nh : ∀ (hfi : (se... | convert rfl using 8 with k m' hm | Mathlib.Tactic._aux_Mathlib_Tactic_Convert___elabRules_Mathlib_Tactic_convert_1 | Mathlib.Tactic.convert |
Mathlib.Data.Ordmap.Ordset | {
"line": 197,
"column": 17
} | {
"line": 197,
"column": 48
} | [
{
"pp": "case pos\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 < l.s... | cases size ml <;> cases size mr | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.Ordmap.Ordset | {
"line": 199,
"column": 8
} | {
"line": 199,
"column": 27
} | [
{
"pp": "case pos.zero.succ\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... | rw [zero_add] at mm | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Num.ZNum | {
"line": 238,
"column": 8
} | {
"line": 238,
"column": 22
} | [
{
"pp": "n : ℕ\n⊢ (↑(n + 1)).toZNum = ZNum.ofInt' ↑(n + 1)",
"usedConstants": [
"Eq.mpr",
"Nat.cast_succ",
"ZNum.ofInt'",
"AddMonoid.toAddSemigroup",
"congrArg",
"id",
"AddMonoidWithOne.toNatCast",
"instOfNatNat",
"Int",
"Num.toZNum",
"Nat.ca... | Nat.cast_succ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.ZNum | {
"line": 238,
"column": 66
} | {
"line": 238,
"column": 80
} | [
{
"pp": "n : ℕ\n⊢ (ZNum.ofInt' ↑n).succ = ZNum.ofInt' ↑(n + 1)",
"usedConstants": [
"Eq.mpr",
"Nat.cast_succ",
"ZNum.ofInt'",
"ZNum.succ",
"AddMonoid.toAddSemigroup",
"congrArg",
"AddGroupWithOne.toAddMonoidWithOne",
"id",
"AddMonoidWithOne.toNatCast",
... | Nat.cast_succ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.ZNum | {
"line": 269,
"column": 33
} | {
"line": 269,
"column": 49
} | [
{
"pp": "m n : Num\n⊢ (↑m - ↑n).toNat = ↑m - ↑n",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"Nat.instMulZeroClass",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"Nat.instOne",
"AddMonoid.toAddSemigroup",
"... | ← to_nat_to_int, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.ZNum | {
"line": 269,
"column": 50
} | {
"line": 269,
"column": 66
} | [
{
"pp": "m n : Num\n⊢ (↑↑m - ↑n).toNat = ↑m - ↑n",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"Nat.instMulZeroClass",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"Nat.instOne",
"AddMonoid.toAddSemigroup",
... | ← to_nat_to_int, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Ordmap.Ordset | {
"line": 205,
"column": 15
} | {
"line": 205,
"column": 24
} | [
{
"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 <... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.ZNum | {
"line": 482,
"column": 28
} | {
"line": 482,
"column": 42
} | [
{
"pp": "n : ℕ\n⊢ -(↑(n + 1)).toZNumNeg = ↑(n + 1)",
"usedConstants": [
"Eq.mpr",
"Nat.cast_succ",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.toNonUnitalCommRing",
"AddMonoid.toAddSemigroup",
"ZNum.addMonoidWithOne",
"congrArg",
"id",
"No... | Nat.cast_succ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.ZNum | {
"line": 483,
"column": 6
} | {
"line": 483,
"column": 20
} | [
{
"pp": "n : ℕ\n⊢ (↑n).toZNum.succ = ↑(n + 1)",
"usedConstants": [
"Eq.mpr",
"Nat.cast_succ",
"ZNum.succ",
"AddMonoid.toAddSemigroup",
"ZNum.addMonoidWithOne",
"congrArg",
"id",
"AddMonoidWithOne.toNatCast",
"instOfNatNat",
"Num.toZNum",
"Nat... | Nat.cast_succ, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.ZNum | {
"line": 534,
"column": 34
} | {
"line": 534,
"column": 42
} | [
{
"pp": "case some.left\nn d : PosNum\nq r : Num\nh₁ : ↑r + ↑d * (↑q + ↑q) = ↑n\nh₂ : ↑r < 2 * ↑d\nthis✝ : ∀ {r₂ : Num}, Num.ofZNum' (r.sub' (Num.pos d)) = some r₂ ↔ ↑r = ↑r₂ + ↑d\nr₂ : Num\ne : Num.ofZNum' (r.sub' (Num.pos d)) = some r₂\nthis : ↑r = ↑r₂ + ↑d\n⊢ ↑r₂ + ↑d * (1 + (↑q + ↑q)) = ↑n",
"usedConsta... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Ordmap.Ordset | {
"line": 216,
"column": 6
} | {
"line": 216,
"column": 42
} | [
{
"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\... | refine add_lt_add_of_lt_of_le ?_ mm₂ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Ordmap.Ordset | {
"line": 286,
"column": 12
} | {
"line": 286,
"column": 15
} | [
{
"pp": "case neg.inr.inl.inl\nα : Type u_1\ninst✝ : Preorder α\nl : Ordnode α\nx : α\no₁ : WithBot α\no₂ : WithTop α\nhl : Valid' o₁ l ↑x\nrs : ℕ\nrl : Ordnode α\nrx : α\nrr : Ordnode α\nhr : Valid' (↑x) (Ordnode.node rs rl rx rr) o₂\nH1 : ¬l.size + (Ordnode.node rs rl rx rr).size ≤ 1\nH2 : delta * l.size ≤ rl... | rr0 | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PNat.Factors | {
"line": 351,
"column": 4
} | {
"line": 353,
"column": 29
} | [
{
"pp": "case a\nm n : ℕ+\n⊢ (m.gcd n).factorMultiset ≤ m.factorMultiset ⊓ n.factorMultiset",
"usedConstants": [
"Iff.mpr",
"PNat.gcd",
"Dvd.dvd",
"instDistribLatticePrimeMultiset",
"PNat.factorMultiset_le_iff",
"PartialOrder.toPreorder",
"semigroupDvd",
"PNat... | apply le_inf_iff.mpr; constructor <;> apply factorMultiset_le_iff.mpr
· exact gcd_dvd_left m n
· exact gcd_dvd_right m n | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.PNat.Factors | {
"line": 351,
"column": 4
} | {
"line": 353,
"column": 29
} | [
{
"pp": "case a\nm n : ℕ+\n⊢ (m.gcd n).factorMultiset ≤ m.factorMultiset ⊓ n.factorMultiset",
"usedConstants": [
"Iff.mpr",
"PNat.gcd",
"Dvd.dvd",
"instDistribLatticePrimeMultiset",
"PNat.factorMultiset_le_iff",
"PartialOrder.toPreorder",
"semigroupDvd",
"PNat... | apply le_inf_iff.mpr; constructor <;> apply factorMultiset_le_iff.mpr
· exact gcd_dvd_left m n
· exact gcd_dvd_right m n | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.PNat.Factors | {
"line": 383,
"column": 4
} | {
"line": 383,
"column": 40
} | [
{
"pp": "case a.h.e'_3.h.right\nm : ℕ+\np : Nat.Primes\nk : ℕ\ne_1✝ : PrimeMultiset = Multiset Nat.Primes\nq : Nat.Primes\nh : q ∈ Multiset.replicate k p\n⊢ q = p",
"usedConstants": [
"Nat.Primes",
"Multiset.eq_of_mem_replicate"
]
}
] | exact Multiset.eq_of_mem_replicate h | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.PNat.Xgcd | {
"line": 217,
"column": 16
} | {
"line": 217,
"column": 25
} | [
{
"pp": "case pos\nu : XgcdType\nhr : u.r = 0\nhq : u.q = 0\nh : 0 + (u.bp + 1) * 0 = u.ap + 1\n⊢ u.q = u.qp + 1",
"usedConstants": [
"Nat.instMulZeroClass",
"HMul.hMul",
"MulZeroClass.toMul",
"congrArg",
"Eq.mp",
"instOfNatNat",
"MulZeroClass.mul_zero",
"inst... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PNat.Xgcd | {
"line": 270,
"column": 75
} | {
"line": 275,
"column": 29
} | [
{
"pp": "u : XgcdType\nhr : u.r ≠ 0\n⊢ sizeOf u.step < sizeOf u",
"usedConstants": [
"PNat.XgcdType.step",
"Nat.succ_pred_eq_of_pos",
"congrArg",
"PNat.XgcdType.r",
"HSub.hSub",
"Eq.mp",
"id",
"instSubNat",
"instOfNatNat",
"Nat.mod_lt",
"PNat... | by
change u.r - 1 < u.bp
have h₀ : u.r - 1 + 1 = u.r := Nat.succ_pred_eq_of_pos (Nat.pos_of_ne_zero hr)
have h₁ : u.r < u.bp + 1 := Nat.mod_lt (u.ap + 1) u.bp.succ_pos
rw [← h₀] at h₁
exact lt_of_succ_lt_succ h₁ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.PNat.Xgcd | {
"line": 279,
"column": 6
} | {
"line": 279,
"column": 14
} | [
{
"pp": "u : XgcdType\nhs : u.wp + u.zp + u.wp * u.zp = u.x * u.y\n⊢ u.y * u.q + u.zp + u.wp + (u.y * u.q + u.zp) * u.wp = u.y * ((u.wp + 1) * u.q + u.x)",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"HMul.hMul",
"PNat.XgcdType.y",
"congrArg",
"PNat.XgcdType.... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Ordmap.Ordset | {
"line": 504,
"column": 8
} | {
"line": 504,
"column": 67
} | [
{
"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... | rw [size_balanceL vl.3 h.3.2.2 vl.2 h.2.2.2 H, h.2.size_eq] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.QPF.Multivariate.Basic | {
"line": 181,
"column": 16
} | {
"line": 181,
"column": 19
} | [
{
"pp": "case mp\nn : ℕ\nF : TypeVec.{u} n → Type u_1\nq : MvQPF F\nα : TypeVec.{u} n\nx : F α\nh : ∀ (p : (i : Fin2 n) → α i → Prop), LiftP p x ↔ ∀ (i : Fin2 n), ∀ u ∈ supp x i, p i u\na : (P F).A\nf : (P F).B a ⟹ α\nxeq : x = abs ⟨a, f⟩\nh' : ∀ (i : Fin2 n) (j : (P F).B a i), supp x i (f i j)\na' : Fin2 n\nf'... | h'' | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.Data.PNat.Xgcd | {
"line": 427,
"column": 18
} | {
"line": 427,
"column": 26
} | [
{
"pp": "a b : ℕ+\nd : ℕ+ := a.gcdD b\nw : ℕ+ := a.gcdW b\nx : ℕ := a.gcdX b\ny : ℕ := a.gcdY b\nz : ℕ+ := a.gcdZ b\na' : ℕ+ := a.gcdA' b\nb' : ℕ+ := a.gcdB' b\nu : XgcdType := XgcdType.start a b\nur : XgcdType := u.reduce\nhb : d = ur.b\nha' : ↑a' = ↑w + x\nhb' : ↑b' = y + ↑z\nhdet : w * z = (x * y).succPNat\n... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PNat.Xgcd | {
"line": 427,
"column": 27
} | {
"line": 427,
"column": 35
} | [
{
"pp": "a b : ℕ+\nd : ℕ+ := a.gcdD b\nw : ℕ+ := a.gcdW b\nx : ℕ := a.gcdX b\ny : ℕ := a.gcdY b\nz : ℕ+ := a.gcdZ b\na' : ℕ+ := a.gcdA' b\nb' : ℕ+ := a.gcdB' b\nu : XgcdType := XgcdType.start a b\nur : XgcdType := u.reduce\nhb : d = ur.b\nha' : ↑a' = ↑w + x\nhb' : ↑b' = y + ↑z\nhdet : w * z = (x * y).succPNat\n... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PNat.Xgcd | {
"line": 430,
"column": 18
} | {
"line": 430,
"column": 26
} | [
{
"pp": "a b : ℕ+\nd : ℕ+ := a.gcdD b\nw : ℕ+ := a.gcdW b\nx : ℕ := a.gcdX b\ny : ℕ := a.gcdY b\nz : ℕ+ := a.gcdZ b\na' : ℕ+ := a.gcdA' b\nb' : ℕ+ := a.gcdB' b\nu : XgcdType := XgcdType.start a b\nur : XgcdType := u.reduce\nhb : d = ur.b\nha' : ↑a' = ↑w + x\nhb' : ↑b' = y + ↑z\nhdet : w * z = (x * y).succPNat\n... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PNat.Xgcd | {
"line": 430,
"column": 27
} | {
"line": 430,
"column": 35
} | [
{
"pp": "a b : ℕ+\nd : ℕ+ := a.gcdD b\nw : ℕ+ := a.gcdW b\nx : ℕ := a.gcdX b\ny : ℕ := a.gcdY b\nz : ℕ+ := a.gcdZ b\na' : ℕ+ := a.gcdA' b\nb' : ℕ+ := a.gcdB' b\nu : XgcdType := XgcdType.start a b\nur : XgcdType := u.reduce\nhb : d = ur.b\nha' : ↑a' = ↑w + x\nhb' : ↑b' = y + ↑z\nhdet : w * z = (x * y).succPNat\n... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.QPF.Multivariate.Constructions.Fix | {
"line": 325,
"column": 4
} | {
"line": 325,
"column": 33
} | [
{
"pp": "case e_x\nn : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nα : TypeVec.{u} n\nβ : Fix F α → Type u\ng : (x : F (α ::: Sigma β)) → β (mk ((TypeVec.id ::: Sigma.fst) <$$> x))\nx : Fix F α\ny : Sigma β := rec (fun i ↦ ⟨mk ((TypeVec.id ::: Sigma.fst) <$$> i), g i⟩) x\nx' : F (α ::: Fix F α)\nih : (Typ... | simp only [Function.comp_def] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.QPF.Multivariate.Constructions.Cofix | {
"line": 404,
"column": 2
} | {
"line": 404,
"column": 34
} | [
{
"pp": "n : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nα : TypeVec.{u} n\nx : Cofix F α\nR : Cofix F α → Cofix F α → Prop := fun x y ↦ abs y.repr = x\n⊢ Quot.mk Mcongr x.repr = x",
"usedConstants": [
"instOfNatNat",
"MvQPF.Cofix.repr",
"MvQPF.Cofix.abs",
"instHAdd",
"Mv... | refine Cofix.bisim₂ R ?_ _ _ rfl | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.QPF.Univariate.Basic | {
"line": 306,
"column": 97
} | {
"line": 314,
"column": 12
} | [
{
"pp": "F : Type u → Type u\nq : QPF F\np : Fix F → Prop\nh : ∀ (x : F (Fix F)), Liftp p x → p (mk x)\n⊢ ∀ (x : Fix F), p x",
"usedConstants": [
"Eq.mpr",
"PFunctor.A",
"WType",
"congrArg",
"HEq.refl",
"QPF.Fix.ind_aux",
"PFunctor.B",
"Quot.ind",
"Exist... | by
rintro ⟨x⟩
induction x with | _ a f ih
change p ⟦⟨a, f⟩⟧
rw [← Fix.ind_aux a f]
apply h
rw [liftp_iff]
refine ⟨_, _, rfl, ?_⟩
convert ih | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.QPF.Univariate.Basic | {
"line": 567,
"column": 16
} | {
"line": 567,
"column": 19
} | [
{
"pp": "case mp\nF : Type u → Type u\nq : QPF F\nα : Type u\nx : F α\nh : ∀ (p : α → Prop), Liftp p x ↔ ∀ u ∈ supp x, p u\na : (P F).A\nf : (P F).B a → α\nxeq : x = abs ⟨a, f⟩\nh' : ∀ (i : (P F).B a), f i ∈ supp x\na' : (P F).A\nf' : (P F).B a' → α\n⊢ abs ⟨a', f'⟩ = x → f '' univ ⊆ f' '' univ",
"usedConsta... | h'' | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.Data.Real.Embedding | {
"line": 92,
"column": 2
} | {
"line": 92,
"column": 24
} | [
{
"pp": "case h\nM : Type u_1\ninst✝⁶ : AddCommGroup M\ninst✝⁵ : LinearOrder M\ninst✝⁴ : IsOrderedAddMonoid M\ninst✝³ : One M\ninst✝² : ZeroLEOneClass M\ninst✝¹ : NeZero 1\ninst✝ : Archimedean M\nx : M\nn : ℕ\nhn : x ≤ n • 1\n⊢ ∀ x_1 ∈ {r | r.num • 1 < r.den • x}, x_1 ≤ ↑n",
"usedConstants": [
"Rat"
... | intro ⟨num, den, _, _⟩ | Lean.Elab.Tactic.evalIntro | null |
Mathlib.Data.Real.Embedding | {
"line": 92,
"column": 2
} | {
"line": 92,
"column": 24
} | [
{
"pp": "case h\nM : Type u_1\ninst✝⁶ : AddCommGroup M\ninst✝⁵ : LinearOrder M\ninst✝⁴ : IsOrderedAddMonoid M\ninst✝³ : One M\ninst✝² : ZeroLEOneClass M\ninst✝¹ : NeZero 1\ninst✝ : Archimedean M\nx : M\nn : ℕ\nhn : x ≤ n • 1\n⊢ ∀ x_1 ∈ {r | r.num • 1 < r.den • x}, x_1 ≤ ↑n",
"usedConstants": [
"Rat"
... | intro ⟨num, den, _, _⟩ | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.Data.WSeq.Basic | {
"line": 496,
"column": 6
} | {
"line": 496,
"column": 18
} | [
{
"pp": "case h1.inr\nα : Type u\ns : WSeq α\na : α\nh✝ : a ∈ s\na' : α\ns' : WSeq α\nn : ℕ\nh : some a ∈ s'.get? n\n⊢ ∃ n, some a ∈ (cons a' s').get? n",
"usedConstants": [
"Stream'.WSeq.cons",
"Option.some",
"Membership.mem",
"Stream'.WSeq.get?",
"instOfNatNat",
"Comput... | exists n + 1 | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticExists_,,_1» | Lean.Parser.Tactic.«tacticExists_,,» |
Mathlib.Data.Sigma.Order | {
"line": 99,
"column": 6
} | {
"line": 99,
"column": 48
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\ninst✝ : (i : ι) → Preorder (α i)\n⊢ ∀ (a b c : (i : ι) × α i), a ≤ b → b ≤ c → a ≤ c",
"usedConstants": [
"Sigma"
]
}
] | rintro _ _ _ ⟨i, a, b, hab⟩ ⟨_, _, c, hbc⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.Data.WSeq.Relation | {
"line": 436,
"column": 25
} | {
"line": 448,
"column": 20
} | [
{
"pp": "α : Type u\nβ : Type v\nR : α → β → Prop\nS✝ : WSeq (WSeq α)\nT✝ : WSeq (WSeq β)\nh✝ : LiftRel (LiftRel R) S✝ T✝\ns1 : WSeq α\ns2 : WSeq β\nx✝¹ :\n (fun s1 s2 ↦ ∃ s t S T, s1 = s.append S.join ∧ s2 = t.append T.join ∧ LiftRel R s t ∧ LiftRel (LiftRel R) S T) s1 s2\ns : WSeq α\nt : WSeq β\nS : WSeq (WS... | by
-- We do not `dsimp` with `LiftRelO` since `liftRel_join.lem` uses `LiftRelO`.
dsimp only [destruct_append.aux, Computation.LiftRel]; constructor
· intro
apply liftRel_join.lem _ ST fun _ _ => id
· intro b mb
rw [← LiftRelO.swap]
apply liftRel_join.lem (s... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.ZMod.Factorial | {
"line": 46,
"column": 58
} | {
"line": 46,
"column": 66
} | [
{
"pp": "n p : ℕ\nh : n ≤ p\nx : ℕ\nhx : x ∈ range n\n⊢ -1 + -↑x = -1 * (↑x + 1)",
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"NegZeroClass.toNeg",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"ZMod.comm... | mul_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Dynamics.Ergodic.Ergodic | {
"line": 175,
"column": 2
} | {
"line": 177,
"column": 88
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\ns : Set α\nf : α → α\nμ : Measure α\nhf : Ergodic f μ\nhs : NullMeasurableSet s μ\nhs' : s ≤ᶠ[ae μ] f ⁻¹' s\nh_fin : μ s ≠ ∞\n⊢ s =ᶠ[ae μ] ∅ ∨ s =ᶠ[ae μ] univ",
"usedConstants": [
"MeasureTheory.ae",
"Eq.mpr",
"MeasureTheory.Measure",
"co... | replace h_fin : μ (f ⁻¹' s) ≠ ∞ := by rwa [hf.measure_preimage hs]
refine hf.quasiErgodic.ae_empty_or_univ₀ hs ?_
exact (ae_eq_of_ae_subset_of_measure_ge hs' (hf.measure_preimage hs).le hs h_fin).symm | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Dynamics.Ergodic.Ergodic | {
"line": 175,
"column": 2
} | {
"line": 177,
"column": 88
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\ns : Set α\nf : α → α\nμ : Measure α\nhf : Ergodic f μ\nhs : NullMeasurableSet s μ\nhs' : s ≤ᶠ[ae μ] f ⁻¹' s\nh_fin : μ s ≠ ∞\n⊢ s =ᶠ[ae μ] ∅ ∨ s =ᶠ[ae μ] univ",
"usedConstants": [
"MeasureTheory.ae",
"Eq.mpr",
"MeasureTheory.Measure",
"co... | replace h_fin : μ (f ⁻¹' s) ≠ ∞ := by rwa [hf.measure_preimage hs]
refine hf.quasiErgodic.ae_empty_or_univ₀ hs ?_
exact (ae_eq_of_ae_subset_of_measure_ge hs' (hf.measure_preimage hs).le hs h_fin).symm | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.MeasureTheory.Measure.ContinuousPreimage | {
"line": 94,
"column": 2
} | {
"line": 94,
"column": 76
} | [
{
"pp": "case h\nα : Type u_1\nX : Type u_2\nY : Type u_3\ninst✝⁹ : TopologicalSpace X\ninst✝⁸ : MeasurableSpace X\ninst✝⁷ : BorelSpace X\ninst✝⁶ : R1Space X\ninst✝⁵ : TopologicalSpace Y\ninst✝⁴ : MeasurableSpace Y\ninst✝³ : BorelSpace Y\ninst✝² : R1Space Y\nμ : Measure X\nν : Measure Y\ninst✝¹ : μ.InnerRegular... | rw [symmDiff_of_ge ha.subset_preimage, symmDiff_of_le hKg.subset_preimage] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.MeasureTheory.Measure.ContinuousPreimage | {
"line": 117,
"column": 4
} | {
"line": 117,
"column": 21
} | [
{
"pp": "X : Type u_2\nY : Type u_3\nZ : Type u_4\ninst✝¹⁰ : TopologicalSpace X\ninst✝⁹ : MeasurableSpace X\ninst✝⁸ : BorelSpace X\ninst✝⁷ : R1Space X\ninst✝⁶ : TopologicalSpace Y\ninst✝⁵ : MeasurableSpace Y\ninst✝⁴ : BorelSpace Y\ninst✝³ : R1Space Y\ninst✝² : TopologicalSpace Z\nμ : Measure X\nν : Measure Y\ni... | apply gt_mem_nhds | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | {
"line": 645,
"column": 13
} | {
"line": 647,
"column": 66
} | [
{
"pp": "f : CircleDeg1Lift\nn : ℕ\n⊢ τ (f ^ (n + 1)) = ↑(n + 1) * τ f",
"usedConstants": [
"CircleDeg1Lift.translationNumber_mul_of_commute",
"add_mul",
"Eq.mpr",
"MulOne.toOne",
"Real",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"HMul.hMul",
"CommRing.... | by
rw [pow_succ, translationNumber_mul_of_commute (Commute.pow_self f n),
translationNumber_pow n, Nat.cast_add_one, add_mul, one_mul] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | {
"line": 859,
"column": 4
} | {
"line": 859,
"column": 27
} | [
{
"pp": "case refine_2\nG : Type u_1\ninst✝ : Group G\nf₁ f₂ : G →* CircleDeg1Lift\nh : ∀ (g : G), τ (f₁ g) = τ (f₂ g)\nthis : ∀ (x : ℝ), BddAbove (range fun g ↦ (f₂ g⁻¹) ((f₁ g) x))\nF₁ : G →* ℝ ≃o ℝ := toOrderIso.comp f₁.toHomUnits\nF₂ : G →* ℝ ≃o ℝ := toOrderIso.comp f₂.toHomUnits\nhF₁ : ∀ (g : G), ⇑(F₁ g) =... | simp only [map_add_one] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Dynamics.Ergodic.Conservative | {
"line": 223,
"column": 12
} | {
"line": 223,
"column": 21
} | [
{
"pp": "case succ.refine_1\nα : Type u_1\ninst✝ : MeasurableSpace α\nf : α → α\nμ : Measure α\nhf : Conservative f μ\nn : ℕ\ns : Set α\nhs : MeasurableSet s\nhs0 : μ s ≠ 0\nx : α\nleft✝ : x ∈ s\nhx : {n | f^[n] x ∈ s}.Infinite\nk : ℕ\nhk : k ∈ {n | f^[n] x ∈ s}\nl : ℕ\nhl : l ∈ {n | f^[n] x ∈ s}\nhkl : k < l\n... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Dynamics.Ergodic.AddCircle | {
"line": 63,
"column": 19
} | {
"line": 63,
"column": 48
} | [
{
"pp": "T : ℝ\nhT : Fact (0 < T)\ns : Set (AddCircle T)\nι : Type u_1\nl : Filter ι\ninst✝ : l.NeBot\nu : ι → AddCircle T\nμ : Measure (AddCircle T) := volume\nhs : NullMeasurableSet s μ\nhu₁ : ∀ (i : ι), u i +ᵥ s =ᶠ[ae μ] s\nn : ι → ℕ := addOrderOf ∘ u\nhu₂ : Tendsto n l atTop\nhT₀ : 0 < T\nhT₁ : ENNReal.ofRe... | ae_eq_univ_iff_measure_eq hs, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Dynamics.Ergodic.Action.OfMinimal | {
"line": 108,
"column": 4
} | {
"line": 108,
"column": 46
} | [
{
"pp": "M : Type u_1\nX : Type u_2\ninst✝¹⁵ : Monoid M\ninst✝¹⁴ : SMul M X\ninst✝¹³ : TopologicalSpace X\ninst✝¹² : R1Space X\ninst✝¹¹ : MeasurableSpace X\ninst✝¹⁰ : BorelSpace X\nμ : Measure X\ninst✝⁹ : IsFiniteMeasure μ\ninst✝⁸ : μ.InnerRegular\nN : Type u_3\ninst✝⁷ : MulAction M N\ninst✝⁶ : Monoid N\ninst✝⁵... | refine (MulAction.dense_orbit M 1).mono ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Dynamics.Ergodic.RadonNikodym | {
"line": 43,
"column": 2
} | {
"line": 55,
"column": 59
} | [
{
"pp": "case h.e'_6\nX : Type u_1\nm : MeasurableSpace X\nμ ν : Measure X\ninst✝¹ : IsFiniteMeasure μ\ninst✝ : SigmaFinite ν\nf : X → X\nhfμ : MeasurePreserving f μ μ\nhfν : MeasurePreserving f ν ν\ns : Set X\nhsm : MeasurableSet s\nhνs : ν s = 0\nhμs : (μ.singularPart ν) sᶜ = 0\n⊢ μ.singularPart ν = μ.restric... | · refine singularPart_eq_restrict ?_ (hfν.preimage_null hνs)
rw [← mem_ae_iff, ← Filter.eventuallyEq_univ,
ae_eq_univ_iff_measure_eq (hfμ.measurable hsm).nullMeasurableSet]
calc
μ.singularPart ν (f ⁻¹' s) = (ν.withDensity (μ.rnDeriv ν) + μ.singularPart ν) (f ⁻¹' s) := by
rw [← hfν.measure_pr... | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 121,
"column": 4
} | {
"line": 130,
"column": 57
} | [
{
"pp": "case refine_2\nα : Type u_1\nm : MeasurableSpace α\nμ : Measure α\nf : α → ℝ≥0∞\nν : Measure α\ninst✝¹ : SigmaFinite μ\ninst✝ : SigmaFinite ν\nhμν : μ ≪ ν\nhf : AEMeasurable f ν\n⊢ μ.withDensity f = 0 + ν.withDensity fun x ↦ f x * μ.rnDeriv ν x",
"usedConstants": [
"Eq.mpr",
"MeasureThe... | ext1 s hs
rw [zero_add, withDensity_apply _ hs, withDensity_apply _ hs]
conv_lhs => rw [← Measure.withDensity_rnDeriv_eq _ _ hμν]
rw [setLIntegral_withDensity_eq_setLIntegral_mul_non_measurable₀ _ _ _ hs]
· congr with x
rw [mul_comm]
simp only [Pi.mul_apply]
· refine ae_restrict_of_ae ?_... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 121,
"column": 4
} | {
"line": 130,
"column": 57
} | [
{
"pp": "case refine_2\nα : Type u_1\nm : MeasurableSpace α\nμ : Measure α\nf : α → ℝ≥0∞\nν : Measure α\ninst✝¹ : SigmaFinite μ\ninst✝ : SigmaFinite ν\nhμν : μ ≪ ν\nhf : AEMeasurable f ν\n⊢ μ.withDensity f = 0 + ν.withDensity fun x ↦ f x * μ.rnDeriv ν x",
"usedConstants": [
"Eq.mpr",
"MeasureThe... | ext1 s hs
rw [zero_add, withDensity_apply _ hs, withDensity_apply _ hs]
conv_lhs => rw [← Measure.withDensity_rnDeriv_eq _ _ hμν]
rw [setLIntegral_withDensity_eq_setLIntegral_mul_non_measurable₀ _ _ _ hs]
· congr with x
rw [mul_comm]
simp only [Pi.mul_apply]
· refine ae_restrict_of_ae ?_... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Dynamics.OmegaLimit | {
"line": 282,
"column": 4
} | {
"line": 282,
"column": 97
} | [
{
"pp": "case h.left\nτ : Type u_1\nα : Type u_2\nβ : Type u_3\ninst✝¹ : TopologicalSpace β\nf : Filter τ\nϕ : τ → α → β\ns : Set α\ninst✝ : f.NeBot\nc : Set β\nhc₁ : IsCompact c\nhs : s.Nonempty\nv : Set τ\nhv₁ : v ∈ f\nhv₂ : closure (image2 ϕ v s) ⊆ c\nu₁ : Set τ\nhu₁ : u₁ ∈ f.sets\nu₂ : Set τ\nhu₂ : u₂ ∈ f.s... | all_goals exact closure_mono (image2_subset (inter_subset_inter_left _ (by simp)) Subset.rfl) | Lean.Elab.Tactic.evalAllGoals | Lean.Parser.Tactic.allGoals |
Mathlib.Dynamics.TopologicalEntropy.NetEntropy | {
"line": 121,
"column": 4
} | {
"line": 121,
"column": 16
} | [
{
"pp": "case mp\nX : Type u_1\nT : X → X\nF : Set X\nU : SetRel X X\nn : ℕ\nh : netMaxcard T F U n < ⊤\nk : ℕ\nk_max : ↑k = netMaxcard T F U n\n⊢ ∃ s, IsDynNetIn T F U n ↑s ∧ ↑s.card = netMaxcard T F U n",
"usedConstants": [
"Eq.mpr",
"ENat.instNatCast",
"congrArg",
"Finset",
... | rw [← k_max] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Dynamics.TopologicalEntropy.NetEntropy | {
"line": 120,
"column": 4
} | {
"line": 146,
"column": 13
} | [
{
"pp": "case mp\nX : Type u_1\nT : X → X\nF : Set X\nU : SetRel X X\nn : ℕ\nh : netMaxcard T F U n < ⊤\n⊢ ∃ s, IsDynNetIn T F U n ↑s ∧ ↑s.card = netMaxcard T F U n",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"ENat.some_eq_coe",
"WithTop.charZero",
"WithTop.instCompleteLinearOrde... | obtain ⟨k, k_max⟩ := WithTop.ne_top_iff_exists.1 h.ne
rw [← k_max]
simp only [ENat.some_eq_coe, Nat.cast_inj]
-- The criterion we want to use is `Nat.sSup_mem`. We rewrite `netMaxcard` with an `sSup`,
-- then check its `BddAbove` and `Nonempty` hypotheses.
have : netMaxcard T F U n
= sSup (Wit... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Dynamics.TopologicalEntropy.NetEntropy | {
"line": 120,
"column": 4
} | {
"line": 146,
"column": 13
} | [
{
"pp": "case mp\nX : Type u_1\nT : X → X\nF : Set X\nU : SetRel X X\nn : ℕ\nh : netMaxcard T F U n < ⊤\n⊢ ∃ s, IsDynNetIn T F U n ↑s ∧ ↑s.card = netMaxcard T F U n",
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"ENat.some_eq_coe",
"WithTop.charZero",
"WithTop.instCompleteLinearOrde... | obtain ⟨k, k_max⟩ := WithTop.ne_top_iff_exists.1 h.ne
rw [← k_max]
simp only [ENat.some_eq_coe, Nat.cast_inj]
-- The criterion we want to use is `Nat.sSup_mem`. We rewrite `netMaxcard` with an `sSup`,
-- then check its `BddAbove` and `Nonempty` hypotheses.
have : netMaxcard T F U n
= sSup (Wit... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Dynamics.TopologicalEntropy.NetEntropy | {
"line": 161,
"column": 40
} | {
"line": 161,
"column": 56
} | [
{
"pp": "X : Type u_1\nT : X → X\nF : Set X\nU : SetRel X X\nn : ℕ\nh : F = ∅\n⊢ netMaxcard T ∅ U n = 0",
"usedConstants": [
"Eq.mpr",
"congrArg",
"CommSemiring.toSemiring",
"NonUnitalNonAssocSemiring.toMulZeroClass",
"Dynamics.netMaxcard_empty",
"id",
"NonAssocSemi... | netMaxcard_empty | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 276,
"column": 2
} | {
"line": 286,
"column": 25
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\nμ ν : Measure α\ninst✝² : μ.HaveLebesgueDecomposition ν\ninst✝¹ : ν.HaveLebesgueDecomposition μ\ninst✝ : SigmaFinite μ\nhμν : μ ≪ ν\nhνμ : ν ≪ μ\n⊢ (μ.rnDeriv ν)⁻¹ =ᶠ[ae μ] ν.rnDeriv μ",
"usedConstants": [
"MeasureTheory.ae",
"Eq.mpr",
"Measure... | suffices μ.withDensity (μ.rnDeriv ν)⁻¹ = μ.withDensity (ν.rnDeriv μ) by
calc (μ.rnDeriv ν)⁻¹ =ᵐ[μ] (μ.withDensity (μ.rnDeriv ν)⁻¹).rnDeriv μ :=
(rnDeriv_withDensity _ (measurable_rnDeriv _ _).inv).symm
_ = (μ.withDensity (ν.rnDeriv μ)).rnDeriv μ := by rw [this]
_ =ᵐ[μ] ν.rnDeriv μ := rnDeriv_withD... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 276,
"column": 2
} | {
"line": 286,
"column": 25
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\nμ ν : Measure α\ninst✝² : μ.HaveLebesgueDecomposition ν\ninst✝¹ : ν.HaveLebesgueDecomposition μ\ninst✝ : SigmaFinite μ\nhμν : μ ≪ ν\nhνμ : ν ≪ μ\n⊢ (μ.rnDeriv ν)⁻¹ =ᶠ[ae μ] ν.rnDeriv μ",
"usedConstants": [
"MeasureTheory.ae",
"Eq.mpr",
"Measure... | suffices μ.withDensity (μ.rnDeriv ν)⁻¹ = μ.withDensity (ν.rnDeriv μ) by
calc (μ.rnDeriv ν)⁻¹ =ᵐ[μ] (μ.withDensity (μ.rnDeriv ν)⁻¹).rnDeriv μ :=
(rnDeriv_withDensity _ (measurable_rnDeriv _ _).inv).symm
_ = (μ.withDensity (ν.rnDeriv μ)).rnDeriv μ := by rw [this]
_ =ᵐ[μ] ν.rnDeriv μ := rnDeriv_withD... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Dynamics.TopologicalEntropy.Subset | {
"line": 136,
"column": 53
} | {
"line": 140,
"column": 48
} | [
{
"pp": "X : Type u_1\nT : X → X\nF : Set X\ninst✝ : UniformSpace X\nh : Continuous T\n⊢ coverEntropy T (closure F) = coverEntropy T F",
"usedConstants": [
"Filter.instMembership",
"iSup₂_le",
"SetRel",
"iSup",
"subset_closure",
"Dynamics.coverEntropy_monotone",
"Co... | by
refine (iSup₂_le fun U U_uni ↦ ?_).antisymm (coverEntropy_monotone T subset_closure)
obtain ⟨V, V_uni, V_U⟩ := comp_mem_uniformity_sets U_uni
exact le_iSup₂_of_le V V_uni ((coverEntropyEntourage_antitone T (closure F) V_U).trans
(coverEntropyEntourage_closure h F V V_uni)) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Dynamics.TopologicalEntropy.CoverEntropy | {
"line": 178,
"column": 2
} | {
"line": 180,
"column": 77
} | [
{
"pp": "case inr.inr.refine_2\nX : Type u_1\nT : X → X\nU : SetRel X X\nF : Set X\nm : ℕ\nF_inv : MapsTo T F F\ninst✝ : U.IsSymm\nn : ℕ\ns : Finset X\nh : IsDynCoverOf T F U m ↑s\nx✝ : Nonempty X\ns_nemp : (↑s).Nonempty\nx : X\nx_F : x ∈ F\nm_pos : m > 0\ndyncover : (Fin n → ↥s) → X\nh_dyncover :\n ∀ (t : Fin... | · rw [toFinset_card]
apply (Fintype.card_range_le dyncover).trans
simp only [Fintype.card_fun, Fintype.card_coe, Fintype.card_fin, le_refl] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 444,
"column": 2
} | {
"line": 444,
"column": 9
} | [
{
"pp": "case h\nα : Type u_1\nm : MeasurableSpace α\nμ ν : Measure α\ninst✝¹ : SigmaFinite μ\ninst✝ : SigmaFinite ν\nhν_ac : μ ≪ ν + μ\na : α\nh1 : (ν + μ).rnDeriv μ a = (ν.rnDeriv μ + μ.rnDeriv μ) a\nh2 : μ.rnDeriv μ a = 1\nh3 : μ.rnDeriv (ν + μ) a = (ν.rnDeriv μ a + 1)⁻¹\n⊢ μ.rnDeriv (ν + μ) a = (ν.rnDeriv μ... | rw [h3] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Dynamics.TopologicalEntropy.CoverEntropy | {
"line": 277,
"column": 8
} | {
"line": 277,
"column": 17
} | [
{
"pp": "case inr.inl\nX : Type u_1\nT : X → X\nU : SetRel X X\nF : Set X\nF_inv : MapsTo T F F\ninst✝ : U.IsSymm\nm : ℕ\nF_nonempty : F.Nonempty\n⊢ coverMincard T F (U ○ U) (m * 0) ≤ coverMincard T F U m ^ 0",
"usedConstants": [
"Eq.mpr",
"Nat.instMulZeroClass",
"HMul.hMul",
"MulZer... | mul_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 466,
"column": 13
} | {
"line": 466,
"column": 16
} | [
{
"pp": "case h\nα : Type u_1\nm : MeasurableSpace α\nμ ν : Measure α\ninst✝¹ : SigmaFinite μ\ninst✝ : SigmaFinite ν\na : α\n⊢ ν.rnDeriv (μ + ν) a = (μ.rnDeriv ν a + 1)⁻¹ →\n μ.rnDeriv (μ + ν) a = μ.rnDeriv ν a / (μ.rnDeriv ν a + 1) →\n μ.rnDeriv ν a < ∞ → μ.rnDeriv ν a = μ.rnDeriv (μ + ν) a / ν.rnDeriv... | ha1 | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.ModelTheory.Ultraproducts | {
"line": 149,
"column": 2
} | {
"line": 149,
"column": 73
} | [
{
"pp": "α : Type u_1\nM : α → Type u_2\nu : Ultrafilter α\nL : Language\ninst✝¹ : (a : α) → L.Structure (M a)\ninst✝ : ∀ (a : α), Nonempty (M a)\nβ : Type u_3\nφ : L.Formula β\nx : β → (a : α) → M a\n⊢ (φ.Realize fun i ↦ Quotient.mk' (x i)) ↔ ∀ᶠ (a : α) in ↑u, φ.Realize fun i ↦ x i a",
"usedConstants": [
... | simp_rw [Formula.Realize, ← boundedFormula_realize_cast φ x, iff_eq_eq] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.ModelTheory.Encoding | {
"line": 84,
"column": 6
} | {
"line": 86,
"column": 95
} | [
{
"pp": "L : Language\nα : Type u'\nl✝ : List (L.Term α)\nn : ℕ\nf : L.Functions n\nts : Fin n → L.Term α\nih : ∀ (a : Fin n) (l : List (α ⊕ (i : ℕ) × L.Functions i)), listDecode ((ts a).listEncode ++ l) = ts a :: listDecode l\nl : List (α ⊕ (i : ℕ) × L.Functions i)\n⊢ listDecode (flatMap (fun i ↦ (ts i).listEn... | induction finRange n with
| nil => rfl
| cons i l' l'ih => rw [flatMap_cons, List.append_assoc, ih, map_cons, l'ih, cons_append] | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.ModelTheory.Substructures | {
"line": 385,
"column": 77
} | {
"line": 385,
"column": 87
} | [
{
"pp": "L : Language\nM : Type w\ninst✝ : L.Structure M\nι : Sort u_3\nS : ι → L.Substructure M\n⊢ ⨆ i, S i = ⨆ i, (closure L).toFun ↑(S i)",
"usedConstants": [
"CompleteLattice.instOmegaCompletePartialOrder",
"congrArg",
"iSup",
"PartialOrder.toPreorder",
"FirstOrder.Language... | closure_eq | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.ModelTheory.Semantics | {
"line": 557,
"column": 2
} | {
"line": 557,
"column": 49
} | [
{
"pp": "L : Language\nM : Type w\ninst✝ : L.Structure M\nα : Type u'\nv : α → M\nR : L.Relations 1\nt : L.Term α\n⊢ (R.formula₁ t).Realize v ↔ RelMap R ![Term.realize v t]",
"usedConstants": [
"Eq.mpr",
"FirstOrder.Language.Formula.realize_rel",
"congrArg",
"FirstOrder.Language.Term... | rw [Relations.formula₁, realize_rel, iff_eq_eq] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.ModelTheory.Semantics | {
"line": 849,
"column": 4
} | {
"line": 849,
"column": 33
} | [
{
"pp": "case all\nL : Language\nM : Type w\ninst✝ : L.Structure M\nα : Type u'\nn n✝ : ℕ\nf✝ : L.BoundedFormula α (n✝ + 1)\nih3 : ∀ (v : α ⊕ Fin (n✝ + 1) → M), f✝.toFormula.Realize v ↔ f✝.Realize (v ∘ Sum.inl) (v ∘ Sum.inr)\nv : α ⊕ Fin n✝ → M\na : M\nh :\n f✝.toFormula.Realize (Sum.elim (v ∘ Sum.inl) (snoc (... | simp only [Function.comp_def] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.ModelTheory.Satisfiability | {
"line": 183,
"column": 8
} | {
"line": 183,
"column": 47
} | [
{
"pp": "L : Language\nι : Type u_1\nT : ι → L.Theory\nh : ∀ (s : Finset ι), IsSatisfiable (⋃ i ∈ s, T i)\n⊢ IsSatisfiable (⋃ i, T i)",
"usedConstants": [
"FirstOrder.Language.Theory.isSatisfiable_iff_isFinitelySatisfiable",
"Eq.mpr",
"FirstOrder.Language.Theory.IsSatisfiable",
"Firs... | isSatisfiable_iff_isFinitelySatisfiable | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.ModelTheory.Encoding | {
"line": 283,
"column": 21
} | {
"line": 287,
"column": 7
} | [
{
"pp": "L : Language\nα : Type u'\nφ : (n : ℕ) × L.BoundedFormula α n\n⊢ (listDecode φ.snd.listEncode)[0]? = some φ",
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.instGetElem?NatLtLength",
"Option.some",
"FirstOrder.Language.Term",
"Eq.mp",
"Sum",
"id",
... | by
have h := listDecode_encode_list [φ]
rw [flatMap_singleton] at h
rw [h]
rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.ModelTheory.Satisfiability | {
"line": 532,
"column": 2
} | {
"line": 532,
"column": 42
} | [
{
"pp": "κ : Cardinal.{w}\nT : Language.empty.Theory\nM N : T.ModelType\nhM : #↑M = κ\nhN : #↑N = κ\n⊢ Nonempty (↑M ≃[Language.empty] ↑N)",
"usedConstants": [
"Eq.mpr",
"FirstOrder.Language.empty",
"Cardinal",
"FirstOrder.Language.Theory.ModelType.struc",
"congrArg",
"Fir... | by rw [empty.nonempty_equiv_iff, hM, hN] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.ModelTheory.ElementaryMaps | {
"line": 77,
"column": 4
} | {
"line": 77,
"column": 97
} | [
{
"pp": "L : Language\nM : Type u_1\nN : Type u_2\ninst✝¹ : L.Structure M\ninst✝ : L.Structure N\nf : M ↪ₑ[L] N\nα : Type u_5\nn : ℕ\nφ : L.BoundedFormula α n\nv : α → M\nxs : Fin n → M\n⊢ φ.Realize (⇑f ∘ v) (⇑f ∘ xs) ↔ φ.Realize v xs",
"usedConstants": [
"Eq.mpr",
"FirstOrder.Language.BoundedFo... | rw [← BoundedFormula.realize_restrictFreeVar' Set.Subset.rfl, Set.inclusion_eq_id, iff_eq_eq] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.ModelTheory.ElementaryMaps | {
"line": 186,
"column": 24
} | {
"line": 186,
"column": 53
} | [
{
"pp": "L : Language\nM : Type u_1\nN : Type u_2\nP : Type u_3\nQ : Type u_4\ninst✝³ : L.Structure M\ninst✝² : L.Structure N\ninst✝¹ : L.Structure P\ninst✝ : L.Structure Q\nhnp : N ↪ₑ[L] P\nhmn : M ↪ₑ[L] N\nn : ℕ\nφ : L.Formula (Fin n)\nx : Fin n → M\n⊢ φ.Realize ((⇑hnp ∘ ⇑hmn) ∘ x) ↔ φ.Realize x",
"usedCo... | by simp [Function.comp_assoc] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.FieldTheory.AxGrothendieck | {
"line": 213,
"column": 2
} | {
"line": 213,
"column": 27
} | [
{
"pp": "K : Type u_1\nι : Type u_2\ninst✝³ : Field K\ninst✝² : IsAlgClosed K\ninst✝¹ : Finite ι\ninst✝ : CompatibleRing K\nc : Set K\nS : Set (ι → K)\nhS : ∃ A0, ↑A0 ⊆ c ∧ (↑A0).Definable ring S\nps : ι → MvPolynomial ι K\nthis : Fintype ι := Fintype.ofFinite ι\np : ℕ := ringChar K\n⊢ Set.MapsTo (fun v i ↦ (ev... | rcases hS with ⟨c, _, hS⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.SetTheory.Cardinal.Divisibility | {
"line": 122,
"column": 4
} | {
"line": 122,
"column": 44
} | [
{
"pp": "n : ℕ\nh✝ : ∀ (a b : ℕ), n ∣ a * b → n ∣ a ∨ n ∣ b\nb c : Cardinal.{u_1}\nhbc : ↑n ∣ b * c\nh' : ℵ₀ ≤ b * c\nhb : b ≠ 0\nhc : c ≠ 0\nhℵ₀ : ℵ₀ ≤ b ∨ ℵ₀ ≤ c\nh : ↑n = 0\n⊢ False",
"usedConstants": [
"Dvd.dvd",
"HMul.hMul",
"Cardinal",
"MulZeroClass.toMul",
"congrArg",
... | rw [h, zero_dvd_iff, mul_eq_zero] at hbc | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.FieldTheory.Finite.Polynomial | {
"line": 77,
"column": 2
} | {
"line": 84,
"column": 20
} | [
{
"pp": "K : Type u_1\nσ : Type u_2\ninst✝² : Fintype K\ninst✝¹ : Fintype σ\ninst✝ : CommRing K\nc : σ → K\n⊢ (indicator c).degrees ≤ ∑ s, (Fintype.card K - 1) • {s}",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Eq.mpr",
"Nat.instMulZeroClass",
"AddMonoidAlgebra.semiring",
... | rw [indicator]
classical
refine degrees_prod_le.trans <| Finset.sum_le_sum fun s _ ↦ degrees_sub_le.trans ?_
rw [degrees_one, Multiset.zero_union]
refine le_trans degrees_pow_le (nsmul_le_nsmul_right ?_ _)
refine degrees_sub_le.trans ?_
rw [degrees_C, Multiset.union_zero]
exact degrees_X' _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.FieldTheory.Finite.Polynomial | {
"line": 77,
"column": 2
} | {
"line": 84,
"column": 20
} | [
{
"pp": "K : Type u_1\nσ : Type u_2\ninst✝² : Fintype K\ninst✝¹ : Fintype σ\ninst✝ : CommRing K\nc : σ → K\n⊢ (indicator c).degrees ≤ ∑ s, (Fintype.card K - 1) • {s}",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Eq.mpr",
"Nat.instMulZeroClass",
"AddMonoidAlgebra.semiring",
... | rw [indicator]
classical
refine degrees_prod_le.trans <| Finset.sum_le_sum fun s _ ↦ degrees_sub_le.trans ?_
rw [degrees_one, Multiset.zero_union]
refine le_trans degrees_pow_le (nsmul_le_nsmul_right ?_ _)
refine degrees_sub_le.trans ?_
rw [degrees_C, Multiset.union_zero]
exact degrees_X' _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.FieldTheory.CardinalEmb | {
"line": 161,
"column": 62
} | {
"line": 161,
"column": 90
} | [
{
"pp": "case refine_1.h\nF : Type u\nE : Type v\ninst✝³ : Field F\ninst✝² : Field E\ninst✝¹ : Algebra F E\nrank_inf : Fact (ℵ₀ ≤ Module.rank F E)\ninst✝ : Algebra.IsAlgebraic F E\ni j : (Module.rank F E).ord.ToType\nhj : j ∈ Iio i\n⊢ φ j ∈ Iio (φ i)",
"usedConstants": [
"Field.Emb.Cardinal.strictMono... | exact strictMono_leastExt hj | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.RingTheory.Invariant.Basic | {
"line": 357,
"column": 58
} | {
"line": 358,
"column": 66
} | [
{
"pp": "A : Type u_1\nB : Type u_2\ninst✝¹⁶ : CommRing A\ninst✝¹⁵ : CommRing B\ninst✝¹⁴ : Algebra A B\nG : Type u_3\ninst✝¹³ : Group G\ninst✝¹² : MulSemiringAction G B\ninst✝¹¹ : SMulCommClass G A B\nP : Ideal A\nQ : Ideal B\ninst✝¹⁰ : Q.LiesOver P\nK : Type u_4\nL : Type u_5\ninst✝⁹ : Field K\ninst✝⁸ : Field ... | by
simp [IsFractionRing.stabilizerHom, MulAction.subgroup_smul_def] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.FieldTheory.Galois.IsGaloisGroup | {
"line": 320,
"column": 62
} | {
"line": 320,
"column": 73
} | [
{
"pp": "G : Type u_1\nK : Type u_3\nL : Type u_4\ninst✝⁴ : Group G\ninst✝³ : Field K\ninst✝² : Field L\ninst✝¹ : Algebra K L\ninst✝ : MulSemiringAction G L\nF : IntermediateField K L\nN : Subgroup G\nhN : N.Normal\nhF : IsGaloisGroup (↥N) (↥F) L\ng : G\nx : ↥F\nn : ↥N\n⊢ (g • (g⁻¹ * ↑n * g)) • ↑x = g • ↑x",
... | smul_assoc, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.FieldTheory.IsPerfectClosure | {
"line": 228,
"column": 6
} | {
"line": 228,
"column": 14
} | [
{
"pp": "K : Type u_1\nL : Type u_2\ninst✝⁴ : CommSemiring K\ninst✝³ : CommSemiring L\ni : K →+* L\np : ℕ\ninst✝² : IsPRadical i p\ninst✝¹ : ExpChar L p\ninst✝ : PerfectRing L p\nx : L\n⊢ liftAux i i p x = x",
"usedConstants": [
"iterateFrobeniusEquiv",
"Eq.mpr",
"PerfectRing.liftAux.eq_1"... | liftAux, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.FieldTheory.IsPerfectClosure | {
"line": 238,
"column": 6
} | {
"line": 238,
"column": 14
} | [
{
"pp": "K : Type u_1\nM : Type u_3\ninst✝³ : CommSemiring K\ninst✝² : CommSemiring M\nj : K →+* M\np : ℕ\ninst✝¹ : ExpChar M p\ninst✝ : PerfectRing M p\nx : K\nthis : (Classical.choose ⋯).2 = x ^ p ^ (Classical.choose ⋯).1\n⊢ liftAux (RingHom.id K) j p x = j x",
"usedConstants": [
"iterateFrobeniusEq... | liftAux, | Lean.Elab.Tactic.evalRewriteSeq | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.