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.Computability.TuringMachine.Config | {
"line": 320,
"column": 26
} | {
"line": 320,
"column": 56
} | [
{
"pp": "case comp\nn : ℕ\nf : List.Vector ℕ n →. ℕ\nm✝ n✝ : ℕ\nf✝ : List.Vector ℕ n✝ →. ℕ\ng : Fin n✝ → List.Vector ℕ m✝ →. ℕ\na✝¹ : Nat.Partrec' f✝\na✝ : ∀ (i : Fin n✝), Nat.Partrec' (g i)\nIHf : ∃ c, ∀ (v : List.Vector ℕ n✝), c.eval ↑v = pure <$> f✝ v\nIHg : ∀ (i : Fin n✝), ∃ c, ∀ (v : List.Vector ℕ m✝), c.e... | exact exists_code.comp IHf IHg | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.Config | {
"line": 610,
"column": 6
} | {
"line": 610,
"column": 24
} | [
{
"pp": "f : Code\nk : Cont\nv : List ℕ\nfok : f.Ok\nx : Cfg\nthis :\n ∀ (c : Cfg),\n x ∈ eval step c →\n ∀ (v : List ℕ) (c' : Cfg),\n c = c'.then (Cont.fix f k) →\n Reaches step (stepNormal f Cont.halt v) c' →\n ∃ v₁ ∈ f.eval v,\n ∃ v₂ ∈ if v₁.headI = 0 then pur... | split_ifs at hv₂ ⊢ | Mathlib.Tactic._aux_Mathlib_Tactic_SplitIfs___elabRules_Mathlib_Tactic_splitIfs_1 | Mathlib.Tactic.splitIfs |
Mathlib.Computability.TuringMachine.Config | {
"line": 612,
"column": 8
} | {
"line": 612,
"column": 38
} | [
{
"pp": "case pos\nf : Code\nk : Cont\nv : List ℕ\nfok : f.Ok\nx : Cfg\nthis :\n ∀ (c : Cfg),\n x ∈ eval step c →\n ∀ (v : List ℕ) (c' : Cfg),\n c = c'.then (Cont.fix f k) →\n Reaches step (stepNormal f Cont.halt v) c' →\n ∃ v₁ ∈ f.eval v,\n ∃ v₂ ∈ if v₁.headI = ... | exact Or.inl (Part.mem_some _) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Computability.TuringMachine.Config | {
"line": 640,
"column": 8
} | {
"line": 640,
"column": 26
} | [
{
"pp": "case neg\nf : Code\nk : Cont\nv✝ : List ℕ\nfok : f.Ok\nx c : Cfg\nhe✝ : x ∈ eval step c\nv v' : List ℕ\nIH :\n ∀ (a' : Cfg),\n step (stepRet (Cont.fix f k) v') = some a' →\n ∀ (v : List ℕ) (c' : Cfg),\n a' = c'.then (Cont.fix f k) →\n Reaches step (stepNormal f Cont.halt v) c' ... | split_ifs at hv₂ ⊢ | Mathlib.Tactic._aux_Mathlib_Tactic_SplitIfs___elabRules_Mathlib_Tactic_splitIfs_1 | Mathlib.Tactic.splitIfs |
Mathlib.Topology.Category.CompHausLike.Limits | {
"line": 239,
"column": 34
} | {
"line": 239,
"column": 74
} | [
{
"pp": "P : TopCat → Prop\nX Y B : CompHausLike P\nf : X ⟶ B\ng : Y ⟶ B\ninst✝ : HasExplicitPullback f g\nZ : CompHausLike P\na : Z ⟶ X\nb : Z ⟶ Y\nw : a ≫ f = b ≫ g\nz : ↑Z.toTop\n⊢ ((ConcreteCategory.hom a) z, (ConcreteCategory.hom b) z) ∈\n {xy | (ConcreteCategory.hom f) xy.1 = (ConcreteCategory.hom g) x... | by apply_fun (fun q ↦ q z) at w; exact w | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.TuringMachine.Config | {
"line": 669,
"column": 2
} | {
"line": 669,
"column": 25
} | [
{
"pp": "case cons\nf fs : Code\nIHf : f.Ok\nIHfs : fs.Ok\nk : Cont\nv : List ℕ\n⊢ eval step ((fun k v ↦ stepNormal f (Cont.cons₁ fs v k) v) k v) = do\n let v ← (f.cons fs).eval v\n eval step (Cfg.ret k v)",
"usedConstants": [
"Pure.pure",
"Part",
"Eq.mpr",
"PFun",
"Turin... | | cons f fs IHf IHfs => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Topology.Separation.Profinite | {
"line": 195,
"column": 6
} | {
"line": 195,
"column": 33
} | [
{
"pp": "X : Type u_4\nI✝ : Type u_5\ninst✝⁵ : TopologicalSpace X\ninst✝⁴ : CompactSpace X\ninst✝³ : T2Space X\ninst✝² : TotallyDisconnectedSpace X\ninst✝¹ : Finite I✝\nI : Type u_5\ninst✝ : Fintype I\nIH :\n ∀ {Z D : I → Set X},\n (∀ (i : I), IsClosed[inst✝⁵] (Z i)) →\n (∀ (i : I), IsClopen (D i)) →\n... | simp only [C0, subset_diff] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Topology.ExtremallyDisconnected | {
"line": 128,
"column": 6
} | {
"line": 128,
"column": 36
} | [
{
"pp": "case refine_1.inl\nX : Type u\ninst✝² : TopologicalSpace X\ninst✝¹ : CompactSpace X\ninst✝ : T2Space X\nh : Projective X\nU : Set X\nhU : IsOpen U\nZ₁ : Set (X × Bool) := Uᶜ ×ˢ {true}\nZ₂ : Set (X × Bool) := closure U ×ˢ {false}\nZ : Set (X × Bool) := Z₁ ∪ Z₂\nhZ₁₂ : Disjoint Z₁ Z₂\nhZ₁ : IsClosed Z₁\n... | exact ((hφ₁ x ▸ hφ.1) hx).elim | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Topology.ExtremallyDisconnected | {
"line": 128,
"column": 6
} | {
"line": 128,
"column": 36
} | [
{
"pp": "case refine_1.inl\nX : Type u\ninst✝² : TopologicalSpace X\ninst✝¹ : CompactSpace X\ninst✝ : T2Space X\nh : Projective X\nU : Set X\nhU : IsOpen U\nZ₁ : Set (X × Bool) := Uᶜ ×ˢ {true}\nZ₂ : Set (X × Bool) := closure U ×ˢ {false}\nZ : Set (X × Bool) := Z₁ ∪ Z₂\nhZ₁₂ : Disjoint Z₁ Z₂\nhZ₁ : IsClosed Z₁\n... | exact ((hφ₁ x ▸ hφ.1) hx).elim | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.ExtremallyDisconnected | {
"line": 128,
"column": 6
} | {
"line": 128,
"column": 36
} | [
{
"pp": "case refine_1.inl\nX : Type u\ninst✝² : TopologicalSpace X\ninst✝¹ : CompactSpace X\ninst✝ : T2Space X\nh : Projective X\nU : Set X\nhU : IsOpen U\nZ₁ : Set (X × Bool) := Uᶜ ×ˢ {true}\nZ₂ : Set (X × Bool) := closure U ×ˢ {false}\nZ : Set (X × Bool) := Z₁ ∪ Z₂\nhZ₁₂ : Disjoint Z₁ Z₂\nhZ₁ : IsClosed Z₁\n... | exact ((hφ₁ x ▸ hφ.1) hx).elim | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1215,
"column": 2
} | {
"line": 1215,
"column": 25
} | [
{
"pp": "case cons\nS : Finset Λ'\nf fs : Code\nIHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S\nIHfs : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Supports (codeSupp' fs k) S\nk : Cont'\nH : codeSupp (f.cons fs) k ⊆ S\n⊢ Supports (codeSupp' (f.cons fs) k) S",
"usedConstants": [
"Turing.Part... | | cons f fs IHf IHfs => | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Topology.Category.Profinite.CofilteredLimit | {
"line": 172,
"column": 2
} | {
"line": 172,
"column": 56
} | [
{
"pp": "case h\nJ : Type v\ninst✝³ : SmallCategory J\ninst✝² : IsCofiltered J\nF : J ⥤ Profinite\nC : Cone F\nα : Type u_1\ninst✝¹ : Finite α\ninst✝ : Nonempty α\nhC : IsLimit C\nf : LocallyConstant (↑C.pt.toTop) α\ninhabited_h : Inhabited α\nj : J\ngg : LocallyConstant (↑(F.obj j).toTop) (α → Fin 2)\nh : Loca... | have h2 : ∃ a : α, ι a = gg (C.π.app j x) := ⟨f x, h1⟩ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Logic.Function.FiberPartition | {
"line": 49,
"column": 74
} | {
"line": 52,
"column": 17
} | [
{
"pp": "Y : Type u_2\nZ : Type u_3\nf : Y → Z\na : Fiber f\nx : ↑↑a\n⊢ f ↑x = image f a",
"usedConstants": [
"Eq.mpr",
"Exists.choose_spec",
"outParam",
"congrArg",
"HEq.refl",
"Membership.mem",
"Set.Elem",
"Set.instSingletonSet",
"Eq.casesOn",
"i... | by
have := a.2.choose_spec
rw [← Set.mem_singleton_iff, ← Set.mem_preimage]
convert! x.prop | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Topology.Category.LightProfinite.Extend | {
"line": 144,
"column": 6
} | {
"line": 148,
"column": 94
} | [
{
"pp": "F : ℕᵒᵖ ⥤ FintypeCat\nc : Cone (F ⋙ toLightProfinite)\nC : Type u_1\ninst✝ : Category.{v_1, u_1} C\nG : LightProfiniteᵒᵖ ⥤ C\nS : LightProfinite\nx✝¹ x✝ : CostructuredArrow toLightProfinite.op (Opposite.op S)\nf : x✝¹ ⟶ x✝\n⊢ (CostructuredArrow.proj toLightProfinite.op (Opposite.op S) ⋙ toLightProfinit... | have := f.w
simp only [op_obj, const_obj_obj, op_map, CostructuredArrow.right_eq_id, const_obj_map,
Category.comp_id] at this
simp only [comp_obj, CostructuredArrow.proj_obj, op_obj, const_obj_obj, Functor.comp_map,
CostructuredArrow.proj_map, op_map, ← map_comp, this, const_obj_map, Categor... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.Category.LightProfinite.Extend | {
"line": 144,
"column": 6
} | {
"line": 148,
"column": 94
} | [
{
"pp": "F : ℕᵒᵖ ⥤ FintypeCat\nc : Cone (F ⋙ toLightProfinite)\nC : Type u_1\ninst✝ : Category.{v_1, u_1} C\nG : LightProfiniteᵒᵖ ⥤ C\nS : LightProfinite\nx✝¹ x✝ : CostructuredArrow toLightProfinite.op (Opposite.op S)\nf : x✝¹ ⟶ x✝\n⊢ (CostructuredArrow.proj toLightProfinite.op (Opposite.op S) ⋙ toLightProfinit... | have := f.w
simp only [op_obj, const_obj_obj, op_map, CostructuredArrow.right_eq_id, const_obj_map,
Category.comp_id] at this
simp only [comp_obj, CostructuredArrow.proj_obj, op_obj, const_obj_obj, Functor.comp_map,
CostructuredArrow.proj_map, op_map, ← map_comp, this, const_obj_map, Categor... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Category.Profinite.Extend | {
"line": 97,
"column": 2
} | {
"line": 104,
"column": 67
} | [
{
"pp": "case right\nI : Type u\ninst✝² : SmallCategory I\ninst✝¹ : IsCofiltered I\nF : I ⥤ FintypeCat\nc : Cone (F ⋙ toProfinite)\nhc : IsLimit c\ninst✝ : ∀ (i : I), Epi (c.π.app i)\ne : I ≌ ULiftHom (ULift.{w, u} I) := ⋯\n⊢ ∀ {d : StructuredArrow c.pt toProfinite} {c_1 : ULiftHom (ULift.{w, u} I)}\n (s s' ... | · intro ⟨_, X, (f : c.pt ⟶ _)⟩ ⟨i⟩ ⟨_, (s : F.obj i ⟶ X), (w : f = c.π.app i ≫ _)⟩
⟨_, (s' : F.obj i ⟶ X), (w' : f = c.π.app i ≫ _)⟩
simp only [StructuredArrow.hom_eq_iff,
StructuredArrow.comp_right]
refine ⟨⟨i⟩, 𝟙 _, ?_⟩
simp only [CategoryTheory.Functor.map_id]
rw [w] at w'
exact toPr... | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Bool.Count | {
"line": 54,
"column": 4
} | {
"line": 54,
"column": 36
} | [
{
"pp": "b x : Bool\nl : List Bool\nh : IsChain (fun x1 x2 ↦ x1 ≠ x2) (b :: x :: l)\n⊢ count (!b) (x :: l) = count b (x :: l) + (x :: l).length % 2",
"usedConstants": [
"_private.Mathlib.Data.Bool.Count.0.List.IsChain.count_not_cons._proof_1_3"
]
}
] | grind [h.of_cons.count_not_cons] | Lean.Elab.Tactic.evalGrind | Lean.Parser.Tactic.grind |
Mathlib.Data.Bool.Count | {
"line": 54,
"column": 4
} | {
"line": 54,
"column": 36
} | [
{
"pp": "b x : Bool\nl : List Bool\nh : IsChain (fun x1 x2 ↦ x1 ≠ x2) (b :: x :: l)\n⊢ count (!b) (x :: l) = count b (x :: l) + (x :: l).length % 2",
"usedConstants": [
"_private.Mathlib.Data.Bool.Count.0.List.IsChain.count_not_cons._proof_1_3"
]
}
] | grind [h.of_cons.count_not_cons] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Bool.Count | {
"line": 54,
"column": 4
} | {
"line": 54,
"column": 36
} | [
{
"pp": "b x : Bool\nl : List Bool\nh : IsChain (fun x1 x2 ↦ x1 ≠ x2) (b :: x :: l)\n⊢ count (!b) (x :: l) = count b (x :: l) + (x :: l).length % 2",
"usedConstants": [
"_private.Mathlib.Data.Bool.Count.0.List.IsChain.count_not_cons._proof_1_3"
]
}
] | grind [h.of_cons.count_not_cons] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.FinEnum | {
"line": 56,
"column": 15
} | {
"line": 56,
"column": 46
} | [
{
"pp": "α : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\nxs : List α\nh : ∀ (x : α), x ∈ xs\nh' : xs.Nodup\ni : Fin xs.length\n⊢ (fun x ↦ ⟨List.idxOf x xs, ⋯⟩) (xs.get i) = i",
"usedConstants": [
"instLawfulBEq",
"congrArg",
"List.get",
"Fin.isLt",
"Fin.mk",
"FinEnum.o... | by ext; simp [h'.idxOf_getElem] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Sigma | {
"line": 463,
"column": 55
} | {
"line": 475,
"column": 30
} | [
{
"pp": "α : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na a' : α\nl : List (Sigma β)\n⊢ kerase a (kerase a' l) = kerase a' (kerase a l)",
"usedConstants": [
"False",
"eq_false",
"congrArg",
"List.kerase_cons_ne",
"Sigma.fst",
"Ne.symm",
"List.rec",
"List.k... | by
by_cases h : a = a'
· subst a'; rfl
induction l with
| nil => rfl
| cons x xs =>
by_cases a' = x.1
· subst a'
simp [kerase_cons_ne h, kerase_cons_eq rfl]
by_cases h' : a = x.1
· subst a
simp [kerase_cons_eq rfl, kerase_cons_ne (Ne.symm h)]
· simp [kerase_cons_ne, *] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Sigma | {
"line": 509,
"column": 4
} | {
"line": 517,
"column": 23
} | [
{
"pp": "case cons\nα : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na a' : α\nh : a ≠ a'\nhd : Sigma β\ntl : List (Sigma β)\nih : dlookup a (kerase a' tl) = dlookup a tl\n⊢ dlookup a (kerase a' (hd :: tl)) = dlookup a (hd :: tl)",
"usedConstants": [
"False",
"eq_false",
"congrArg",
... | obtain ⟨ah, bh⟩ := hd
by_cases h₁ : a = ah <;> by_cases h₂ : a' = ah
· substs h₁ h₂
cases Ne.irrefl h
· subst h₁
simp [h₂]
· subst h₂
simp [h]
· simp [h₁, h₂, ih] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Sigma | {
"line": 509,
"column": 4
} | {
"line": 517,
"column": 23
} | [
{
"pp": "case cons\nα : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na a' : α\nh : a ≠ a'\nhd : Sigma β\ntl : List (Sigma β)\nih : dlookup a (kerase a' tl) = dlookup a tl\n⊢ dlookup a (kerase a' (hd :: tl)) = dlookup a (hd :: tl)",
"usedConstants": [
"False",
"eq_false",
"congrArg",
... | obtain ⟨ah, bh⟩ := hd
by_cases h₁ : a = ah <;> by_cases h₂ : a' = ah
· substs h₁ h₂
cases Ne.irrefl h
· subst h₁
simp [h₂]
· subst h₂
simp [h]
· simp [h₁, h₂, ih] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finsupp.NeLocus | {
"line": 154,
"column": 2
} | {
"line": 154,
"column": 43
} | [
{
"pp": "α : Type u_1\nN : Type u_3\ninst✝² : DecidableEq α\ninst✝¹ : DecidableEq N\ninst✝ : AddGroup N\nf g : α →₀ N\n⊢ (f - g).neLocus f = g.support",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"congrArg",
"Finsupp.neLocus",
"Finset",
"HSub.hSub",
... | rw [neLocus_comm, neLocus_self_sub_right] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Finsupp.NeLocus | {
"line": 154,
"column": 2
} | {
"line": 154,
"column": 43
} | [
{
"pp": "α : Type u_1\nN : Type u_3\ninst✝² : DecidableEq α\ninst✝¹ : DecidableEq N\ninst✝ : AddGroup N\nf g : α →₀ N\n⊢ (f - g).neLocus f = g.support",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"congrArg",
"Finsupp.neLocus",
"Finset",
"HSub.hSub",
... | rw [neLocus_comm, neLocus_self_sub_right] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finsupp.NeLocus | {
"line": 154,
"column": 2
} | {
"line": 154,
"column": 43
} | [
{
"pp": "α : Type u_1\nN : Type u_3\ninst✝² : DecidableEq α\ninst✝¹ : DecidableEq N\ninst✝ : AddGroup N\nf g : α →₀ N\n⊢ (f - g).neLocus f = g.support",
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"congrArg",
"Finsupp.neLocus",
"Finset",
"HSub.hSub",
... | rw [neLocus_comm, neLocus_self_sub_right] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Holor | {
"line": 235,
"column": 2
} | {
"line": 235,
"column": 22
} | [
{
"pp": "α : Type\nd : ℕ\nds : List ℕ\ninst✝ : Semiring α\nx : Holor α (d :: ds)\n⊢ ∑ i ∈ (Finset.range d).attach, unitVec d ↑i ⊗ x.slice ↑i ⋯ = x",
"usedConstants": [
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.succ_le_of_lt",
"Finset",
"Membership.mem",
"Subtype",
"... | apply slice_eq _ _ _ | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Data.Int.CardIntervalMod | {
"line": 37,
"column": 21
} | {
"line": 37,
"column": 32
} | [
{
"pp": "case h\na b r v x : ℤ\n⊢ (a ≤ x ∧ x < b) ∧ x ≡ v [ZMOD r] ↔ (a - v ≤ x - v ∧ x - v < b - v) ∧ r ∣ x - v",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Dvd.dvd",
"congrArg",
"PartialOrder.toPreorder",
"HSub.hSub",
"Preorder.toLE",
"_private.Mathlib.D... | modEq_comm, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Int.CardIntervalMod | {
"line": 44,
"column": 21
} | {
"line": 44,
"column": 32
} | [
{
"pp": "case h\na b r v x : ℤ\n⊢ (a < x ∧ x ≤ b) ∧ x ≡ v [ZMOD r] ↔ (a - v < x - v ∧ x - v ≤ b - v) ∧ r ∣ x - v",
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"Dvd.dvd",
"_private.Mathlib.Data.Int.CardIntervalMod.0.Int.Ioc_filter_modEq_eq._simp_1_6",
"congrArg",
"Partia... | modEq_comm, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.List.TakeWhile | {
"line": 93,
"column": 67
} | {
"line": 93,
"column": 95
} | [
{
"pp": "case pos\nα : Type u_1\np q : α → Bool\nhd : α\ntl : List α\nIH : takeWhile p (takeWhile q tl) = takeWhile (fun a ↦ decide (p a = true ∧ q a = true)) tl\nhp : p hd = true\nhq : q hd = true\n⊢ takeWhile p (takeWhile q (hd :: tl)) = takeWhile (fun a ↦ decide (p a = true ∧ q a = true)) (hd :: tl)",
"u... | simp [takeWhile, hp, hq, IH] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.List.TakeWhile | {
"line": 93,
"column": 67
} | {
"line": 93,
"column": 95
} | [
{
"pp": "case neg\nα : Type u_1\np q : α → Bool\nhd : α\ntl : List α\nIH : takeWhile p (takeWhile q tl) = takeWhile (fun a ↦ decide (p a = true ∧ q a = true)) tl\nhp : p hd = true\nhq : ¬q hd = true\n⊢ takeWhile p (takeWhile q (hd :: tl)) = takeWhile (fun a ↦ decide (p a = true ∧ q a = true)) (hd :: tl)",
"... | simp [takeWhile, hp, hq, IH] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.List.TakeWhile | {
"line": 93,
"column": 67
} | {
"line": 93,
"column": 95
} | [
{
"pp": "case pos\nα : Type u_1\np q : α → Bool\nhd : α\ntl : List α\nIH : takeWhile p (takeWhile q tl) = takeWhile (fun a ↦ decide (p a = true ∧ q a = true)) tl\nhp : ¬p hd = true\nhq : q hd = true\n⊢ takeWhile p (takeWhile q (hd :: tl)) = takeWhile (fun a ↦ decide (p a = true ∧ q a = true)) (hd :: tl)",
"... | simp [takeWhile, hp, hq, IH] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.List.TakeWhile | {
"line": 93,
"column": 67
} | {
"line": 93,
"column": 95
} | [
{
"pp": "case neg\nα : Type u_1\np q : α → Bool\nhd : α\ntl : List α\nIH : takeWhile p (takeWhile q tl) = takeWhile (fun a ↦ decide (p a = true ∧ q a = true)) tl\nhp : ¬p hd = true\nhq : ¬q hd = true\n⊢ takeWhile p (takeWhile q (hd :: tl)) = takeWhile (fun a ↦ decide (p a = true ∧ q a = true)) (hd :: tl)",
... | simp [takeWhile, hp, hq, IH] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.List.Map2 | {
"line": 93,
"column": 4
} | {
"line": 93,
"column": 24
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\nf : α → β → γ\na : α\nas : List α\nb : β\nbs : List β\n⊢ zipWith (flip f) (b :: bs) (a :: as) = zipWith f (a :: as) (b :: bs)",
"usedConstants": [
"Eq.mpr",
"List.zipWith",
"and_true",
"congrArg",
"flip",
"id",
"List.cons... | simp! [zipWith_flip] | Lean.Parser.Tactic.expandSimp._@.Init.Meta.4021577198._hygCtx._hyg.3 | Lean.Parser.Tactic.simpAutoUnfold |
Mathlib.Data.List.PeriodicityLemma | {
"line": 104,
"column": 30
} | {
"line": 104,
"column": 44
} | [
{
"pp": "case mpr\nα : Type u_1\np : ℕ\nw : List α\nmod : ∀ i < w.length, w[i]? = w[i % p]?\ni : ℕ\nless : i < w.length - p\n⊢ w[i]? = w[(i + p) % p]?",
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.instGetElem?NatLtLength",
"id",
"Nat.instMod",
"instHMod",
"Nat.ad... | add_mod_right, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.SplitBy | {
"line": 162,
"column": 4
} | {
"line": 162,
"column": 19
} | [
{
"pp": "case nil\nα : Type u_1\nm : List α\nr : α → α → Bool\ng : List α\na : α\nh : IsChain (fun x y ↦ r x y = true) (g.reverse ++ [a])\nha : ∀ (x : α), x ∈ m.head? → r ([a].getLast ⋯) x = false\n⊢ splitBy.loop r ([] ++ m) a g [] = (g.reverse ++ [a]) :: splitBy r m",
"usedConstants": [
"Eq.mpr",
... | rw [nil_append] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.NNRat.BigOperators | {
"line": 62,
"column": 41
} | {
"line": 62,
"column": 77
} | [
{
"pp": "α : Type u_1\ns : Finset α\nf : α → ℚ\nhf : ∀ a ∈ s, 0 ≤ f a\nx : α\nhxs : x ∈ s\n⊢ f x = ↑(f x).toNNRat",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Rat",
"id",
"Field.toSemifield",
"DivisionSemiring.toNNRatCast",
"Semifield.toDivisionSemiring",
"Rat.... | by rw [Rat.coe_toNNRat _ (hf x hxs)] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.NNRat.BigOperators | {
"line": 67,
"column": 42
} | {
"line": 67,
"column": 78
} | [
{
"pp": "α : Type u_1\ns : Finset α\nf : α → ℚ\nhf : ∀ a ∈ s, 0 ≤ f a\nx : α\nhxs : x ∈ s\n⊢ f x = ↑(f x).toNNRat",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Rat",
"id",
"Field.toSemifield",
"DivisionSemiring.toNNRatCast",
"Semifield.toDivisionSemiring",
"Rat.... | by rw [Rat.coe_toNNRat _ (hf x hxs)] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 158,
"column": 34
} | {
"line": 158,
"column": 39
} | [
{
"pp": "case mk\nι : Type u_1\na s : ι → ℕ\nl : List ι\nnod : Multiset.Nodup (Quot.mk (⇑(List.isSetoid ι)) l)\nhs : ∀ i ∈ Quot.mk (⇑(List.isSetoid ι)) l, s i ≠ 0\npp : {x | x ∈ Quot.mk (⇑(List.isSetoid ι)) l}.Pairwise (Coprime on s)\n⊢ ↑(chineseRemainderOfMultiset a s nod hs pp) < (Multiset.map s (Quot.mk (⇑(L... | | _ l
=> | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Data.Nat.Nth | {
"line": 177,
"column": 4
} | {
"line": 177,
"column": 43
} | [
{
"pp": "case refine_2\np : ℕ → Prop\nx : ℕ\nhf : (setOf p).Infinite\nn : ℕ\nhx : nth p n = x\n⊢ ∃ n, (∀ (hf : (setOf p).Finite), n < #hf.toFinset) ∧ nth p n = x",
"usedConstants": [
"setOf",
"Set.Finite",
"And",
"absurd",
"Set.Finite.toFinset",
"Nat",
"And.intro",
... | exact ⟨n, fun hf' => absurd hf' hf, hx⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.PFunctor.Univariate.Basic | {
"line": 177,
"column": 4
} | {
"line": 177,
"column": 28
} | [
{
"pp": "case mp\nP : PFunctor.{uA, uB}\nα : Type u\np : α → Prop\nx : ↑P α\ny : ↑P (Subtype p)\nhy : Subtype.val <$> y = x\n⊢ ∃ a f, x = ⟨a, f⟩ ∧ ∀ (i : P.B a), p (f i)",
"usedConstants": [
"PFunctor.Obj",
"Subtype",
"Eq.refl"
]
}
] | rcases h : y with ⟨a, f⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Data.PFunctor.Univariate.Basic | {
"line": 203,
"column": 10
} | {
"line": 203,
"column": 16
} | [
{
"pp": "case h.right.left\nP : PFunctor.{uA, uB}\nα : Type u\nr : α → α → Prop\nx y : ↑P α\nu : ↑P { p // r p.1 p.2 }\nxeq : (fun t ↦ (↑t).1) <$> u = x\nyeq : (fun t ↦ (↑t).2) <$> u = y\na : P.A\nf : P.B a → { p // r p.1 p.2 }\nh : u = ⟨a, f⟩\n⊢ y = ⟨a, fun i ↦ (↑(f i)).2⟩",
"usedConstants": [
"Eq.mp... | ← yeq, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PFunctor.Multivariate.Basic | {
"line": 147,
"column": 4
} | {
"line": 147,
"column": 28
} | [
{
"pp": "case mp\nn : ℕ\nP : MvPFunctor.{u} n\nα : TypeVec.{u} n\np : ⦃i : Fin2 n⦄ → α i → Prop\nx : ↑P α\ny : ↑P fun i ↦ Subtype p\nhy : (fun i ↦ Subtype.val) <$$> y = x\n⊢ ∃ a f, x = ⟨a, f⟩ ∧ ∀ (i : Fin2 n) (j : P.B a i), p (f i j)",
"usedConstants": [
"MvPFunctor.Obj",
"Subtype",
"Eq.re... | rcases h : y with ⟨a, f⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Data.PFunctor.Multivariate.Basic | {
"line": 173,
"column": 10
} | {
"line": 173,
"column": 16
} | [
{
"pp": "case h.right.left\nn : ℕ\nP : MvPFunctor.{u} n\nα : TypeVec.{u} n\nr : ⦃i : Fin2 n⦄ → α i → α i → Prop\nx y : ↑P α\nu : ↑P fun i ↦ { p // r p.1 p.2 }\nxeq : (fun i t ↦ (↑t).1) <$$> u = x\nyeq : (fun i t ↦ (↑t).2) <$$> u = y\na : P.A\nf : P.B a ⟹ fun i ↦ { p // r p.1 p.2 }\nh : u = ⟨a, f⟩\n⊢ y = ⟨a, fun... | ← yeq, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Ordmap.Invariants | {
"line": 257,
"column": 2
} | {
"line": 257,
"column": 33
} | [
{
"pp": "α : Type u_1\nl : Ordnode α\nx : α\nm : Ordnode α\ny : α\nr : Ordnode α\n⊢ (l.node3L x m y r).dual = r.dual.node3R y m.dual x l.dual",
"usedConstants": [
"Ordnode.node'",
"Ordnode.node3L",
"Ordnode",
"congrArg",
"and_self",
"Ordnode.size_dual",
"instOfNatNa... | simp [node3L, node3R, add_comm] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Ordmap.Invariants | {
"line": 257,
"column": 2
} | {
"line": 257,
"column": 33
} | [
{
"pp": "α : Type u_1\nl : Ordnode α\nx : α\nm : Ordnode α\ny : α\nr : Ordnode α\n⊢ (l.node3L x m y r).dual = r.dual.node3R y m.dual x l.dual",
"usedConstants": [
"Ordnode.node'",
"Ordnode.node3L",
"Ordnode",
"congrArg",
"and_self",
"Ordnode.size_dual",
"instOfNatNa... | simp [node3L, node3R, add_comm] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Ordmap.Invariants | {
"line": 257,
"column": 2
} | {
"line": 257,
"column": 33
} | [
{
"pp": "α : Type u_1\nl : Ordnode α\nx : α\nm : Ordnode α\ny : α\nr : Ordnode α\n⊢ (l.node3L x m y r).dual = r.dual.node3R y m.dual x l.dual",
"usedConstants": [
"Ordnode.node'",
"Ordnode.node3L",
"Ordnode",
"congrArg",
"and_self",
"Ordnode.size_dual",
"instOfNatNa... | simp [node3L, node3R, add_comm] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Ordmap.Invariants | {
"line": 261,
"column": 2
} | {
"line": 261,
"column": 33
} | [
{
"pp": "α : Type u_1\nl : Ordnode α\nx : α\nm : Ordnode α\ny : α\nr : Ordnode α\n⊢ (l.node3R x m y r).dual = r.dual.node3L y m.dual x l.dual",
"usedConstants": [
"Ordnode.node'",
"Ordnode.node3R",
"Ordnode",
"congrArg",
"and_self",
"Ordnode.size_dual",
"instOfNatNa... | simp [node3L, node3R, add_comm] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Ordmap.Invariants | {
"line": 261,
"column": 2
} | {
"line": 261,
"column": 33
} | [
{
"pp": "α : Type u_1\nl : Ordnode α\nx : α\nm : Ordnode α\ny : α\nr : Ordnode α\n⊢ (l.node3R x m y r).dual = r.dual.node3L y m.dual x l.dual",
"usedConstants": [
"Ordnode.node'",
"Ordnode.node3R",
"Ordnode",
"congrArg",
"and_self",
"Ordnode.size_dual",
"instOfNatNa... | simp [node3L, node3R, add_comm] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Ordmap.Invariants | {
"line": 261,
"column": 2
} | {
"line": 261,
"column": 33
} | [
{
"pp": "α : Type u_1\nl : Ordnode α\nx : α\nm : Ordnode α\ny : α\nr : Ordnode α\n⊢ (l.node3R x m y r).dual = r.dual.node3L y m.dual x l.dual",
"usedConstants": [
"Ordnode.node'",
"Ordnode.node3R",
"Ordnode",
"congrArg",
"and_self",
"Ordnode.size_dual",
"instOfNatNa... | simp [node3L, node3R, add_comm] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Ordmap.Invariants | {
"line": 269,
"column": 14
} | {
"line": 269,
"column": 66
} | [
{
"pp": "case nil\nα : Type u_1\nl : Ordnode α\nx y : α\nr : Ordnode α\n⊢ (l.node4R x nil y r).dual = r.dual.node4L y nil.dual x l.dual",
"usedConstants": [
"Ordnode.node'",
"Ordnode",
"congrArg",
"Ordnode.dual",
"True",
"eq_self",
"Ordnode.nil",
"of_eq_true",... | simp [node4L, node4R, node3L, dual_node3R, add_comm] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Ordmap.Invariants | {
"line": 269,
"column": 14
} | {
"line": 269,
"column": 66
} | [
{
"pp": "case node\nα : Type u_1\nl : Ordnode α\nx y : α\nr : Ordnode α\nsize✝ : ℕ\nl✝ : Ordnode α\nx✝ : α\nr✝ : Ordnode α\n⊢ (l.node4R x (node size✝ l✝ x✝ r✝) y r).dual = r.dual.node4L y (node size✝ l✝ x✝ r✝).dual x l.dual",
"usedConstants": [
"Ordnode.node'",
"Ordnode",
"congrArg",
... | simp [node4L, node4R, node3L, dual_node3R, add_comm] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Ordmap.Ordset | {
"line": 259,
"column": 8
} | {
"line": 259,
"column": 26
} | [
{
"pp": "case pos.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.siz... | rw [rl0] at this ⊢ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Ordmap.Ordset | {
"line": 315,
"column": 2
} | {
"line": 315,
"column": 46
} | [
{
"pp": "α : Type u_2\nl : Ordnode α\nl' : ℕ\nr : Ordnode α\nr' : ℕ\nH1 : BalancedSz l' r'\nH2 : l.size.dist l' ≤ 1 ∧ r.size = r' ∨ r.size.dist r' ≤ 1 ∧ l.size = l'\n⊢ 2 * r.size ≤ 9 * l.size + 5 ∨ r.size ≤ 3",
"usedConstants": [
"HMul.hMul",
"instMulNat",
"instOfNatNat",
"LE.le",
... | suffices @size α r ≤ 3 * (size l + 1) by lia | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticSuffices__1 | Lean.Parser.Tactic.tacticSuffices_ |
Mathlib.Data.Ordmap.Invariants | {
"line": 663,
"column": 4
} | {
"line": 663,
"column": 35
} | [
{
"pp": "case mp.inr\nn : ℕ\n⊢ n ≤ n + 1 ∧ n + 1 ≤ n + 1",
"usedConstants": [
"le_rfl",
"Nat.le_succ",
"instOfNatNat",
"LE.le",
"instLENat",
"instHAdd",
"HAdd.hAdd",
"Nat.instPreorder",
"Nat",
"And.intro",
"instAddNat",
"OfNat.ofNat"
... | · exact ⟨Nat.le_succ _, le_rfl⟩ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.QPF.Multivariate.Basic | {
"line": 146,
"column": 10
} | {
"line": 146,
"column": 16
} | [
{
"pp": "case h.right.left\nn : ℕ\nF : TypeVec.{u} n → Type u_1\nq : MvQPF F\nα : TypeVec.{u} n\nr : ⦃i : Fin2 n⦄ → α i → α i → Prop\nx y : F α\nu : F fun i ↦ { p // r p.1 p.2 }\nxeq : (fun i t ↦ (↑t).1) <$$> u = x\nyeq : (fun i t ↦ (↑t).2) <$$> u = y\na : (P F).A\nf : (P F).B a ⟹ fun i ↦ { p // r p.1 p.2 }\nh ... | ← yeq, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PNat.Xgcd | {
"line": 288,
"column": 4
} | {
"line": 290,
"column": 8
} | [
{
"pp": "case fst\nu : XgcdType\nhr✝ : u.r ≠ 0\nha : u.r + ↑u.b * u.q = ↑u.a := ⋯\nhr : u.r - 1 + 1 = u.r := ⋯\n⊢ u.step.v.1 = u.v.swap.1",
"usedConstants": [
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"PNat.val",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Mathlib.Tac... | change ((u.y * u.q + u.z) * u.b + u.y * (u.r - 1 + 1) : ℕ) = u.y * u.a + u.z * u.b
rw [← ha, hr]
ring | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.PNat.Xgcd | {
"line": 288,
"column": 4
} | {
"line": 290,
"column": 8
} | [
{
"pp": "case fst\nu : XgcdType\nhr✝ : u.r ≠ 0\nha : u.r + ↑u.b * u.q = ↑u.a := ⋯\nhr : u.r - 1 + 1 = u.r := ⋯\n⊢ u.step.v.1 = u.v.swap.1",
"usedConstants": [
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"PNat.val",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Mathlib.Tac... | change ((u.y * u.q + u.z) * u.b + u.y * (u.r - 1 + 1) : ℕ) = u.y * u.a + u.z * u.b
rw [← ha, hr]
ring | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Ordmap.Ordset | {
"line": 498,
"column": 6
} | {
"line": 498,
"column": 42
} | [
{
"pp": "case pos\nα : 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 α\nbl : nil.Bounded o₁ ↑x\nbr : nil.Bounded (↑x) o₂\... | rcases hf _ ⟨h_1, h_2⟩ with ⟨xf, fx⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Data.PNat.Xgcd | {
"line": 451,
"column": 4
} | {
"line": 451,
"column": 43
} | [
{
"pp": "case a\na b : ℕ+\nleft✝² : a.gcdW b * a.gcdZ b = (a.gcdX b * a.gcdY b).succPNat\nh₁ : a = a.gcdA' b * a.gcdD b\nh₂ : b = a.gcdB' b * a.gcdD b\nleft✝¹ : a.gcdZ b * a.gcdA' b = (a.gcdX b * ↑(a.gcdB' b)).succPNat\nleft✝ : a.gcdW b * a.gcdB' b = (a.gcdY b * ↑(a.gcdA' b)).succPNat\nh₅ : ↑(a.gcdZ b) * ↑a = a... | exact (Nat.dvd_add_iff_right h₈).mpr h₇ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Ordmap.Ordset | {
"line": 598,
"column": 6
} | {
"line": 605,
"column": 62
} | [
{
"pp": "case node.gt\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₁ (Ordnode.node size✝ t_l t_x t_r) a₂\nt_l_valid : Valid' a₁ (erase x t_l) ↑t_x\nt_l_size : Raised (erase x t_l).size t_l.size... | suffices h_balanceable : _ by
constructor
· exact Valid'.balanceL h.left t_r_valid h_balanceable
· rw [size_balanceL h.left.bal t_r_valid.bal h.left.sz t_r_valid.sz h_balanceable]
apply Raised.add_right
apply Raised.add_left
exact t_r_size
right; exists t_r.si... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Ordmap.Ordset | {
"line": 598,
"column": 6
} | {
"line": 605,
"column": 62
} | [
{
"pp": "case node.gt\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₁ (Ordnode.node size✝ t_l t_x t_r) a₂\nt_l_valid : Valid' a₁ (erase x t_l) ↑t_x\nt_l_size : Raised (erase x t_l).size t_l.size... | suffices h_balanceable : _ by
constructor
· exact Valid'.balanceL h.left t_r_valid h_balanceable
· rw [size_balanceL h.left.bal t_r_valid.bal h.left.sz t_r_valid.sz h_balanceable]
apply Raised.add_right
apply Raised.add_left
exact t_r_size
right; exists t_r.si... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.QPF.Univariate.Basic | {
"line": 105,
"column": 4
} | {
"line": 106,
"column": 9
} | [
{
"pp": "case h.left\nF : Type u → Type v\nq : QPF F\nα : Type u\np : α → Prop\nx : F α\ny : F (Subtype p)\nhy : Subtype.val <$> y = x\na : (P F).A\nf : (P F).B a → Subtype p\nh : repr y = ⟨a, f⟩\n⊢ x = abs ⟨a, fun i ↦ ↑(f i)⟩",
"usedConstants": [
"Eq.mpr",
"QPF.abs_repr",
"PFunctor.A",
... | · rw [← hy, ← abs_repr y, h, ← abs_map]
rfl | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.QPF.Univariate.Basic | {
"line": 121,
"column": 4
} | {
"line": 122,
"column": 9
} | [
{
"pp": "case h.left\nF : Type u → Type v\nq : QPF F\nα : Type u\np : α → Prop\nx : F α\ny : F (Subtype p)\nhy : Subtype.val <$> y = x\na : (P F).A\nf : (P F).B a → Subtype p\nh : repr y = ⟨a, f⟩\n⊢ abs ⟨a, fun i ↦ ↑(f i)⟩ = x",
"usedConstants": [
"Eq.mpr",
"QPF.abs_repr",
"PFunctor.A",
... | · rw [← hy, ← abs_repr y, h, ← abs_map]
rfl | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.QPF.Univariate.Basic | {
"line": 139,
"column": 10
} | {
"line": 139,
"column": 16
} | [
{
"pp": "case h.right.left\nF : Type u → Type v\nq : QPF F\nα : Type u\nr : α → α → Prop\nx y : F α\nu : F { p // r p.1 p.2 }\nxeq : (fun t ↦ (↑t).1) <$> u = x\nyeq : (fun t ↦ (↑t).2) <$> u = y\na : (P F).A\nf : (P F).B a → { p // r p.1 p.2 }\nh : repr u = ⟨a, f⟩\n⊢ y = abs ⟨a, fun i ↦ (↑(f i)).2⟩",
"usedCo... | ← yeq, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Real.Sign | {
"line": 77,
"column": 24
} | {
"line": 77,
"column": 53
} | [
{
"pp": "case inl\nr : ℝ\nhn : r < 0\n⊢ (-r).sign = - -1",
"usedConstants": [
"Iff.mpr",
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"NegZeroClass.toNeg",
"Real.partialOrder",
"Real",
"neg_pos",
"congrArg",
"instIsLeftCancelAddOfAddLeftReflectLE",
"A... | sign_of_pos (neg_pos.mpr hn), | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.QPF.Univariate.Basic | {
"line": 563,
"column": 4
} | {
"line": 563,
"column": 63
} | [
{
"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\n⊢ ∃ a f, abs ⟨a, f⟩ = x ∧ ∀ (a' : (P F).A) (f' : (P F).B a' → α), abs ⟨a', f'⟩ = x → f '' univ ⊆ f' '' univ",
"usedConstants": [
"Eq.mpr",
"congrArg",
"Membership.mem... | have : Liftp (· ∈ supp x) x := by rw [h]; intro u; exact id | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.Set.Enumerate | {
"line": 63,
"column": 4
} | {
"line": 69,
"column": 17
} | [
{
"pp": "α : Type u_1\nsel : Set α → Option α\nh_sel : ∀ (s : Set α) (a : α), sel s = some a → a ∈ s\ns : Set α\nn : ℕ\na : α\n⊢ enumerate sel s (n + 1) = some a → a ∈ s",
"usedConstants": [
"Eq.mpr",
"False",
"Option.ctorIdx",
"congrArg",
"False.elim",
"Option.casesOn",
... | cases h : sel s with
| none => simp [enumerate_eq_none_of_sel, h]
| some a' =>
simp only [enumerate, h]
exact fun h' : enumerate sel (s \ {a'}) n = some a ↦
have : a ∈ s \ {a'} := enumerate_mem h_sel h'
this.left | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Data.Set.Enumerate | {
"line": 63,
"column": 4
} | {
"line": 69,
"column": 17
} | [
{
"pp": "α : Type u_1\nsel : Set α → Option α\nh_sel : ∀ (s : Set α) (a : α), sel s = some a → a ∈ s\ns : Set α\nn : ℕ\na : α\n⊢ enumerate sel s (n + 1) = some a → a ∈ s",
"usedConstants": [
"Eq.mpr",
"False",
"Option.ctorIdx",
"congrArg",
"False.elim",
"Option.casesOn",
... | cases h : sel s with
| none => simp [enumerate_eq_none_of_sel, h]
| some a' =>
simp only [enumerate, h]
exact fun h' : enumerate sel (s \ {a'}) n = some a ↦
have : a ∈ s \ {a'} := enumerate_mem h_sel h'
this.left | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Set.Enumerate | {
"line": 63,
"column": 4
} | {
"line": 69,
"column": 17
} | [
{
"pp": "α : Type u_1\nsel : Set α → Option α\nh_sel : ∀ (s : Set α) (a : α), sel s = some a → a ∈ s\ns : Set α\nn : ℕ\na : α\n⊢ enumerate sel s (n + 1) = some a → a ∈ s",
"usedConstants": [
"Eq.mpr",
"False",
"Option.ctorIdx",
"congrArg",
"False.elim",
"Option.casesOn",
... | cases h : sel s with
| none => simp [enumerate_eq_none_of_sel, h]
| some a' =>
simp only [enumerate, h]
exact fun h' : enumerate sel (s \ {a'}) n = some a ↦
have : a ∈ s \ {a'} := enumerate_mem h_sel h'
this.left | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Seq.Parallel | {
"line": 85,
"column": 6
} | {
"line": 85,
"column": 61
} | [
{
"pp": "case a.cons.inr\nα : Type u\nlem1 :\n ∀ (l : List (Computation α)) (S : WSeq (Computation α)),\n (∃ a, parallel.aux2 l = Sum.inl a) → (corec parallel.aux1 (l, S)).Terminates\nc✝ : Computation α\nT : c✝.Terminates\na : α\nS : WSeq (Computation α)\nc : Computation α\nl : List (Computation α)\nIH : pu... | simp only [parallel.aux2, rmap, List.foldr_cons] at ⊢ e | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Seq.Parallel | {
"line": 101,
"column": 6
} | {
"line": 108,
"column": 13
} | [
{
"pp": "case cons.inr\nα : Type u\nlem1 :\n ∀ (l : List (Computation α)) (S : WSeq (Computation α)),\n (∃ a, parallel.aux2 l = Sum.inl a) → (corec parallel.aux1 (l, S)).Terminates\nc✝ : Computation α\nT : c✝.Terminates\ns : Computation α\nIH : ∀ {l : List (Computation α)} {S : WSeq (Computation α)}, s ∈ l ... | · rcases e : List.foldr (fun c o =>
match o with
| Sum.inl a => Sum.inl a
| Sum.inr ls => rmap (fun c' => c' :: ls) (destruct c))
(Sum.inr List.nil) l with a' | ls <;> simp only [rmap] at e <;> rw [e] at e'
· contradiction
have := IH' m _ e
grind | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.WSeq.Relation | {
"line": 263,
"column": 2
} | {
"line": 263,
"column": 21
} | [
{
"pp": "case h1\nα : Type u\nc : Computation (WSeq α)\ns : WSeq α\nh : s ∈ c\n⊢ flatten (Computation.pure s) ~ʷ s",
"usedConstants": [
"congrArg",
"Stream'.WSeq.flatten",
"_private.Mathlib.Data.WSeq.Relation.0.Stream'.WSeq.flatten_equiv._simp_1_1",
"Computation.pure",
"True",
... | · simp [Equiv.refl] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Seq.Parallel | {
"line": 170,
"column": 8
} | {
"line": 173,
"column": 13
} | [
{
"pp": "case inr.inr.some\nα : Type u\nS✝ : WSeq (Computation α)\nc✝ : Computation α\nh✝ : c✝ ∈ S✝\nT✝ : c✝.Terminates\nn : ℕ\nIH :\n ∀ (l : List (Computation α)) (S : Stream'.Seq (Option (Computation α))) (c : Computation α),\n c ∈ l ∨ some (some c) = S.get? n → c.Terminates → (corec parallel.aux1 (l, S))... | have D : Seq.destruct S = some (o, S.tail) := by
dsimp [Seq.destruct]
rw [e]
rfl | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.WSeq.Basic | {
"line": 710,
"column": 6
} | {
"line": 710,
"column": 45
} | [
{
"pp": "case inr.inr\nα : Type u\na : α\nss : WSeq α\nh : a ∈ ss\nS : WSeq (WSeq α)\nx✝ : α\ns✝ : WSeq α\nej : cons x✝ (s✝.append S.join) = cons x✝ (s✝.append S.join)\nIH :\n ∀ (s : WSeq α) (S_1 : WSeq (WSeq α)),\n s.append S_1.join = s✝.append S.join → a ∈ s.append S_1.join → a ∈ s ∨ ∃ s ∈ S_1, a ∈ s\nm :... | exact Or.imp_left Or.inr (IH _ _ rfl m) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Dynamics.Ergodic.Ergodic | {
"line": 64,
"column": 2
} | {
"line": 64,
"column": 63
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\ns : Set α\nf : α → α\nμ : Measure α\nhf : PreErgodic f μ\nhs : MeasurableSet s\nhfs : f ⁻¹' s = s\n⊢ s =ᶠ[ae μ] ∅ ∨ s =ᶠ[ae μ] univ",
"usedConstants": [
"MeasureTheory.ae",
"MeasureTheory.Measure",
"Set.univ",
"PreErgodic._auto_1",
... | simpa only [eventuallyConst_set'] using hf.aeconst_set hs hfs | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Dynamics.Ergodic.Ergodic | {
"line": 64,
"column": 2
} | {
"line": 64,
"column": 63
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\ns : Set α\nf : α → α\nμ : Measure α\nhf : PreErgodic f μ\nhs : MeasurableSet s\nhfs : f ⁻¹' s = s\n⊢ s =ᶠ[ae μ] ∅ ∨ s =ᶠ[ae μ] univ",
"usedConstants": [
"MeasureTheory.ae",
"MeasureTheory.Measure",
"Set.univ",
"PreErgodic._auto_1",
... | simpa only [eventuallyConst_set'] using hf.aeconst_set hs hfs | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Dynamics.Ergodic.Ergodic | {
"line": 64,
"column": 2
} | {
"line": 64,
"column": 63
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\ns : Set α\nf : α → α\nμ : Measure α\nhf : PreErgodic f μ\nhs : MeasurableSet s\nhfs : f ⁻¹' s = s\n⊢ s =ᶠ[ae μ] ∅ ∨ s =ᶠ[ae μ] univ",
"usedConstants": [
"MeasureTheory.ae",
"MeasureTheory.Measure",
"Set.univ",
"PreErgodic._auto_1",
... | simpa only [eventuallyConst_set'] using hf.aeconst_set hs hfs | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | {
"line": 233,
"column": 21
} | {
"line": 233,
"column": 87
} | [
{
"pp": "f : CircleDeg1Lift\nh : Bijective ⇑f\nx : ℝ\n⊢ f ((Equiv.ofBijective (⇑f) h).symm (x + 1)) = f ((Equiv.ofBijective (⇑f) h).symm x + 1)",
"usedConstants": [
"Real",
"Equiv.instEquivLike",
"Equiv.ofBijective_apply_symm_apply",
"congrArg",
"CircleDeg1Lift.instFunLikeReal"... | by simp only [Equiv.ofBijective_apply_symm_apply f, f.map_add_one] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Dynamics.Ergodic.AddCircle | {
"line": 71,
"column": 2
} | {
"line": 71,
"column": 75
} | [
{
"pp": "case inr.h\nT : ℝ\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₁ : ... | let I : ι → Set (AddCircle T) := fun j => closedBall d (T / (2 * ↑(n j))) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.Dynamics.Ergodic.Conservative | {
"line": 201,
"column": 2
} | {
"line": 201,
"column": 77
} | [
{
"pp": "α : Type u_1\ninst✝³ : MeasurableSpace α\ninst✝² : TopologicalSpace α\ninst✝¹ : SecondCountableTopology α\ninst✝ : OpensMeasurableSpace α\nf : α → α\nμ : Measure α\nh : Conservative f μ\nthis : ∀ s ∈ countableBasis α, ∀ᵐ (x : α) ∂μ, x ∈ s → ∃ᶠ (n : ℕ) in atTop, f^[n] x ∈ s\nx : α\nhx : ∀ i ∈ countableB... | rcases (isBasis_countableBasis α).mem_nhds_iff.1 hs with ⟨o, hoS, hxo, hos⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Dynamics.Ergodic.Action.OfMinimal | {
"line": 227,
"column": 2
} | {
"line": 227,
"column": 38
} | [
{
"pp": "G : Type u_1\ninst✝⁸ : Group G\ninst✝⁷ : TopologicalSpace G\ninst✝⁶ : IsTopologicalGroup G\ninst✝⁵ : SecondCountableTopology G\ninst✝⁴ : MeasurableSpace G\ninst✝³ : BorelSpace G\nμ : Measure G\ninst✝² : IsFiniteMeasure μ\ninst✝¹ : μ.InnerRegular\ninst✝ : μ.IsMulLeftInvariant\nf : G →* G\nhf : Dense (⋃ ... | rw [mem_preimage, Set.mem_one] at hx | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Dynamics.TopologicalEntropy.NetEntropy | {
"line": 88,
"column": 23
} | {
"line": 94,
"column": 86
} | [
{
"pp": "X : Type u_1\nT : X → X\nU : SetRel X X\nn : ℕ\nF : Set X\ns t : Finset X\nhs : IsDynNetIn T F U n ↑s\nht : IsDynCoverOf T F U n ↑t\n⊢ s.card ≤ t.card",
"usedConstants": [
"SetLike.mem_coe._simp_1",
"ChainCompletePartialOrder.instOfCompleteLattice",
"SetRel",
"CompleteBoolea... | by
have (x : X) (x_s : x ∈ s) : ∃ z ∈ t, z ∈ ball x (dynEntourage T U n) := by
simpa using ht (hs.1 x_s)
choose! F s_t using this
apply Finset.card_le_card_of_injOn F fun x x_s ↦ (s_t x x_s).1
exact fun x x_s y y_s Fx_Fy ↦
PairwiseDisjoint.elim_set hs.2 x_s y_s (F x) (s_t x x_s).2 (Fx_Fy ▸ (s_t y y_s).2... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Dynamics.Transitive | {
"line": 78,
"column": 2
} | {
"line": 78,
"column": 94
} | [
{
"pp": "M : Type u_1\nα : Type u_2\ninst✝² : TopologicalSpace α\ninst✝¹ : Monoid M\ninst✝ : MulAction M α\n⊢ IsTopologicallyTransitive M α ↔\n ∀ {U : Set α},\n IsOpen U → U.Nonempty → ∀ (U_1 : Set α), IsOpen U_1 → U_1.Nonempty → ∃ i, ((fun x ↦ i • x) '' U_1 ∩ U).Nonempty",
"usedConstants": [
... | exact ⟨fun h _ h₁ h₂ _ h₃ h₄ ↦ h.1 h₃ h₄ h₁ h₂, fun h ↦ ⟨fun h₁ h₂ h₃ h₄ ↦ h h₃ h₄ _ h₁ h₂⟩⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.RingTheory.Algebraic.Cardinality | {
"line": 56,
"column": 51
} | {
"line": 56,
"column": 62
} | [
{
"pp": "R : Type u\ninst✝⁶ : CommRing R\ninst✝⁵ : IsDomain R\nL : Type v\ninst✝⁴ : CommRing L\ninst✝³ : IsDomain L\ninst✝² : Algebra R L\ninst✝¹ : IsTorsionFree R L\ninst✝ : Algebra.IsAlgebraic R L\n⊢ lift.{v, u} #R[X] * lift.{u, v} ℵ₀ = lift.{v, u} #R[X] * ℵ₀",
"usedConstants": [
"Eq.mpr",
"HM... | lift_aleph0 | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.FieldTheory.IsAlgClosed.Classification | {
"line": 196,
"column": 4
} | {
"line": 196,
"column": 32
} | [
{
"pp": "case inl\nK : Type u\nL : Type v\ninst✝⁵ : Field K\ninst✝⁴ : Field L\ninst✝³ : IsAlgClosed K\ninst✝² : IsAlgClosed L\np : ℕ\ninst✝¹ : CharP K p\ninst✝ : CharP L p\nhK : ℵ₀ < #K\nhKL : Nonempty (K ≃ L)\nhp : Nat.Prime p\n⊢ Nonempty (K ≃+* L)",
"usedConstants": [
"Nat.Prime",
"Fact.mk"
... | haveI : Fact p.Prime := ⟨hp⟩ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHaveI___1 | Lean.Parser.Tactic.tacticHaveI__ |
Mathlib.ModelTheory.Algebra.Ring.Basic | {
"line": 247,
"column": 8
} | {
"line": 248,
"column": 45
} | [
{
"pp": "α : Type u_1\nR : Type u_2\nS : Type u_3\ninst✝³ : NonAssocRing R\ninst✝² : NonAssocRing S\ninst✝¹ : CompatibleRing R\ninst✝ : CompatibleRing S\nf : R ≃[ring] S\n⊢ ∀ (x y : R), f.toFun (x + y) = f.toFun x + f.toFun y",
"usedConstants": [
"FirstOrder.Language.Equiv.map_fun",
"NegZeroClas... | intro x y
simpa using f.map_fun addFunc ![x, y] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.ModelTheory.Algebra.Ring.Basic | {
"line": 247,
"column": 8
} | {
"line": 248,
"column": 45
} | [
{
"pp": "α : Type u_1\nR : Type u_2\nS : Type u_3\ninst✝³ : NonAssocRing R\ninst✝² : NonAssocRing S\ninst✝¹ : CompatibleRing R\ninst✝ : CompatibleRing S\nf : R ≃[ring] S\n⊢ ∀ (x y : R), f.toFun (x + y) = f.toFun x + f.toFun y",
"usedConstants": [
"FirstOrder.Language.Equiv.map_fun",
"NegZeroClas... | intro x y
simpa using f.map_fun addFunc ![x, y] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.FieldTheory.AbelRuffini | {
"line": 221,
"column": 6
} | {
"line": 221,
"column": 30
} | [
{
"pp": "F : Type u_1\nE : Type u_2\ninst✝² : Field F\ninst✝¹ : Field E\ninst✝ : Algebra F E\nx : E\nn : ℕ\nhn : n ≠ 0\nhx : x ^ n ∈ algebraicClosure F E\n⊢ x ∈ algebraicClosure F E",
"usedConstants": [
"IsAlgebraic",
"congrArg",
"IntermediateField",
"Membership.mem",
"Field.to... | mem_algebraicClosure_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.ModelTheory.Syntax | {
"line": 697,
"column": 14
} | {
"line": 699,
"column": 31
} | [
{
"pp": "L : Language\nL' : Language\nM : Type w\nα : Type u'\nβ : Type v'\nγ : Type u_1\nn : ℕ\nφ : L ≃ᴸ L'\n⊢ Function.LeftInverse φ.invLHom.onBoundedFormula φ.toLHom.onBoundedFormula",
"usedConstants": [
"Eq.mpr",
"Function.LeftInverse",
"FirstOrder.Language.LHom.comp",
"congrArg"... | by
rw [Function.leftInverse_iff_comp, ← LHom.comp_onBoundedFormula, φ.left_inv,
LHom.id_onBoundedFormula] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.ModelTheory.Substructures | {
"line": 298,
"column": 14
} | {
"line": 298,
"column": 30
} | [
{
"pp": "L : Language\nM : Type w\ninst✝ : L.Structure M\ns : Set M\n⊢ max ℵ₀ (lift.{u, w} #↑s + lift.{w, u} #((i : ℕ) × L.Functions i)) ≤\n max ℵ₀ (lift.{max w u, w} #↑s + lift.{w, u} #((i : ℕ) × L.Functions i))",
"usedConstants": [
"Eq.mpr",
"Lattice.toSemilatticeSup",
"Cardinal",
... | lift_umax.{w, u} | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.ModelTheory.Definability | {
"line": 270,
"column": 6
} | {
"line": 275,
"column": 33
} | [
{
"pp": "case intro.intro.mpr\nM : Type w\nA : Set M\nL : Language\ninst✝² : L.Structure M\nα : Type u₁\nβ : Type u_1\ns : Set (β → M)\nh✝ : A.Definable L s\nf : α → β\ninst✝¹ : Finite α\ninst✝ : Finite β\nval✝¹ : Fintype α\nval✝ : Fintype β\nh :\n A.Definable L\n ((fun g ↦ g ∘ rangeSplitting f) ⁻¹'\n ... | rintro ⟨y, ys, rfl⟩
refine ⟨⟨y, ys, ?_⟩, fun a => ?_⟩
· ext
simp [Set.apply_rangeSplitting f]
· rw [Function.comp_apply, Function.comp_apply, apply_rangeSplitting f,
rangeFactorization_coe] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.ModelTheory.Definability | {
"line": 270,
"column": 6
} | {
"line": 275,
"column": 33
} | [
{
"pp": "case intro.intro.mpr\nM : Type w\nA : Set M\nL : Language\ninst✝² : L.Structure M\nα : Type u₁\nβ : Type u_1\ns : Set (β → M)\nh✝ : A.Definable L s\nf : α → β\ninst✝¹ : Finite α\ninst✝ : Finite β\nval✝¹ : Fintype α\nval✝ : Fintype β\nh :\n A.Definable L\n ((fun g ↦ g ∘ rangeSplitting f) ⁻¹'\n ... | rintro ⟨y, ys, rfl⟩
refine ⟨⟨y, ys, ?_⟩, fun a => ?_⟩
· ext
simp [Set.apply_rangeSplitting f]
· rw [Function.comp_apply, Function.comp_apply, apply_rangeSplitting f,
rangeFactorization_coe] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.ModelTheory.Definability | {
"line": 561,
"column": 45
} | {
"line": 564,
"column": 48
} | [
{
"pp": "M : Type u_1\nL : Language\ninst✝ : L.Structure M\nα : Type u_2\nA : Set M\nf g : (α → M) → M\nhf : DefinableFun L A f\nhg : DefinableFun L A g\n⊢ A.Definable L {v | f v = g v}",
"usedConstants": [
"Set.Definable₂._proof_1",
"congrArg",
"and_self",
"setOf",
"Membership... | by
have hF : A.DefinableMap L (fun v => ![f v, g v]) := by
simp [DefinableMap, *]
exact (Definable.diagonal L A).preimage_map hF | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.ModelTheory.Satisfiability | {
"line": 439,
"column": 4
} | {
"line": 439,
"column": 23
} | [
{
"pp": "case mpr\nL : Language\nT : L.Theory\nh : ∀ (M N : T.ModelType), ↑M ≅[L] ↑N\nφ : L.Sentence\nM : T.ModelType\n⊢ T ⊨ᵇ φ ∨ T ⊨ᵇ Formula.not φ",
"usedConstants": [
"FirstOrder.Language.Sentence.Realize",
"FirstOrder.Language.Theory.ModelType.struc",
"Classical.propDecidable",
"... | («tacticBy_cases_:_»
"by_cases"
[`hφ ":"]
(choice (FirstOrder.Language.«term_⊨__1» `M "⊨" `φ) (FirstOrder.Language.«term_⊨_» `M "⊨" `φ))) | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.ModelTheory.Algebra.Field.IsAlgClosed | {
"line": 190,
"column": 6
} | {
"line": 194,
"column": 41
} | [
{
"pp": "case a.inl\nφ : Language.ring.Sentence\nT0 : Finset Language.ring.Sentence\nhT0 : ↑T0 ⊆ Theory.ACF 0\nh✝ : ↑T0 ⊨ᵇ φ\nψ : Language.ring.Sentence\nh : ψ ∈ Theory.field ∪ genericMonicPolyHasRoot '' {n | 0 < n}\n⊢ Nonempty { s // ∀ q ∉ s, Theory.ACF ↑q ⊨ᵇ ψ }",
"usedConstants": [
"Eq.mpr",
... | refine ⟨⟨∅, ?_⟩⟩
intro q _
exact Theory.models_sentence_of_mem
(by rw [Theory.ACF, Theory.fieldOfChar, Set.union_right_comm];
exact Set.mem_union_left _ h) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.ModelTheory.Algebra.Field.IsAlgClosed | {
"line": 190,
"column": 6
} | {
"line": 194,
"column": 41
} | [
{
"pp": "case a.inl\nφ : Language.ring.Sentence\nT0 : Finset Language.ring.Sentence\nhT0 : ↑T0 ⊆ Theory.ACF 0\nh✝ : ↑T0 ⊨ᵇ φ\nψ : Language.ring.Sentence\nh : ψ ∈ Theory.field ∪ genericMonicPolyHasRoot '' {n | 0 < n}\n⊢ Nonempty { s // ∀ q ∉ s, Theory.ACF ↑q ⊨ᵇ ψ }",
"usedConstants": [
"Eq.mpr",
... | refine ⟨⟨∅, ?_⟩⟩
intro q _
exact Theory.models_sentence_of_mem
(by rw [Theory.ACF, Theory.fieldOfChar, Set.union_right_comm];
exact Set.mem_union_left _ h) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.FieldTheory.AxGrothendieck | {
"line": 190,
"column": 4
} | {
"line": 190,
"column": 31
} | [
{
"pp": "case h.e'_2\nι : Type u_1\nα : Type u_2\ninst✝¹ : Finite α\ninst✝ : Finite ι\nφ : ring.Formula (α ⊕ ι)\nmons : ι → Finset (ι →₀ ℕ)\n⊢ {p | Theory.ACF ↑p ⊨ᵇ genericPolyMapSurjOnOfInjOn φ mons} = Set.univ",
"usedConstants": [
"Eq.mpr",
"FirstOrder.genericPolyMapSurjOnOfInjOn",
"Firs... | rw [Set.eq_univ_iff_forall] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.FieldTheory.Differential.Basic | {
"line": 117,
"column": 8
} | {
"line": 117,
"column": 65
} | [
{
"pp": "case h.h.h0\nR : Type u_1\ninst✝⁶ : Field R\ninst✝⁵ : Differential R\na b : R\nF : Type u_2\ninst✝⁴ : Field F\ninst✝³ : Differential F\ninst✝² : CharZero F\np : F[X]\ninst✝¹ : Fact (Irreducible p)\ninst✝ : Fact p.Monic\nq : F[X]\nthis : 0 < p.natDegree\nnh : derivative p = 0\n⊢ False",
"usedConstan... | simp [natDegree_eq_zero_of_derivative_eq_zero nh] at this | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.FieldTheory.Finite.Polynomial | {
"line": 224,
"column": 48
} | {
"line": 224,
"column": 83
} | [
{
"pp": "σ K : Type u\ninst✝² : Fintype K\ninst✝¹ : Field K\ninst✝ : Finite σ\np : MvPolynomial σ K\nh : ∀ (v : σ → K), (eval v) p = 0\nhp : p ∈ restrictDegree σ K (Fintype.card K - 1)\np' : R σ K := ⟨p, hp⟩\nthis : p' ∈ (evalᵢ σ K).ker\n⊢ p' = 0",
"usedConstants": [
"Pi.Function.module",
"Submo... | by rwa [ker_evalₗ, mem_bot] at this | [anonymous] | Lean.Parser.Term.byTactic |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.