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.PNat.Interval | {
"line": 94,
"column": 6
} | {
"line": 94,
"column": 17
} | [
{
"pp": "a b : ℕ+\n⊢ Fintype.card ↑(Set.Ioo a b) = ↑b - ↑a - 1",
"usedConstants": [
"PNat.val",
"Eq.mpr",
"instLinearOrderPNat",
"congrArg",
"PartialOrder.toPreorder",
"HSub.hSub",
"SemilatticeInf.toPartialOrder",
"Set.Elem",
"DistribLattice.toLattice",
... | ← card_Ioo, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PSigma.Order | {
"line": 80,
"column": 8
} | {
"line": 80,
"column": 31
} | [
{
"pp": "case refine_1.left.right\nι : Type u_1\nα : ι → Type u_2\ninst✝¹ : Preorder ι\ninst✝ : (i : ι) → Preorder (α i)\na₁✝ : ι\ni a : α a₁✝\nhji : a₁✝ < a₁✝\nhab : a < i\n⊢ False",
"usedConstants": [
"lt_irrefl"
]
},
{
"pp": "case refine_1.right.left\nι : Type u_1\nα : ι → Type u_2\nins... | · exact lt_irrefl _ hji | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.PSigma.Order | {
"line": 138,
"column": 6
} | {
"line": 140,
"column": 46
} | [
{
"pp": "case left\nι : Type u_1\nα : ι → Type u_2\ninst✝⁴ : Preorder ι\ninst✝³ : DenselyOrdered ι\ninst✝² : ∀ (i : ι), Nonempty (α i)\ninst✝¹ : (i : ι) → Preorder (α i)\ninst✝ : ∀ (i : ι), DenselyOrdered (α i)\ni : ι\na : α i\nj : ι\nb : α j\nh : i < j\n⊢ ∃ a_1, ⟨i, a⟩ < a_1 ∧ a_1 < ⟨j, b⟩",
"usedConstants... | obtain ⟨k, hi, hj⟩ := exists_between h
obtain ⟨c⟩ : Nonempty (α k) := inferInstance
exact ⟨⟨k, c⟩, left _ _ hi, left _ _ hj⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.PSigma.Order | {
"line": 138,
"column": 6
} | {
"line": 140,
"column": 46
} | [
{
"pp": "case left\nι : Type u_1\nα : ι → Type u_2\ninst✝⁴ : Preorder ι\ninst✝³ : DenselyOrdered ι\ninst✝² : ∀ (i : ι), Nonempty (α i)\ninst✝¹ : (i : ι) → Preorder (α i)\ninst✝ : ∀ (i : ι), DenselyOrdered (α i)\ni : ι\na : α i\nj : ι\nb : α j\nh : i < j\n⊢ ∃ a_1, ⟨i, a⟩ < a_1 ∧ a_1 < ⟨j, b⟩",
"usedConstants... | obtain ⟨k, hi, hj⟩ := exists_between h
obtain ⟨c⟩ : Nonempty (α k) := inferInstance
exact ⟨⟨k, c⟩, left _ _ hi, left _ _ hj⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Pi.Interval | {
"line": 72,
"column": 4
} | {
"line": 72,
"column": 43
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\ninst✝⁴ : Fintype ι\ninst✝³ : DecidableEq ι\ninst✝² : (i : ι) → DecidableEq (α i)\ninst✝¹ : (i : ι) → PartialOrder (α i)\ninst✝ : (i : ι) → LocallyFiniteOrderTop (α i)\na✝ a x : (i : ι) → α i\n⊢ x ∈ (fun a ↦ piFinset fun i ↦ Ici (a i)) a ↔ a ≤ x",
"usedConstants": [
... | simp_rw [mem_piFinset, mem_Ici, le_def] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Data.Pi.Interval | {
"line": 72,
"column": 4
} | {
"line": 72,
"column": 43
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\ninst✝⁴ : Fintype ι\ninst✝³ : DecidableEq ι\ninst✝² : (i : ι) → DecidableEq (α i)\ninst✝¹ : (i : ι) → PartialOrder (α i)\ninst✝ : (i : ι) → LocallyFiniteOrderTop (α i)\na✝ a x : (i : ι) → α i\n⊢ x ∈ (fun a ↦ piFinset fun i ↦ Ici (a i)) a ↔ a ≤ x",
"usedConstants": [
... | simp_rw [mem_piFinset, mem_Ici, le_def] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Pi.Interval | {
"line": 72,
"column": 4
} | {
"line": 72,
"column": 43
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\ninst✝⁴ : Fintype ι\ninst✝³ : DecidableEq ι\ninst✝² : (i : ι) → DecidableEq (α i)\ninst✝¹ : (i : ι) → PartialOrder (α i)\ninst✝ : (i : ι) → LocallyFiniteOrderTop (α i)\na✝ a x : (i : ι) → α i\n⊢ x ∈ (fun a ↦ piFinset fun i ↦ Ici (a i)) a ↔ a ≤ x",
"usedConstants": [
... | simp_rw [mem_piFinset, mem_Ici, le_def] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.PNat.Xgcd | {
"line": 216,
"column": 2
} | {
"line": 216,
"column": 23
} | [
{
"pp": "u : XgcdType\nhr : u.r = 0\n⊢ u.q = u.qp + 1",
"usedConstants": [
"instOfNatNat",
"dite",
"PNat.XgcdType.qp",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"instDecidableEqNat",
"OfNat.ofNat",
"Eq",
"Not",
"PNat.XgcdType.q"
... | by_cases hq : u.q = 0 | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.Data.Ordmap.Ordset | {
"line": 536,
"column": 55
} | {
"line": 537,
"column": 72
} | [
{
"pp": "α : Type u_1\ninst✝² : Preorder α\ninst✝¹ : Std.Total fun x1 x2 ↦ x1 ≤ x2\ninst✝ : DecidableLE α\nx : α\nt : Ordnode α\nh : t.Valid\n⊢ (insert' x t).Valid",
"usedConstants": [
"Ordnode.insertWith",
"Eq.mpr",
"Ordnode",
"Ordnode.insertWith.valid",
"congrArg",
"Ord... | by
rw [insert'_eq_insertWith]; exact insertWith.valid _ _ (fun _ => id) h | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Ordmap.Ordset | {
"line": 632,
"column": 6
} | {
"line": 632,
"column": 33
} | [
{
"pp": "case node.lt.succ\nα : Type u_1\ninst✝¹ : Preorder α\ninst✝ : DecidableLE α\nx : α\nsize✝ : ℕ\nt_l : Ordnode α\nt_x : α\nt_r : Ordnode α\na₁ : WithBot α\na₂ : WithTop α\nh : Valid' a₁ (node size✝ t_l t_x t_r) a₂\nh_mem : mem x t_l = true\nt_ih_l : (erase x t_l).size = t_l.size - 1\nt_l_valid : Valid' a... | · simp [Nat.add_right_comm] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Real.Sign | {
"line": 42,
"column": 37
} | {
"line": 42,
"column": 90
} | [
{
"pp": "⊢ sign 0 = 0",
"usedConstants": [
"Eq.mpr",
"Real",
"Preorder.toLT",
"lt_irrefl",
"Real.instZero",
"congrArg",
"Real.decidableLT",
"Real.instLT",
"Real.sign",
"id",
"Real.instOne",
"Real.sign.eq_1",
"LT.lt",
"Real.i... | rw [sign, if_neg (lt_irrefl _), if_neg (lt_irrefl _)] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Real.Sign | {
"line": 42,
"column": 37
} | {
"line": 42,
"column": 90
} | [
{
"pp": "⊢ sign 0 = 0",
"usedConstants": [
"Eq.mpr",
"Real",
"Preorder.toLT",
"lt_irrefl",
"Real.instZero",
"congrArg",
"Real.decidableLT",
"Real.instLT",
"Real.sign",
"id",
"Real.instOne",
"Real.sign.eq_1",
"LT.lt",
"Real.i... | rw [sign, if_neg (lt_irrefl _), if_neg (lt_irrefl _)] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Real.Sign | {
"line": 42,
"column": 37
} | {
"line": 42,
"column": 90
} | [
{
"pp": "⊢ sign 0 = 0",
"usedConstants": [
"Eq.mpr",
"Real",
"Preorder.toLT",
"lt_irrefl",
"Real.instZero",
"congrArg",
"Real.decidableLT",
"Real.instLT",
"Real.sign",
"id",
"Real.instOne",
"Real.sign.eq_1",
"LT.lt",
"Real.i... | rw [sign, if_neg (lt_irrefl _), if_neg (lt_irrefl _)] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Rat.Star | {
"line": 44,
"column": 19
} | {
"line": 44,
"column": 68
} | [
{
"pp": "a b : ℚ≥0\n⊢ a ≤ b ↔ ∃ p ∈ closure (range fun s ↦ star s * s), b = a + p",
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"AddSubmonoid.instTop",
"HMul.hMul",
"AddLeftCancelSemigroup.toIsLeftCancelAdd",
"_private.Mathlib.Data.Rat.Star.0.NNRat.instStarOrd... | simp [eq_comm, le_iff_exists_nonneg_add (a := a)] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Rat.Star | {
"line": 44,
"column": 19
} | {
"line": 44,
"column": 68
} | [
{
"pp": "a b : ℚ≥0\n⊢ a ≤ b ↔ ∃ p ∈ closure (range fun s ↦ star s * s), b = a + p",
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"AddSubmonoid.instTop",
"HMul.hMul",
"AddLeftCancelSemigroup.toIsLeftCancelAdd",
"_private.Mathlib.Data.Rat.Star.0.NNRat.instStarOrd... | simp [eq_comm, le_iff_exists_nonneg_add (a := a)] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Rat.Star | {
"line": 44,
"column": 19
} | {
"line": 44,
"column": 68
} | [
{
"pp": "a b : ℚ≥0\n⊢ a ≤ b ↔ ∃ p ∈ closure (range fun s ↦ star s * s), b = a + p",
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"AddSubmonoid.instTop",
"HMul.hMul",
"AddLeftCancelSemigroup.toIsLeftCancelAdd",
"_private.Mathlib.Data.Rat.Star.0.NNRat.instStarOrd... | simp [eq_comm, le_iff_exists_nonneg_add (a := a)] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Rat.Star | {
"line": 63,
"column": 19
} | {
"line": 63,
"column": 68
} | [
{
"pp": "a b : ℚ\n⊢ a ≤ b ↔ ∃ p ∈ closure (range fun s ↦ star s * s), b = a + p",
"usedConstants": [
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"_private.Mathlib.Data.Rat.Star.0.NNRat.instStarOrderedRing._simp_1",
"congrArg",
"instIsLeftCancelAddOfAddLeftReflectLE",
"Ad... | simp [eq_comm, le_iff_exists_nonneg_add (a := a)] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Rat.Star | {
"line": 63,
"column": 19
} | {
"line": 63,
"column": 68
} | [
{
"pp": "a b : ℚ\n⊢ a ≤ b ↔ ∃ p ∈ closure (range fun s ↦ star s * s), b = a + p",
"usedConstants": [
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"_private.Mathlib.Data.Rat.Star.0.NNRat.instStarOrderedRing._simp_1",
"congrArg",
"instIsLeftCancelAddOfAddLeftReflectLE",
"Ad... | simp [eq_comm, le_iff_exists_nonneg_add (a := a)] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Rat.Star | {
"line": 63,
"column": 19
} | {
"line": 63,
"column": 68
} | [
{
"pp": "a b : ℚ\n⊢ a ≤ b ↔ ∃ p ∈ closure (range fun s ↦ star s * s), b = a + p",
"usedConstants": [
"HMul.hMul",
"CommRing.toNonUnitalCommRing",
"_private.Mathlib.Data.Rat.Star.0.NNRat.instStarOrderedRing._simp_1",
"congrArg",
"instIsLeftCancelAddOfAddLeftReflectLE",
"Ad... | simp [eq_comm, le_iff_exists_nonneg_add (a := a)] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.WSeq.Basic | {
"line": 434,
"column": 4
} | {
"line": 443,
"column": 41
} | [
{
"pp": "case h1.cons\nα : Type u\na a' : α\ns' : WSeq α\nc : Computation (Option (α × WSeq α))\nh : some (a', s') ∈ c\nx✝ : α\ns✝ : WSeq α\nm : (cons x✝ s✝).destruct = Computation.pure (some (a', s'))\nthis : x✝ = a' ∧ s✝ = s'\n⊢ a ∈ cons x✝ s✝ ↔ a = a' ∨ a ∈ s'",
"usedConstants": [
"Eq.mpr",
"... | obtain ⟨i1, i2⟩ := this
rw [i1, i2]
dsimp only [cons, Membership.mem, WSeq.Mem, Seq.Mem, Seq.cons]
have h_a_eq_a' : a = a' ↔ some (some a) = some (some a') := by simp
rw [h_a_eq_a']
refine ⟨Stream'.eq_or_mem_of_mem_cons, fun o => ?_⟩
· rcases o with e | m
· rw [e]
apply Stream'.mem... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.WSeq.Basic | {
"line": 434,
"column": 4
} | {
"line": 443,
"column": 41
} | [
{
"pp": "case h1.cons\nα : Type u\na a' : α\ns' : WSeq α\nc : Computation (Option (α × WSeq α))\nh : some (a', s') ∈ c\nx✝ : α\ns✝ : WSeq α\nm : (cons x✝ s✝).destruct = Computation.pure (some (a', s'))\nthis : x✝ = a' ∧ s✝ = s'\n⊢ a ∈ cons x✝ s✝ ↔ a = a' ∨ a ∈ s'",
"usedConstants": [
"Eq.mpr",
"... | obtain ⟨i1, i2⟩ := this
rw [i1, i2]
dsimp only [cons, Membership.mem, WSeq.Mem, Seq.Mem, Seq.cons]
have h_a_eq_a' : a = a' ↔ some (some a) = some (some a') := by simp
rw [h_a_eq_a']
refine ⟨Stream'.eq_or_mem_of_mem_cons, fun o => ?_⟩
· rcases o with e | m
· rw [e]
apply Stream'.mem... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.WSeq.Basic | {
"line": 500,
"column": 4
} | {
"line": 500,
"column": 12
} | [
{
"pp": "case h2\nα : Type u\ns : WSeq α\na : α\nh✝ : a ∈ s\ns' : WSeq α\nn : ℕ\nh : some a ∈ s'.get? n\n⊢ ∃ n, some a ∈ s'.think.get? n",
"usedConstants": [
"Option.some",
"Membership.mem",
"Stream'.WSeq.get?",
"Computation",
"Nat",
"Stream'.WSeq.think",
"Exists.in... | exists n | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticExists_,,_1» | Lean.Parser.Tactic.«tacticExists_,,» |
Mathlib.Data.Sigma.Order | {
"line": 153,
"column": 8
} | {
"line": 153,
"column": 31
} | [
{
"pp": "case refine_1.left.right\nι : Type u_1\nα : ι → Type u_2\ninst✝¹ : Preorder ι\ninst✝ : (i : ι) → Preorder (α i)\ni✝ : ι\nb a : α i✝\nhji : i✝ < i✝\nhab : a < b\n⊢ False",
"usedConstants": [
"lt_irrefl"
]
},
{
"pp": "case refine_1.right.left\nι : Type u_1\nα : ι → Type u_2\ninst✝¹ ... | · exact lt_irrefl _ hji | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Sigma.Order | {
"line": 204,
"column": 6
} | {
"line": 206,
"column": 46
} | [
{
"pp": "case left\nι : Type u_1\nα : ι → Type u_2\ninst✝⁴ : Preorder ι\ninst✝³ : DenselyOrdered ι\ninst✝² : ∀ (i : ι), Nonempty (α i)\ninst✝¹ : (i : ι) → Preorder (α i)\ninst✝ : ∀ (i : ι), DenselyOrdered (α i)\ni : ι\na : α i\nj : ι\nb : α j\nh : i < j\n⊢ ∃ a_1, ⟨i, a⟩ < a_1 ∧ a_1 < ⟨j, b⟩",
"usedConstants... | obtain ⟨k, hi, hj⟩ := exists_between h
obtain ⟨c⟩ : Nonempty (α k) := inferInstance
exact ⟨⟨k, c⟩, left _ _ hi, left _ _ hj⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Sigma.Order | {
"line": 204,
"column": 6
} | {
"line": 206,
"column": 46
} | [
{
"pp": "case left\nι : Type u_1\nα : ι → Type u_2\ninst✝⁴ : Preorder ι\ninst✝³ : DenselyOrdered ι\ninst✝² : ∀ (i : ι), Nonempty (α i)\ninst✝¹ : (i : ι) → Preorder (α i)\ninst✝ : ∀ (i : ι), DenselyOrdered (α i)\ni : ι\na : α i\nj : ι\nb : α j\nh : i < j\n⊢ ∃ a_1, ⟨i, a⟩ < a_1 ∧ a_1 < ⟨j, b⟩",
"usedConstants... | obtain ⟨k, hi, hj⟩ := exists_between h
obtain ⟨c⟩ : Nonempty (α k) := inferInstance
exact ⟨⟨k, c⟩, left _ _ hi, left _ _ hj⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Sigma.Order | {
"line": 225,
"column": 6
} | {
"line": 226,
"column": 46
} | [
{
"pp": "case left\nι : Type u_1\nα : ι → Type u_2\ninst✝³ : Preorder ι\ninst✝² : (i : ι) → Preorder (α i)\ninst✝¹ : ∀ (i : ι), DenselyOrdered (α i)\ninst✝ : ∀ (i : ι), NoMinOrder (α i)\ni : ι\na : α i\nj : ι\nb : α j\nh : i < j\n⊢ ∃ a_1, ⟨i, a⟩ < a_1 ∧ a_1 < ⟨j, b⟩",
"usedConstants": [
"Preorder.toLT... | obtain ⟨c, hb⟩ := exists_lt b
exact ⟨⟨j, c⟩, left _ _ h, right _ _ hb⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Sigma.Order | {
"line": 225,
"column": 6
} | {
"line": 226,
"column": 46
} | [
{
"pp": "case left\nι : Type u_1\nα : ι → Type u_2\ninst✝³ : Preorder ι\ninst✝² : (i : ι) → Preorder (α i)\ninst✝¹ : ∀ (i : ι), DenselyOrdered (α i)\ninst✝ : ∀ (i : ι), NoMinOrder (α i)\ni : ι\na : α i\nj : ι\nb : α j\nh : i < j\n⊢ ∃ a_1, ⟨i, a⟩ < a_1 ∧ a_1 < ⟨j, b⟩",
"usedConstants": [
"Preorder.toLT... | obtain ⟨c, hb⟩ := exists_lt b
exact ⟨⟨j, c⟩, left _ _ h, right _ _ hb⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.String.Basic | {
"line": 101,
"column": 8
} | {
"line": 101,
"column": 57
} | [
{
"pp": "case nil.cons.ha\nc₂ : Char\ncs₂ : List Char\n⊢ (if { s := ofList (c₂ :: cs₂), i := 0 }.hasNext = true then\n if { s := ofList [], i := 0 }.hasNext = true then\n if { s := ofList [], i := 0 }.curr = { s := ofList (c₂ :: cs₂), i := 0 }.curr then\n ltb { s := ofList [], i := 0 }.next... | simp [Legacy.Iterator.hasNext, Char.utf8Size_pos] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.String.Lemmas | {
"line": 34,
"column": 12
} | {
"line": 34,
"column": 47
} | [
{
"pp": "n : ℕ\nc : Char\nx✝ : String\ns : String := x✝\n⊢ (replicate (n - x✝.length) c).IsPrefix (leftpad n c x✝)",
"usedConstants": [
"String.toList_ofList",
"String.replicate",
"List.replicate",
"congrArg",
"String",
"String.length_toList",
"HSub.hSub",
"St... | simp [leftpad, IsPrefix, replicate] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.String.Lemmas | {
"line": 34,
"column": 12
} | {
"line": 34,
"column": 47
} | [
{
"pp": "n : ℕ\nc : Char\nx✝ : String\ns : String := x✝\n⊢ (replicate (n - x✝.length) c).IsPrefix (leftpad n c x✝)",
"usedConstants": [
"String.toList_ofList",
"String.replicate",
"List.replicate",
"congrArg",
"String",
"String.length_toList",
"HSub.hSub",
"St... | simp [leftpad, IsPrefix, replicate] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.String.Lemmas | {
"line": 34,
"column": 12
} | {
"line": 34,
"column": 47
} | [
{
"pp": "n : ℕ\nc : Char\nx✝ : String\ns : String := x✝\n⊢ (replicate (n - x✝.length) c).IsPrefix (leftpad n c x✝)",
"usedConstants": [
"String.toList_ofList",
"String.replicate",
"List.replicate",
"congrArg",
"String",
"String.length_toList",
"HSub.hSub",
"St... | simp [leftpad, IsPrefix, replicate] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Vector.Snoc | {
"line": 128,
"column": 2
} | {
"line": 128,
"column": 14
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nn : ℕ\nx : α\nxs : Vector α n\nf : α → β\n⊢ map f (xs.snoc x) = (map f xs).snoc (f x)",
"usedConstants": [
"List.Vector.map",
"List.Vector",
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"List.Vector.snoc",
... | induction xs | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.Vector.Snoc | {
"line": 140,
"column": 2
} | {
"line": 140,
"column": 14
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nσ : Type u_3\nn : ℕ\nx : α\nxs : Vector α n\nf : α → σ → σ × β\ns : σ\n⊢ mapAccumr f (xs.snoc x) s =\n let q := f x s;\n let r := mapAccumr f xs q.1;\n (r.1, r.2.snoc q.2)",
"usedConstants": [
"List.Vector.mapAccumr",
"List.Vector",
"Prod.mk",
... | induction xs | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.Vector.Mem | {
"line": 44,
"column": 6
} | {
"line": 44,
"column": 25
} | [
{
"pp": "α : Type u_1\nn : ℕ\na a' : α\nv : Vector α n\n⊢ a' ∈ (a ::ᵥ v).toList ↔ a' = a ∨ a' ∈ v.toList",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Membership.mem",
"id",
"List.Vector.toList_cons",
"List.cons",
"List",
"Iff",
"List.instMembership",
... | Vector.toList_cons, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Vector.MapLemmas | {
"line": 56,
"column": 2
} | {
"line": 56,
"column": 14
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nn : ℕ\nxs : Vector α n\nf₁ : β → γ\nf₂ : α → β\n⊢ map f₁ (map f₂ xs) = map (fun x ↦ f₁ (f₂ x)) xs",
"usedConstants": [
"List.Vector.map",
"List.Vector",
"Nat",
"Eq",
"List.Vector.inductionOn"
]
}
] | induction xs | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.Vector.MapLemmas | {
"line": 60,
"column": 2
} | {
"line": 60,
"column": 14
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nn : ℕ\nxs : Vector α n\np : α → Prop\nf₁ : β → γ\nf₂ : (a : α) → p a → β\nH : ∀ (x : α), x ∈ xs.toList → p x\n⊢ map f₁ (pmap f₂ xs H) = pmap (fun x hx ↦ f₁ (f₂ x hx)) xs H",
"usedConstants": [
"List.Vector.pmap",
"List.Vector.map",
"List.V... | induction xs | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.Vector.MapLemmas | {
"line": 65,
"column": 2
} | {
"line": 65,
"column": 14
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nn : ℕ\nxs : Vector α n\np : β → Prop\nf₁ : (b : β) → p b → γ\nf₂ : α → β\nH : ∀ (x : β), x ∈ (map f₂ xs).toList → p x\n⊢ pmap f₁ (map f₂ xs) H = pmap (fun x hx ↦ f₁ (f₂ x) hx) xs ⋯",
"usedConstants": [
"List.Vector.pmap",
"List.Vector.map",
... | induction xs | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.Sum.Interval | {
"line": 175,
"column": 2
} | {
"line": 177,
"column": 31
} | [
{
"pp": "α₁ : Type u_1\nα₂ : Type u_2\nβ₁ : Type u_3\nβ₂ : Type u_4\nγ₁ : Type u_5\nγ₂ : Type u_6\nf₁ f₁' : α₁ → β₁ → Finset γ₁\nf₂ f₂' : α₂ → β₂ → Finset γ₂\ng₁ g₁' : α₁ → β₂ → Finset γ₁\ng₂ g₂' : α₁ → β₂ → Finset γ₂\nhf₁ : ∀ (a : α₁) (b : β₁), f₁ a b ⊆ f₁' a b\nhf₂ : ∀ (a : α₂) (b : β₂), f₂ a b ⊆ f₂' a b\nhg₁... | cases a <;> cases b
exacts [map_subset_map.2 (hf₁ _ _), disjSum_mono (hg₁ _ _) (hg₂ _ _), Subset.rfl,
map_subset_map.2 (hf₂ _ _)] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Sum.Interval | {
"line": 175,
"column": 2
} | {
"line": 177,
"column": 31
} | [
{
"pp": "α₁ : Type u_1\nα₂ : Type u_2\nβ₁ : Type u_3\nβ₂ : Type u_4\nγ₁ : Type u_5\nγ₂ : Type u_6\nf₁ f₁' : α₁ → β₁ → Finset γ₁\nf₂ f₂' : α₂ → β₂ → Finset γ₂\ng₁ g₁' : α₁ → β₂ → Finset γ₁\ng₂ g₂' : α₁ → β₂ → Finset γ₂\nhf₁ : ∀ (a : α₁) (b : β₁), f₁ a b ⊆ f₁' a b\nhf₂ : ∀ (a : α₂) (b : β₂), f₂ a b ⊆ f₂' a b\nhg₁... | cases a <;> cases b
exacts [map_subset_map.2 (hf₁ _ _), disjSum_mono (hg₁ _ _) (hg₂ _ _), Subset.rfl,
map_subset_map.2 (hf₂ _ _)] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Sum.Interval | {
"line": 186,
"column": 4
} | {
"line": 186,
"column": 50
} | [
{
"pp": "case refine_2\nα₁ : Type u_1\nα₂ : Type u_2\nβ₁ : Type u_3\nβ₂ : Type u_4\nγ₁ : Type u_5\nγ₂ : Type u_6\nf₁ : α₁ → β₁ → Finset γ₁\nf₂ : α₂ → β₂ → Finset γ₂\ng₁ : α₁ → β₂ → Finset γ₁\ng₂ : α₁ → β₂ → Finset γ₂\na : α₁ ⊕ α₂\nb : β₁ ⊕ β₂\nh : sumLexLift f₁ f₂ g₁ g₂ a b = ∅\n⊢ ∀ (a₁ : α₁) (b₂ : β₂), a = inl... | rintro a b rfl rfl; exact disjSum_eq_empty.1 h | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Sum.Interval | {
"line": 186,
"column": 4
} | {
"line": 186,
"column": 50
} | [
{
"pp": "case refine_2\nα₁ : Type u_1\nα₂ : Type u_2\nβ₁ : Type u_3\nβ₂ : Type u_4\nγ₁ : Type u_5\nγ₂ : Type u_6\nf₁ : α₁ → β₁ → Finset γ₁\nf₂ : α₂ → β₂ → Finset γ₂\ng₁ : α₁ → β₂ → Finset γ₁\ng₂ : α₁ → β₂ → Finset γ₂\na : α₁ ⊕ α₂\nb : β₁ ⊕ β₂\nh : sumLexLift f₁ f₂ g₁ g₂ a b = ∅\n⊢ ∀ (a₁ : α₁) (b₂ : β₂), a = inl... | rintro a b rfl rfl; exact disjSum_eq_empty.1 h | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Sum.Interval | {
"line": 191,
"column": 4
} | {
"line": 191,
"column": 44
} | [
{
"pp": "case refine_4.inr.inr\nα₁ : Type u_1\nα₂ : Type u_2\nβ₁ : Type u_3\nβ₂ : Type u_4\nγ₁ : Type u_5\nγ₂ : Type u_6\nf₁ : α₁ → β₁ → Finset γ₁\nf₂ : α₂ → β₂ → Finset γ₂\ng₁ : α₁ → β₂ → Finset γ₁\ng₂ : α₁ → β₂ → Finset γ₂\nval✝¹ : α₂\nval✝ : β₂\nh :\n (∀ (a₁ : α₁) (b₁ : β₁), inr val✝¹ = inl a₁ → inr val✝ = ... | exact map_eq_empty.2 (h.2.2 _ _ rfl rfl) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Sum.Interval | {
"line": 191,
"column": 4
} | {
"line": 191,
"column": 44
} | [
{
"pp": "case refine_4.inr.inr\nα₁ : Type u_1\nα₂ : Type u_2\nβ₁ : Type u_3\nβ₂ : Type u_4\nγ₁ : Type u_5\nγ₂ : Type u_6\nf₁ : α₁ → β₁ → Finset γ₁\nf₂ : α₂ → β₂ → Finset γ₂\ng₁ : α₁ → β₂ → Finset γ₁\ng₂ : α₁ → β₂ → Finset γ₂\nval✝¹ : α₂\nval✝ : β₂\nh :\n (∀ (a₁ : α₁) (b₁ : β₁), inr val✝¹ = inl a₁ → inr val✝ = ... | exact map_eq_empty.2 (h.2.2 _ _ rfl rfl) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Sum.Interval | {
"line": 191,
"column": 4
} | {
"line": 191,
"column": 44
} | [
{
"pp": "case refine_4.inr.inr\nα₁ : Type u_1\nα₂ : Type u_2\nβ₁ : Type u_3\nβ₂ : Type u_4\nγ₁ : Type u_5\nγ₂ : Type u_6\nf₁ : α₁ → β₁ → Finset γ₁\nf₂ : α₂ → β₂ → Finset γ₂\ng₁ : α₁ → β₂ → Finset γ₁\ng₂ : α₁ → β₂ → Finset γ₂\nval✝¹ : α₂\nval✝ : β₂\nh :\n (∀ (a₁ : α₁) (b₁ : β₁), inr val✝¹ = inl a₁ → inr val✝ = ... | exact map_eq_empty.2 (h.2.2 _ _ rfl rfl) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | {
"line": 569,
"column": 4
} | {
"line": 570,
"column": 59
} | [
{
"pp": "f : CircleDeg1Lift\nτ' : ℝ\nh : Tendsto (fun n ↦ (⇑f)^[n] 0 / ↑n) atTop (𝓝 τ')\n⊢ Tendsto f.transnumAuxSeq atTop (𝓝 τ')",
"usedConstants": [
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Real",
"instHDiv",
"Nat.instIsOrd... | simpa [Function.comp_def, transnumAuxSeq_def, coe_pow] using
h.comp (tendsto_pow_atTop_atTop_of_one_lt one_lt_two) | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | {
"line": 569,
"column": 4
} | {
"line": 570,
"column": 59
} | [
{
"pp": "f : CircleDeg1Lift\nτ' : ℝ\nh : Tendsto (fun n ↦ (⇑f)^[n] 0 / ↑n) atTop (𝓝 τ')\n⊢ Tendsto f.transnumAuxSeq atTop (𝓝 τ')",
"usedConstants": [
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Real",
"instHDiv",
"Nat.instIsOrd... | simpa [Function.comp_def, transnumAuxSeq_def, coe_pow] using
h.comp (tendsto_pow_atTop_atTop_of_one_lt one_lt_two) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | {
"line": 569,
"column": 4
} | {
"line": 570,
"column": 59
} | [
{
"pp": "f : CircleDeg1Lift\nτ' : ℝ\nh : Tendsto (fun n ↦ (⇑f)^[n] 0 / ↑n) atTop (𝓝 τ')\n⊢ Tendsto f.transnumAuxSeq atTop (𝓝 τ')",
"usedConstants": [
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Real",
"instHDiv",
"Nat.instIsOrd... | simpa [Function.comp_def, transnumAuxSeq_def, coe_pow] using
h.comp (tendsto_pow_atTop_atTop_of_one_lt one_lt_two) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Order.CountableSeparating | {
"line": 36,
"column": 4
} | {
"line": 36,
"column": 46
} | [
{
"pp": "case exists_countable_separating.refine_1\nX : Type u_1\ninst✝³ : TopologicalSpace X\ninst✝² : LinearOrder X\ninst✝¹ : OrderTopology X\ninst✝ : SecondCountableTopology X\ns✝ s : Set X\nhsc : s.Countable\nhsd : Dense s\nt : Set X := s ∪ {x | ∃ y, y ⋖ x}\n⊢ t.Countable",
"usedConstants": [
"Pre... | exact hsc.union countable_setOf_covBy_left | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Topology.Order.CountableSeparating | {
"line": 36,
"column": 4
} | {
"line": 36,
"column": 46
} | [
{
"pp": "case exists_countable_separating.refine_1\nX : Type u_1\ninst✝³ : TopologicalSpace X\ninst✝² : LinearOrder X\ninst✝¹ : OrderTopology X\ninst✝ : SecondCountableTopology X\ns✝ s : Set X\nhsc : s.Countable\nhsd : Dense s\nt : Set X := s ∪ {x | ∃ y, y ⋖ x}\n⊢ t.Countable",
"usedConstants": [
"Pre... | exact hsc.union countable_setOf_covBy_left | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Order.CountableSeparating | {
"line": 36,
"column": 4
} | {
"line": 36,
"column": 46
} | [
{
"pp": "case exists_countable_separating.refine_1\nX : Type u_1\ninst✝³ : TopologicalSpace X\ninst✝² : LinearOrder X\ninst✝¹ : OrderTopology X\ninst✝ : SecondCountableTopology X\ns✝ s : Set X\nhsc : s.Countable\nhsd : Dense s\nt : Set X := s ∪ {x | ∃ y, y ⋖ x}\n⊢ t.Countable",
"usedConstants": [
"Pre... | exact hsc.union countable_setOf_covBy_left | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Order.CountableSeparating | {
"line": 41,
"column": 6
} | {
"line": 41,
"column": 65
} | [
{
"pp": "case exists_countable_separating.refine_3.inr\nX : Type u_1\ninst✝³ : TopologicalSpace X\ninst✝² : LinearOrder X\ninst✝¹ : OrderTopology X\ninst✝ : SecondCountableTopology X\ns✝ s : Set X\nhsc : s.Countable\nhsd : Dense s\nt : Set X := s ∪ {x | ∃ y, y ⋖ x}\nx y : X\nh : ∀ s ∈ Iio '' t, x ∈ s ↔ y ∈ s\nh... | refine this y x ?_ hne.symm (hne.lt_or_gt.resolve_left hlt) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 97,
"column": 2
} | {
"line": 102,
"column": 100
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\nf : α → ℝ≥0∞\nμ ν : Measure α\ninst✝¹ : SigmaFinite μ\ninst✝ : SigmaFinite ν\nhf_ne_top : ∀ᵐ (x : α) ∂μ, f x ≠ ∞\n⊢ ((ν.withDensity (μ.rnDeriv ν)).withDensity f).rnDeriv ν =ᶠ[ae ν] (μ.withDensity f).rnDeriv ν",
"usedConstants": [
"MeasureTheory.ae",
... | conv_rhs => rw [μ.haveLebesgueDecomposition_add ν, add_comm, withDensity_add_measure]
have : SigmaFinite ((μ.singularPart ν).withDensity f) :=
SigmaFinite.withDensity_of_ne_top (ae_mono (Measure.singularPart_le _ _) hf_ne_top)
have : SigmaFinite ((ν.withDensity (μ.rnDeriv ν)).withDensity f) :=
SigmaFinite.w... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 97,
"column": 2
} | {
"line": 102,
"column": 100
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\nf : α → ℝ≥0∞\nμ ν : Measure α\ninst✝¹ : SigmaFinite μ\ninst✝ : SigmaFinite ν\nhf_ne_top : ∀ᵐ (x : α) ∂μ, f x ≠ ∞\n⊢ ((ν.withDensity (μ.rnDeriv ν)).withDensity f).rnDeriv ν =ᶠ[ae ν] (μ.withDensity f).rnDeriv ν",
"usedConstants": [
"MeasureTheory.ae",
... | conv_rhs => rw [μ.haveLebesgueDecomposition_add ν, add_comm, withDensity_add_measure]
have : SigmaFinite ((μ.singularPart ν).withDensity f) :=
SigmaFinite.withDensity_of_ne_top (ae_mono (Measure.singularPart_le _ _) hf_ne_top)
have : SigmaFinite ((ν.withDensity (μ.rnDeriv ν)).withDensity f) :=
SigmaFinite.w... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 358,
"column": 4
} | {
"line": 358,
"column": 63
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\nμ ν : Measure α\ninst✝¹ : SigmaFinite μ\ninst✝ : SFinite ν\ns : Set α\n⊢ (∫⁻ (a : α) in s, μ.rnDeriv ν a ∂ν).toReal = ((ν.withDensity (μ.rnDeriv ν)) s).toReal",
"usedConstants": [
"Eq.mpr",
"MeasureTheory.Measure.withDensity",
"Real",
"Me... | rw [ENNReal.toReal_eq_toReal_iff, ← withDensity_apply' _ s] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Dynamics.TopologicalEntropy.DynamicalEntourage | {
"line": 74,
"column": 4
} | {
"line": 74,
"column": 29
} | [
{
"pp": "case succ\nX : Type u_1\nT : X → X\nU : SetRel X X\ninst✝ : UniformSpace X\nh : UniformContinuous T\nU_uni : U ∈ 𝓤 X\nn : ℕ\nih : ⋂ i, ⋂ (_ : i < n), (map T T)^[i] ⁻¹' U ∈ 𝓤 X\n⊢ (⋂ k, ⋂ (_ : k < n), (map T T)^[k] ⁻¹' U) ∩ (map T T)^[n] ⁻¹' U ∈ 𝓤 X",
"usedConstants": [
"Preorder.toLT",
... | apply Filter.inter_mem ih | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 527,
"column": 2
} | {
"line": 527,
"column": 38
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nm : MeasurableSpace α\nmβ : MeasurableSpace β\nf : α → β\nhf : MeasurableEmbedding f\nμ ν : Measure α\ninst✝¹ : SigmaFinite μ\ninst✝ : SigmaFinite ν\nthis✝¹ : SigmaFinite (map f ν)\nthis✝ : SigmaFinite (map f (μ.singularPart ν))\nthis : SigmaFinite (map f (ν.withDensity (μ.r... | refine Filter.EventuallyEq.add ?_ ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Dynamics.TopologicalEntropy.CoverEntropy | {
"line": 226,
"column": 2
} | {
"line": 226,
"column": 59
} | [
{
"pp": "X : Type u_1\nT : X → X\nF : Set X\nU : SetRel X X\nn : ℕ\nh_fin : coverMincard T F U n < ⊤\n⊢ ∃ s, IsDynCoverOf T F U n ↑s ∧ ↑(#s) = coverMincard T F U n",
"usedConstants": [
"instTopENat",
"Exists",
"instPreorderENat",
"Ne",
"WithTop.ne_top_iff_exists",
"WithTo... | obtain ⟨k, k_min⟩ := WithTop.ne_top_iff_exists.1 h_fin.ne | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Dynamics.TopologicalEntropy.NetEntropy | {
"line": 361,
"column": 6
} | {
"line": 361,
"column": 56
} | [
{
"pp": "X : Type u_1\ninst✝ : UniformSpace X\nι : Sort u_2\np : ι → Prop\ns : ι → SetRel X X\nh : (𝓤 X).HasBasis p s\nT : X → X\nF : Set X\n⊢ coverEntropyInf T F = ⨆ i, ⨆ (_ : p i), netEntropyInfEntourage T F (s i)",
"usedConstants": [
"Filter.instMembership",
"Eq.mpr",
"congrArg",
... | coverEntropyInf_eq_iSup_netEntropyInfEntourage T F | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Algebraic.Cardinality | {
"line": 65,
"column": 55
} | {
"line": 66,
"column": 68
} | [
{
"pp": "R : Type u\ninst✝⁶ : CommRing R\ninst✝⁵ : IsDomain R\nL : Type u\ninst✝⁴ : CommRing L\ninst✝³ : IsDomain L\ninst✝² : Algebra R L\ninst✝¹ : IsTorsionFree R L\ninst✝ : Algebra.IsAlgebraic R L\n⊢ #L ≤ #((p : R[X]) × { x // x ∈ p.aroots L })",
"usedConstants": [
"Cardinal",
"congrArg",
... | by
simpa only [lift_id] using lift_cardinalMk_le_sigma_polynomial R L | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.FieldTheory.AbelRuffini | {
"line": 105,
"column": 2
} | {
"line": 106,
"column": 68
} | [
{
"pp": "case neg\nF : Type u_1\ninst✝ : Field F\nn : ℕ\na : F\nh : (map (RingHom.id F) (X ^ n - 1)).Splits\nha : ¬a = 0\n⊢ IsSolvable (X ^ n - C a).Gal",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Polynomial.C",
"RingHom.instRingHomClass",
"RingHomClass.toAddMonoidHomClass"... | have ha' : algebraMap F (X ^ n - C a).SplittingField a ≠ 0 :=
mt ((injective_iff_map_eq_zero _).mp (RingHom.injective _) a) ha | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.ModelTheory.LanguageMap | {
"line": 312,
"column": 55
} | {
"line": 312,
"column": 67
} | [
{
"pp": "L : Language\nL' : Language\nM : Type w\ninst✝ : L.Structure M\nL'' : Language\ne'✝ : L' ≃ᴸ L''\ne✝ e : L ≃ᴸ L'\ne' : L' ≃ᴸ L''\n⊢ e.invLHom.comp ((e'.invLHom.comp e'.toLHom).comp e.toLHom) = LHom.id L",
"usedConstants": [
"Eq.mpr",
"FirstOrder.Language.LHom.comp",
"congrArg",
... | e'.left_inv, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.ModelTheory.LanguageMap | {
"line": 446,
"column": 78
} | {
"line": 446,
"column": 89
} | [
{
"pp": "L : Language\nα : Type w'\nβ : Type u_1\nf : α → β\n⊢ (L.lhomWithConstantsMap f).comp LHom.sumInl = L.lhomWithConstants β",
"usedConstants": [
"FirstOrder.Language.LHom.onRelation",
"FirstOrder.Language.LHom.comp",
"FirstOrder.Language.LHom.funext",
"FirstOrder.Language.with... | ext <;> rfl | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.ModelTheory.LanguageMap | {
"line": 446,
"column": 78
} | {
"line": 446,
"column": 89
} | [
{
"pp": "L : Language\nα : Type w'\nβ : Type u_1\nf : α → β\n⊢ (L.lhomWithConstantsMap f).comp LHom.sumInl = L.lhomWithConstants β",
"usedConstants": [
"FirstOrder.Language.LHom.onRelation",
"FirstOrder.Language.LHom.comp",
"FirstOrder.Language.LHom.funext",
"FirstOrder.Language.with... | ext <;> rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.ModelTheory.LanguageMap | {
"line": 446,
"column": 78
} | {
"line": 446,
"column": 89
} | [
{
"pp": "L : Language\nα : Type w'\nβ : Type u_1\nf : α → β\n⊢ (L.lhomWithConstantsMap f).comp LHom.sumInl = L.lhomWithConstants β",
"usedConstants": [
"FirstOrder.Language.LHom.onRelation",
"FirstOrder.Language.LHom.comp",
"FirstOrder.Language.LHom.funext",
"FirstOrder.Language.with... | ext <;> rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.FieldTheory.AbelRuffini | {
"line": 179,
"column": 4
} | {
"line": 179,
"column": 26
} | [
{
"pp": "case pos\nF : Type u_1\ninst✝ : Field F\nn : ℕ\nx : F\nhx : x = 0\n⊢ IsSolvable (X ^ n - C x).Gal",
"usedConstants": [
"Eq.mpr",
"Polynomial.C",
"IsSolvable",
"Polynomial.Gal",
"congrArg",
"sub_zero",
"Polynomial.C_0",
"HSub.hSub",
"RingHom",
... | rw [hx, C_0, sub_zero] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.ModelTheory.Ultraproducts | {
"line": 91,
"column": 21
} | {
"line": 91,
"column": 56
} | [
{
"pp": "case h.e'_3.h.e'_3.h.func\nα : Type u_1\nM : α → Type u_2\nu : Ultrafilter α\nL : Language\ninst✝ : (a : α) → L.Structure (M a)\nβ : Type u_3\nx : β → (a : α) → M a\na : α\nl✝ : ℕ\n_f✝ : L.Functions l✝\n_ts✝ : Fin l✝ → L.Term β\nt_ih : ∀ (a_1 : Fin l✝), Term.realize (fun i ↦ x i a) (_ts✝ a_1) = Term.re... | simp only [Term.realize, t_ih]; rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.ModelTheory.Ultraproducts | {
"line": 91,
"column": 21
} | {
"line": 91,
"column": 56
} | [
{
"pp": "case h.e'_3.h.e'_3.h.func\nα : Type u_1\nM : α → Type u_2\nu : Ultrafilter α\nL : Language\ninst✝ : (a : α) → L.Structure (M a)\nβ : Type u_3\nx : β → (a : α) → M a\na : α\nl✝ : ℕ\n_f✝ : L.Functions l✝\n_ts✝ : Fin l✝ → L.Term β\nt_ih : ∀ (a_1 : Fin l✝), Term.realize (fun i ↦ x i a) (_ts✝ a_1) = Term.re... | simp only [Term.realize, t_ih]; rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.ModelTheory.Semantics | {
"line": 490,
"column": 2
} | {
"line": 490,
"column": 33
} | [
{
"pp": "L : Language\nM : Type w\ninst✝ : L.Structure M\nα : Type u'\nβ : Type v'\ng : α ≃ β\nk : ℕ\nφ : L.BoundedFormula α k\nv : β → M\nxs✝ : Fin k → M\nn : ℕ\nt : L.Term (α ⊕ Fin n)\nxs : Fin n → M\n⊢ realize (Sum.elim v xs ∘ ⇑(g.sumCongr (_root_.Equiv.refl (Fin n)))) t = realize (Sum.elim (v ∘ ⇑g) xs) t",
... | refine congr (congr rfl ?_) rfl | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.ModelTheory.Encoding | {
"line": 233,
"column": 4
} | {
"line": 233,
"column": 15
} | [
{
"pp": "case equal.hc\nL : Language\nα : Type u'\nl✝ : List ((n : ℕ) × L.BoundedFormula α n)\nn n✝ : ℕ\nt₁✝ t₂✝ : L.Term (α ⊕ Fin n✝)\nl : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)\n⊢ ⟨n✝, equal t₁✝ t₂✝⟩.fst = ⟨n✝, equal t₁✝ t₂✝⟩.fst",
"usedConstants": [
"Nat",
"eq_self"... | · simp only | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.ModelTheory.Definability | {
"line": 129,
"column": 4
} | {
"line": 131,
"column": 24
} | [
{
"pp": "M : Type w\nA : Set M\nL : Language\ninst✝ : L.Structure M\nα : Type u₁\nι : Type u_2\nf : ι → Set (α → M)\nhf : ∀ (i : ι), A.Definable L (f i)\ns : Finset ι\n⊢ A.Definable L (s.inf f)",
"usedConstants": [
"Eq.mpr",
"Set.Definable.inter",
"Set.Definable",
"congrArg",
"... | refine Finset.induction definable_univ (fun i s _ h => ?_) s
rw [Finset.inf_insert]
exact (hf i).inter h | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.ModelTheory.Definability | {
"line": 129,
"column": 4
} | {
"line": 131,
"column": 24
} | [
{
"pp": "M : Type w\nA : Set M\nL : Language\ninst✝ : L.Structure M\nα : Type u₁\nι : Type u_2\nf : ι → Set (α → M)\nhf : ∀ (i : ι), A.Definable L (f i)\ns : Finset ι\n⊢ A.Definable L (s.inf f)",
"usedConstants": [
"Eq.mpr",
"Set.Definable.inter",
"Set.Definable",
"congrArg",
"... | refine Finset.induction definable_univ (fun i s _ h => ?_) s
rw [Finset.inf_insert]
exact (hf i).inter h | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.ModelTheory.Semantics | {
"line": 920,
"column": 27
} | {
"line": 920,
"column": 50
} | [
{
"pp": "case imp\nL : Language\nM : Type w\nN : Type u_1\ninst✝³ : L.Structure M\ninst✝² : L.Structure N\nα : Type u'\nn : ℕ\nF : Type u_4\ninst✝¹ : EquivLike F M N\ninst✝ : L.StrongHomClass F M N\ng : F\nv : α → M\nn✝ : ℕ\nf₁✝ f₂✝ : L.BoundedFormula α n✝\nih1 : ∀ {xs : Fin n✝ → M}, f₁✝.Realize (⇑g ∘ v) (⇑g ∘ ... | BoundedFormula.Realize, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.ModelTheory.Semantics | {
"line": 922,
"column": 8
} | {
"line": 922,
"column": 31
} | [
{
"pp": "case all\nL : Language\nM : Type w\nN : Type u_1\ninst✝³ : L.Structure M\ninst✝² : L.Structure N\nα : Type u'\nn : ℕ\nF : Type u_4\ninst✝¹ : EquivLike F M N\ninst✝ : L.StrongHomClass F M N\ng : F\nv : α → M\nn✝ : ℕ\nf✝ : L.BoundedFormula α (n✝ + 1)\nih3 : ∀ {xs : Fin (n✝ + 1) → M}, f✝.Realize (⇑g ∘ v) ... | BoundedFormula.Realize, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.ModelTheory.Semantics | {
"line": 1034,
"column": 2
} | {
"line": 1036,
"column": 43
} | [
{
"pp": "case refine_2\nL : Language\nα : Type u'\nM : Type w\ninst✝ : L[[α]].Structure M\ns : Set α\n⊢ Set.InjOn (fun i ↦ ↑(L.con i)) s →\n ∀ (φ : L[[α]].Sentence) (x x_1 : α),\n (x, x_1) ∈ s ×ˢ s ∩ (Set.diagonal α)ᶜ → ((L.con x).term.equal (L.con x_1).term).not = φ → M ⊨ φ",
"usedConstants": [
... | · rintro h φ a b ⟨⟨as, bs⟩, ab⟩ rfl
simp only [Sentence.Realize, Formula.realize_not, Formula.realize_equal, Term.realize_constants]
exact fun contra => ab (h as bs contra) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.ModelTheory.Definability | {
"line": 667,
"column": 2
} | {
"line": 667,
"column": 62
} | [
{
"pp": "case h.h\nM : Type w\nA : Set M\nL : Language\ninst✝ : L.Structure M\nf : M → M\nh✝ : TermDefinable₁ L f\nt : L[[↑A]].Formula (Option Unit)\nh : (Function.tupleGraph fun v ↦ f (v ())) = setOf t.Realize\nv : Fin 2 → M\n⊢ v ∈ {x | (x 0, x 1) ∈ Function.graph f} ↔ v ∈ setOf (Formula.relabel (fun x ↦ x.eli... | convert! Set.ext_iff.1 h (v ∘ (Option.elim · 1 (fun _ ↦ 0))) | Mathlib.Tactic._aux_Mathlib_Tactic_Convert___macroRules_Mathlib_Tactic_convert!_1 | Mathlib.Tactic.convert! |
Mathlib.SetTheory.Cardinal.Divisibility | {
"line": 126,
"column": 2
} | {
"line": 126,
"column": 25
} | [
{
"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\nhn : ↑n ≠ 0\nthis :\n ∀ {n : ℕ},\n (∀ (a b : ℕ), n ∣ a * b → n ∣ a ∨ n ∣ b) →\n ∀ (b c : Cardinal.{u_1}),\n ↑n ∣ b * c → ℵ₀ ≤ b * c ... | · rwa [mul_comm] at hbc | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.SetTheory.Cardinal.Divisibility | {
"line": 138,
"column": 4
} | {
"line": 138,
"column": 47
} | [
{
"pp": "case pos\na : Cardinal.{u_1}\nh : ℵ₀ ≤ a\n⊢ IsPrimePow a ↔ ℵ₀ ≤ a ∨ ∃ n, a = ↑n ∧ IsPrimePow n",
"usedConstants": [
"Cardinal",
"congrArg",
"true_or",
"IsPrimePow",
"Exists",
"Cardinal.aleph0",
"LE.le",
"Nat.cast",
"Cardinal.instLE",
"iff_... | simp [h, (prime_of_aleph0_le h).isPrimePow] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.SetTheory.Cardinal.Divisibility | {
"line": 138,
"column": 4
} | {
"line": 138,
"column": 47
} | [
{
"pp": "case pos\na : Cardinal.{u_1}\nh : ℵ₀ ≤ a\n⊢ IsPrimePow a ↔ ℵ₀ ≤ a ∨ ∃ n, a = ↑n ∧ IsPrimePow n",
"usedConstants": [
"Cardinal",
"congrArg",
"true_or",
"IsPrimePow",
"Exists",
"Cardinal.aleph0",
"LE.le",
"Nat.cast",
"Cardinal.instLE",
"iff_... | simp [h, (prime_of_aleph0_le h).isPrimePow] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.SetTheory.Cardinal.Divisibility | {
"line": 138,
"column": 4
} | {
"line": 138,
"column": 47
} | [
{
"pp": "case pos\na : Cardinal.{u_1}\nh : ℵ₀ ≤ a\n⊢ IsPrimePow a ↔ ℵ₀ ≤ a ∨ ∃ n, a = ↑n ∧ IsPrimePow n",
"usedConstants": [
"Cardinal",
"congrArg",
"true_or",
"IsPrimePow",
"Exists",
"Cardinal.aleph0",
"LE.le",
"Nat.cast",
"Cardinal.instLE",
"iff_... | simp [h, (prime_of_aleph0_le h).isPrimePow] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.FieldTheory.Differential.Liouville | {
"line": 72,
"column": 8
} | {
"line": 72,
"column": 54
} | [
{
"pp": "F : Type u_1\nK : Type u_2\ninst✝¹² : Field F\ninst✝¹¹ : Field K\ninst✝¹⁰ : Differential F\ninst✝⁹ : Differential K\ninst✝⁸ : Algebra F K\ninst✝⁷ : DifferentialAlgebra F K\nA : Type u_3\ninst✝⁶ : Field A\ninst✝⁵ : Algebra K A\ninst✝⁴ : Algebra F A\ninst✝³ : Differential A\ninst✝² : IsScalarTower F K A\... | simp only [coe_deriv, hc, algebraMap.coe_zero] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.FieldTheory.Finite.Polynomial | {
"line": 136,
"column": 4
} | {
"line": 136,
"column": 31
} | [
{
"pp": "case intro.refine_2.h\nK : Type u_1\nσ : Type u_2\ninst✝² : Field K\ninst✝¹ : Fintype K\ninst✝ : Finite σ\nval✝ : Fintype σ\ne : (σ → K) → K\nx✝ : e ∈ ⊤\nn : σ → K\n⊢ ∑ x, e x * (eval n) (indicator x) = e n",
"usedConstants": [
"Finsupp.instAddZeroClass",
"Eq.mpr",
"Nat.instMulZer... | rw [Finset.sum_eq_single n] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.FieldTheory.Finite.Polynomial | {
"line": 218,
"column": 42
} | {
"line": 218,
"column": 51
} | [
{
"pp": "case intro\nσ K : Type u\ninst✝² : Fintype K\ninst✝¹ : Field K\ninst✝ : Finite σ\nval✝ : Fintype σ\n⊢ Module.finrank K (R σ K) = Fintype.card (σ → K)",
"usedConstants": [
"Eq.mpr",
"congrArg",
"AddCommGroup.toAddCommMonoid",
"Pi.instFintype",
"Classical.propDecidable",... | finrank_R | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Localization.NormTrace | {
"line": 68,
"column": 2
} | {
"line": 68,
"column": 38
} | [
{
"pp": "case inr\nR : Type u_1\nS : Type u_2\ninst✝¹⁴ : CommRing R\ninst✝¹³ : CommRing S\ninst✝¹² : Algebra R S\nRₘ : Type u_3\nSₘ : Type u_4\ninst✝¹¹ : CommRing Rₘ\ninst✝¹⁰ : Algebra R Rₘ\ninst✝⁹ : CommRing Sₘ\ninst✝⁸ : Algebra S Sₘ\nM : Submonoid R\ninst✝⁷ : IsLocalization M Rₘ\ninst✝⁶ : IsLocalization (alge... | let b := Module.Free.chooseBasis R S | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.RingTheory.Localization.NormTrace | {
"line": 89,
"column": 2
} | {
"line": 89,
"column": 38
} | [
{
"pp": "case inr\nR : Type u_1\nS : Type u_2\ninst✝¹⁴ : CommRing R\ninst✝¹³ : CommRing S\ninst✝¹² : Algebra R S\nRₘ : Type u_3\nSₘ : Type u_4\ninst✝¹¹ : CommRing Rₘ\ninst✝¹⁰ : Algebra R Rₘ\ninst✝⁹ : CommRing Sₘ\ninst✝⁸ : Algebra S Sₘ\nM : Submonoid R\ninst✝⁷ : IsLocalization M Rₘ\ninst✝⁶ : IsLocalization (alge... | let b := Module.Free.chooseBasis R S | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.RingTheory.Discriminant | {
"line": 287,
"column": 4
} | {
"line": 287,
"column": 58
} | [
{
"pp": "case pos\nK : Type u\nL : Type v\ninst✝¹⁰ : Field K\ninst✝⁹ : Field L\ninst✝⁸ : Algebra K L\ninst✝⁷ : Module.Finite K L\nR : Type z\ninst✝⁶ : CommRing R\ninst✝⁵ : Algebra R K\ninst✝⁴ : Algebra R L\ninst✝³ : IsScalarTower R K L\ninst✝² : Algebra.IsSeparable K L\ninst✝¹ : IsIntegrallyClosed R\ninst✝ : Is... | simp only [updateCol_apply, hji, PowerBasis.coe_basis] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.RingTheory.Discriminant | {
"line": 288,
"column": 4
} | {
"line": 288,
"column": 100
} | [
{
"pp": "case pos\nK : Type u\nL : Type v\ninst✝¹⁰ : Field K\ninst✝⁹ : Field L\ninst✝⁸ : Algebra K L\ninst✝⁷ : Module.Finite K L\nR : Type z\ninst✝⁶ : CommRing R\ninst✝⁵ : Algebra R K\ninst✝⁴ : Algebra R L\ninst✝³ : IsScalarTower R K L\ninst✝² : Algebra.IsSeparable K L\ninst✝¹ : IsIntegrallyClosed R\ninst✝ : Is... | exact mem_bot.2 (IsIntegrallyClosed.isIntegral_iff.1 <| isIntegral_trace (hz.mul <| hint.pow _)) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.RingTheory.Discriminant | {
"line": 289,
"column": 4
} | {
"line": 289,
"column": 58
} | [
{
"pp": "case neg\nK : Type u\nL : Type v\ninst✝¹⁰ : Field K\ninst✝⁹ : Field L\ninst✝⁸ : Algebra K L\ninst✝⁷ : Module.Finite K L\nR : Type z\ninst✝⁶ : CommRing R\ninst✝⁵ : Algebra R K\ninst✝⁴ : Algebra R L\ninst✝³ : IsScalarTower R K L\ninst✝² : Algebra.IsSeparable K L\ninst✝¹ : IsIntegrallyClosed R\ninst✝ : Is... | simp only [updateCol_apply, hji, PowerBasis.coe_basis] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.FieldTheory.CardinalEmb | {
"line": 125,
"column": 6
} | {
"line": 142,
"column": 85
} | [
{
"pp": "F : 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 : (Module.rank F E).ord.ToType\nih : (y : (Module.rank F E).ord.ToType) → y < i → (Module.rank F E).ord.ToType\ns : Set E := failed to pretty prin... | rw [← compl_setOf, nonempty_compl]; by_contra!
simp_rw [eq_univ_iff_forall, mem_setOf] at this
have := adjoin_le_iff.mpr (range_subset_iff.mpr this)
rw [adjoin_basis_eq_top, ← eq_top_iff] at this
apply_fun Module.rank F at this
refine ne_of_lt ?_ this
let _ : AddCommMonoid (⊤ : Inter... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.FieldTheory.CardinalEmb | {
"line": 125,
"column": 6
} | {
"line": 142,
"column": 85
} | [
{
"pp": "F : 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 : (Module.rank F E).ord.ToType\nih : (y : (Module.rank F E).ord.ToType) → y < i → (Module.rank F E).ord.ToType\ns : Set E := failed to pretty prin... | rw [← compl_setOf, nonempty_compl]; by_contra!
simp_rw [eq_univ_iff_forall, mem_setOf] at this
have := adjoin_le_iff.mpr (range_subset_iff.mpr this)
rw [adjoin_basis_eq_top, ← eq_top_iff] at this
apply_fun Module.rank F at this
refine ne_of_lt ?_ this
let _ : AddCommMonoid (⊤ : Inter... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.FieldTheory.CardinalEmb | {
"line": 205,
"column": 60
} | {
"line": 210,
"column": 51
} | [
{
"pp": "F : 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 : WithTop (Module.rank F E).ord.ToType\nh : i < j\n⊢ failed to pretty print expression (use 'set_option pp.rawOnError true' for raw representati... | by
cases j
· obtain ⟨i, rfl⟩ := ne_top_iff_exists.mp h.ne
exact ⟨le_top, fun incl ↦ (isLeast_leastExt i).1 (incl trivial)⟩
· obtain ⟨i, rfl⟩ := ne_top_iff_exists.mp (h.trans <| coe_lt_top _).ne
exact strictMono_filtration (coe_lt_coe.mp h) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.FieldTheory.Galois.NormalBasis | {
"line": 56,
"column": 51
} | {
"line": 56,
"column": 64
} | [
{
"pp": "case h.e'_4.h.h\nK : Type u_1\nL : Type u_2\ninst✝³ : Field K\ninst✝² : Field L\ninst✝¹ : Algebra K L\ninst✝ : Finite L\nthis✝ : Finite K\nthis : Fintype K\nx : L\nhx :\n Ideal.span {X ^ finrank K L - 1} =\n (toSpanSingleton K[X] (AEval' (frobeniusAlgHom K L).toLinearMap)\n ((AEval'.of (frob... | End.smul_def, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Invariant.Basic | {
"line": 281,
"column": 15
} | {
"line": 281,
"column": 35
} | [
{
"pp": "case pos\nB : Type u_2\ninst✝⁴ : CommRing B\nG : Type u_3\ninst✝³ : Group G\ninst✝² : Finite G\ninst✝¹ : MulSemiringAction G B\nQ : Ideal B\ninst✝ : Q.IsPrime\nval✝ : Fintype G\nP : Ideal B := {g | g • Q ≠ Q}.inf fun g ↦ g • Q\nh1 : ¬P ≤ Q\nb : B\nhbQ : b ∉ Q\nhbP : ∀ (g : G), g • Q ≠ Q → b ∈ g • Q\nf ... | sub_sub_cancel_left, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.FieldTheory.Galois.IsGaloisGroup | {
"line": 66,
"column": 45
} | {
"line": 66,
"column": 75
} | [
{
"pp": "G : Type u_1\nA : Type u_2\nB : Type u_4\ninst✝⁶ : Group G\ninst✝⁵ : CommSemiring A\ninst✝⁴ : Semiring B\ninst✝³ : Algebra A B\ninst✝² : MulSemiringAction G B\nhG : IsGaloisGroup G A B\nH : Type u_5\ninst✝¹ : Group H\ninst✝ : MulSemiringAction H B\ne : H ≃* G\nhe : ∀ (h : H) (x : B), e h • x = h • x\nb... | simpa [he'] using h (e.symm g) | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.FieldTheory.Galois.IsGaloisGroup | {
"line": 66,
"column": 45
} | {
"line": 66,
"column": 75
} | [
{
"pp": "G : Type u_1\nA : Type u_2\nB : Type u_4\ninst✝⁶ : Group G\ninst✝⁵ : CommSemiring A\ninst✝⁴ : Semiring B\ninst✝³ : Algebra A B\ninst✝² : MulSemiringAction G B\nhG : IsGaloisGroup G A B\nH : Type u_5\ninst✝¹ : Group H\ninst✝ : MulSemiringAction H B\ne : H ≃* G\nhe : ∀ (h : H) (x : B), e h • x = h • x\nb... | simpa [he'] using h (e.symm g) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.FieldTheory.Galois.IsGaloisGroup | {
"line": 66,
"column": 45
} | {
"line": 66,
"column": 75
} | [
{
"pp": "G : Type u_1\nA : Type u_2\nB : Type u_4\ninst✝⁶ : Group G\ninst✝⁵ : CommSemiring A\ninst✝⁴ : Semiring B\ninst✝³ : Algebra A B\ninst✝² : MulSemiringAction G B\nhG : IsGaloisGroup G A B\nH : Type u_5\ninst✝¹ : Group H\ninst✝ : MulSemiringAction H B\ne : H ≃* G\nhe : ∀ (h : H) (x : B), e h • x = h • x\nb... | simpa [he'] using h (e.symm g) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.FieldTheory.Galois.IsGaloisGroup | {
"line": 150,
"column": 2
} | {
"line": 153,
"column": 53
} | [
{
"pp": "case refine_1\nG : Type u_1\nA : Type u_2\nB : Type u_3\nK : Type u_4\nL : Type u_5\ninst✝¹⁸ : Group G\ninst✝¹⁷ : CommRing A\ninst✝¹⁶ : CommRing B\ninst✝¹⁵ : MulSemiringAction G B\ninst✝¹⁴ : Algebra A B\ninst✝¹³ : Field K\ninst✝¹² : Field L\ninst✝¹¹ : Algebra K L\ninst✝¹⁰ : Algebra A K\ninst✝⁹ : Algebr... | · have := hGKL.faithful
refine eq_of_smul_eq_smul fun (y : L) ↦ ?_
obtain ⟨a, b, hb, rfl⟩ := IsFractionRing.div_surjective B y
simp only [smul_div₀', ← algebraMap.coe_smul', h] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.FieldTheory.Galois.IsGaloisGroup | {
"line": 505,
"column": 92
} | {
"line": 510,
"column": 79
} | [
{
"pp": "G : Type u_1\nG' : Type u_2\nK : Type u_3\nL : Type u_4\ninst✝⁸ : Group G\ninst✝⁷ : Group G'\ninst✝⁶ : Field K\ninst✝⁵ : Field L\ninst✝⁴ : Algebra K L\ninst✝³ : MulSemiringAction G L\ninst✝² : MulSemiringAction G' L\nH H' : Subgroup G\nF F' : IntermediateField K L\nN : Subgroup G\ninst✝¹ : N.Normal\nhF... | by
rw [QuotientGroup.eq, ← fixingSubgroup_fixedPoints G K L N, subgroup_iff.mp hF,
mem_fixingSubgroup_iff]
intro x hx
rw [mul_smul, inv_smul_eq_iff]
simpa [eq_comm, coe_quotient_smul] using congr_arg Subtype.val <| h ⟨x, hx⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.RingTheory.Invariant.Basic | {
"line": 511,
"column": 2
} | {
"line": 512,
"column": 89
} | [
{
"pp": "case inr.splits'.intro\nA : Type u_1\nB : Type u_2\ninst✝⁹ : CommRing A\ninst✝⁸ : CommRing B\ninst✝⁷ : Algebra A B\nG : Type u_4\ninst✝⁶ : Finite G\ninst✝⁵ : Group G\ninst✝⁴ : MulSemiringAction G B\ninst✝³ : Algebra.IsInvariant A B G\nP : Ideal A\nQ : Ideal B\ninst✝² : Q.LiesOver P\ninst✝¹ : P.IsMaxima... | have H : Polynomial.aeval x p = 0 := by
rw [Polynomial.aeval_def, ← Polynomial.eval_map, hp, MulSemiringAction.eval_charpoly] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.FieldTheory.PerfectClosure | {
"line": 172,
"column": 10
} | {
"line": 172,
"column": 76
} | [
{
"pp": "K : Type u\ninst✝² : CommRing K\np : ℕ\ninst✝¹ : Fact (Nat.Prime p)\ninst✝ : CharP K p\ne : PerfectClosure K p\nx✝ : ℕ × K\nn : ℕ\nx : K\n⊢ ((n, x).1 + (0, 1).1, (⇑(frobenius K p))^[(0, 1).1] (n, x).2 * (⇑(frobenius K p))^[(n, x).1] (0, 1).2) = (n, x)",
"usedConstants": [
"iterate_map_one",
... | simp only [iterate_map_one, iterate_zero_apply, mul_one, add_zero] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.FieldTheory.PerfectClosure | {
"line": 172,
"column": 10
} | {
"line": 172,
"column": 76
} | [
{
"pp": "K : Type u\ninst✝² : CommRing K\np : ℕ\ninst✝¹ : Fact (Nat.Prime p)\ninst✝ : CharP K p\ne : PerfectClosure K p\nx✝ : ℕ × K\nn : ℕ\nx : K\n⊢ ((n, x).1 + (0, 1).1, (⇑(frobenius K p))^[(0, 1).1] (n, x).2 * (⇑(frobenius K p))^[(n, x).1] (0, 1).2) = (n, x)",
"usedConstants": [
"iterate_map_one",
... | simp only [iterate_map_one, iterate_zero_apply, mul_one, add_zero] | 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.