module stringlengths 16 90 | startPos dict | endPos dict | nextStartPos dict | goals listlengths 0 96 | goalsAfter listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 375
values | kind stringclasses 379
values |
|---|---|---|---|---|---|---|---|---|
Mathlib.Logic.Function.FiberPartition | {
"line": 67,
"column": 2
} | {
"line": 67,
"column": 27
} | {
"line": 68,
"column": 2
} | [
{
"pp": "Y : Type u_2\nZ : Type u_3\nf : Y → Z\na : Fiber f\n⊢ (↑a).Nonempty",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"Function.Fiber.preimage",
"Membership.mem",
"Set.Elem",
"Set.instSingletonSet",
"Set.preimage",
"Exists.intro",
"Set.range"... | [
"Y : Type u_2\nZ : Type u_3\nf : Y → Z\na : Fiber f\n⊢ preimage f a ∈ ↑a"
] | refine ⟨preimage f a, ?_⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1179,
"column": 4
} | {
"line": 1179,
"column": 64
} | {
"line": 1180,
"column": 2
} | [
{
"pp": "case move\nS : Finset Λ'\nW : ∀ {q : Λ'}, q ∈ trStmts₁ q\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq : Λ'\nq_ih : Λ'.Supports S q → trStmts₁ q ⊆ S → Supports (trStmts₁ q) S\nH₁ : Λ'.Supports S (Λ'.move p✝ k₁✝ k₂✝ q)\nHS₁ : insert (Λ'.move p✝ k₁✝ k₂✝ q) (trStmts₁ q) ⊆ S\nh₁ : Λ'.move p✝ k₁✝ k₂✝ q ∈ S\nh₂ : trStmts... | [
"case move\nS : Finset Λ'\nW : ∀ {q : Λ'}, q ∈ trStmts₁ q\np✝ : Γ' → Bool\nk₁✝ k₂✝ : K'\nq : Λ'\nq_ih : Λ'.Supports S q → trStmts₁ q ⊆ S → Supports (trStmts₁ q) S\nH₁ : Λ'.Supports S (Λ'.move p✝ k₁✝ k₂✝ q)\nHS₁ : insert (Λ'.move p✝ k₁✝ k₂✝ q) (trStmts₁ q) ⊆ S\nh₁ : Λ'.move p✝ k₁✝ k₂✝ q ∈ S\nh₂ : trStmts₁ q ⊆ S\nh₃ ... | first | have h₃ := h₂ W | try simp [Finset.subset_iff] at h₂ | Lean.Elab.Tactic.evalFirst | Lean.Parser.Tactic.first |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1179,
"column": 4
} | {
"line": 1179,
"column": 64
} | {
"line": 1180,
"column": 2
} | [
{
"pp": "case clear\nS : Finset Λ'\nW : ∀ {q : Λ'}, q ∈ trStmts₁ q\np✝ : Γ' → Bool\nk✝ : K'\nq : Λ'\nq_ih : Λ'.Supports S q → trStmts₁ q ⊆ S → Supports (trStmts₁ q) S\nH₁ : Λ'.Supports S (Λ'.clear p✝ k✝ q)\nHS₁ : insert (Λ'.clear p✝ k✝ q) (trStmts₁ q) ⊆ S\nh₁ : Λ'.clear p✝ k✝ q ∈ S\nh₂ : trStmts₁ q ⊆ S\n⊢ Suppo... | [
"case clear\nS : Finset Λ'\nW : ∀ {q : Λ'}, q ∈ trStmts₁ q\np✝ : Γ' → Bool\nk✝ : K'\nq : Λ'\nq_ih : Λ'.Supports S q → trStmts₁ q ⊆ S → Supports (trStmts₁ q) S\nH₁ : Λ'.Supports S (Λ'.clear p✝ k✝ q)\nHS₁ : insert (Λ'.clear p✝ k✝ q) (trStmts₁ q) ⊆ S\nh₁ : Λ'.clear p✝ k✝ q ∈ S\nh₂ : trStmts₁ q ⊆ S\nh₃ : q ∈ S\n⊢ Suppo... | first | have h₃ := h₂ W | try simp [Finset.subset_iff] at h₂ | Lean.Elab.Tactic.evalFirst | Lean.Parser.Tactic.first |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1179,
"column": 4
} | {
"line": 1179,
"column": 64
} | {
"line": 1180,
"column": 2
} | [
{
"pp": "case copy\nS : Finset Λ'\nW : ∀ {q : Λ'}, q ∈ trStmts₁ q\nq : Λ'\nq_ih : Λ'.Supports S q → trStmts₁ q ⊆ S → Supports (trStmts₁ q) S\nH₁ : Λ'.Supports S q.copy\nHS₁ : insert q.copy (trStmts₁ q) ⊆ S\nh₁ : q.copy ∈ S\nh₂ : trStmts₁ q ⊆ S\n⊢ Supports (insert q.copy (trStmts₁ q)) S",
"ppTerm": "?copy",
... | [
"case copy\nS : Finset Λ'\nW : ∀ {q : Λ'}, q ∈ trStmts₁ q\nq : Λ'\nq_ih : Λ'.Supports S q → trStmts₁ q ⊆ S → Supports (trStmts₁ q) S\nH₁ : Λ'.Supports S q.copy\nHS₁ : insert q.copy (trStmts₁ q) ⊆ S\nh₁ : q.copy ∈ S\nh₂ : trStmts₁ q ⊆ S\nh₃ : q ∈ S\n⊢ Supports (insert q.copy (trStmts₁ q)) S"
] | first | have h₃ := h₂ W | try simp [Finset.subset_iff] at h₂ | Lean.Elab.Tactic.evalFirst | Lean.Parser.Tactic.first |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1179,
"column": 4
} | {
"line": 1179,
"column": 64
} | {
"line": 1180,
"column": 2
} | [
{
"pp": "case push\nS : Finset Λ'\nW : ∀ {q : Λ'}, q ∈ trStmts₁ q\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq : Λ'\nq_ih : Λ'.Supports S q → trStmts₁ q ⊆ S → Supports (trStmts₁ q) S\nH₁ : Λ'.Supports S (Λ'.push k✝ s✝ q)\nHS₁ : insert (Λ'.push k✝ s✝ q) (trStmts₁ q) ⊆ S\nh₁ : Λ'.push k✝ s✝ q ∈ S\nh₂ : trStmts₁ q ⊆ S\... | [
"case push\nS : Finset Λ'\nW : ∀ {q : Λ'}, q ∈ trStmts₁ q\nk✝ : K'\ns✝ : Option Γ' → Option Γ'\nq : Λ'\nq_ih : Λ'.Supports S q → trStmts₁ q ⊆ S → Supports (trStmts₁ q) S\nH₁ : Λ'.Supports S (Λ'.push k✝ s✝ q)\nHS₁ : insert (Λ'.push k✝ s✝ q) (trStmts₁ q) ⊆ S\nh₁ : Λ'.push k✝ s✝ q ∈ S\nh₂ : trStmts₁ q ⊆ S\nh₃ : q ∈ S\... | first | have h₃ := h₂ W | try simp [Finset.subset_iff] at h₂ | Lean.Elab.Tactic.evalFirst | Lean.Parser.Tactic.first |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1179,
"column": 4
} | {
"line": 1179,
"column": 64
} | {
"line": 1180,
"column": 2
} | [
{
"pp": "case read\nS : Finset Λ'\nW : ∀ {q : Λ'}, q ∈ trStmts₁ q\nq : Option Γ' → Λ'\nq_ih : ∀ (a : Option Γ'), Λ'.Supports S (q a) → trStmts₁ (q a) ⊆ S → Supports (trStmts₁ (q a)) S\nH₁ : Λ'.Supports S (Λ'.read q)\nHS₁ : insert (Λ'.read q) (Finset.univ.biUnion fun s ↦ trStmts₁ (q s)) ⊆ S\nh₁ : Λ'.read q ∈ S\n... | [
"case read\nS : Finset Λ'\nW : ∀ {q : Λ'}, q ∈ trStmts₁ q\nq : Option Γ' → Λ'\nq_ih : ∀ (a : Option Γ'), Λ'.Supports S (q a) → trStmts₁ (q a) ⊆ S → Supports (trStmts₁ (q a)) S\nH₁ : Λ'.Supports S (Λ'.read q)\nHS₁ : insert (Λ'.read q) (Finset.univ.biUnion fun s ↦ trStmts₁ (q s)) ⊆ S\nh₁ : Λ'.read q ∈ S\nh₂ : ∀ ⦃x : ... | first | have h₃ := h₂ W | try simp [Finset.subset_iff] at h₂ | Lean.Elab.Tactic.evalFirst | Lean.Parser.Tactic.first |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1179,
"column": 4
} | {
"line": 1179,
"column": 64
} | {
"line": 1180,
"column": 2
} | [
{
"pp": "case succ\nS : Finset Λ'\nW : ∀ {q : Λ'}, q ∈ trStmts₁ q\nq : Λ'\nq_ih : Λ'.Supports S q → trStmts₁ q ⊆ S → Supports (trStmts₁ q) S\nH₁ : Λ'.Supports S q.succ\nHS₁ : insert q.succ (insert (unrev q) (trStmts₁ q)) ⊆ S\nh₁ : q.succ ∈ S\nh₂ : insert (unrev q) (trStmts₁ q) ⊆ S\n⊢ Supports (insert q.succ (in... | [
"case succ\nS : Finset Λ'\nW : ∀ {q : Λ'}, q ∈ trStmts₁ q\nq : Λ'\nq_ih : Λ'.Supports S q → trStmts₁ q ⊆ S → Supports (trStmts₁ q) S\nH₁ : Λ'.Supports S q.succ\nHS₁ : insert q.succ (insert (unrev q) (trStmts₁ q)) ⊆ S\nh₁ : q.succ ∈ S\nh₂ : unrev q ∈ S ∧ ∀ a ∈ trStmts₁ q, a ∈ S\n⊢ Supports (insert q.succ (insert (un... | first | have h₃ := h₂ W | try simp [Finset.subset_iff] at h₂ | Lean.Elab.Tactic.evalFirst | Lean.Parser.Tactic.first |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1179,
"column": 4
} | {
"line": 1179,
"column": 64
} | {
"line": 1180,
"column": 2
} | [
{
"pp": "case pred\nS : Finset Λ'\nW : ∀ {q : Λ'}, q ∈ trStmts₁ q\nq₁ q₂ : Λ'\nq₁_ih : Λ'.Supports S q₁ → trStmts₁ q₁ ⊆ S → Supports (trStmts₁ q₁) S\nq₂_ih : Λ'.Supports S q₂ → trStmts₁ q₂ ⊆ S → Supports (trStmts₁ q₂) S\nH₁ : Λ'.Supports S (q₁.pred q₂)\nHS₁ : insert (q₁.pred q₂) (insert (unrev q₂) (trStmts₁ q₁ ... | [
"case pred\nS : Finset Λ'\nW : ∀ {q : Λ'}, q ∈ trStmts₁ q\nq₁ q₂ : Λ'\nq₁_ih : Λ'.Supports S q₁ → trStmts₁ q₁ ⊆ S → Supports (trStmts₁ q₁) S\nq₂_ih : Λ'.Supports S q₂ → trStmts₁ q₂ ⊆ S → Supports (trStmts₁ q₂) S\nH₁ : Λ'.Supports S (q₁.pred q₂)\nHS₁ : insert (q₁.pred q₂) (insert (unrev q₂) (trStmts₁ q₁ ∪ trStmts₁ q... | first | have h₃ := h₂ W | try simp [Finset.subset_iff] at h₂ | Lean.Elab.Tactic.evalFirst | Lean.Parser.Tactic.first |
Mathlib.Topology.Category.Profinite.Extend | {
"line": 97,
"column": 6
} | {
"line": 97,
"column": 55
} | {
"line": 98,
"column": 4
} | [
{
"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) := ULiftHomULiftCategory.equiv I\nleft✝¹ : Discrete PUnit.{1}\nX : FintypeCat\nf : c.pt ⟶ toPr... | [
"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) := ULiftHomULiftCategory.equiv I\nleft✝² : Discrete PUnit.{1}\nX : FintypeCat\nf : c.pt ⟶ toProfinite.obj ... | ⟨_, (s' : F.obj i ⟶ X), (w' : f = c.π.app i ≫ _)⟩ | Lean.Elab.Tactic.evalIntro | Lean.Parser.Term.anonymousCtor |
Mathlib.Condensed.Discrete.Module | {
"line": 103,
"column": 2
} | {
"line": 103,
"column": 66
} | {
"line": 104,
"column": 2
} | [
{
"pp": "P : TopCat → Prop\nR : Type (u + 1)\ninst✝ : Ring R\nM : ModuleCat R\nthis✝ : (constantSheaf (coherentTopology CompHaus) (Type (u + 1))).Faithful\nthis : (constantSheaf (coherentTopology CompHaus) (Type (u + 1))).Full\n⊢ (discrete (Type (u + 1))).essImage\n ((sheafCompose (coherentTopology CompHaus)... | [
"P : TopCat → Prop\nR : Type (u + 1)\ninst✝ : Ring R\nM : ModuleCat R\nthis✝ : (constantSheaf (coherentTopology CompHaus) (Type (u + 1))).Faithful\nthis : (constantSheaf (coherentTopology CompHaus) (Type (u + 1))).Full\n⊢ CondensedSet.LocallyConstant.functor.essImage\n ((sheafCompose (coherentTopology CompHaus) ... | rw [essImage_eq_of_natIso CondensedSet.LocallyConstant.iso.symm] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Condensed.Discrete.Module | {
"line": 220,
"column": 2
} | {
"line": 220,
"column": 66
} | {
"line": 221,
"column": 2
} | [
{
"pp": "P : TopCat → Prop\nR : Type u\ninst✝ : Ring R\nM : ModuleCat R\nthis✝ : (constantSheaf (coherentTopology LightProfinite) (Type u)).Faithful\nthis : (constantSheaf (coherentTopology LightProfinite) (Type u)).Full\n⊢ (discrete (Type u)).essImage\n ((sheafCompose (coherentTopology LightProfinite) (Cate... | [
"P : TopCat → Prop\nR : Type u\ninst✝ : Ring R\nM : ModuleCat R\nthis✝ : (constantSheaf (coherentTopology LightProfinite) (Type u)).Faithful\nthis : (constantSheaf (coherentTopology LightProfinite) (Type u)).Full\n⊢ LightCondSet.LocallyConstant.functor.essImage\n ((sheafCompose (coherentTopology LightProfinite) ... | rw [essImage_eq_of_natIso LightCondSet.LocallyConstant.iso.symm] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Control.EquivFunctor.Instances | {
"line": 41,
"column": 17
} | {
"line": 41,
"column": 59
} | {
"line": 42,
"column": 2
} | [
{
"pp": "α : Type ?u.4\n⊢ (fun x ↦ Fintype.ofBijective ⇑(Equiv.refl α) ⋯) = id",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"Equiv.instEquivLike",
"Equiv.bijective",
"Fintype.subsingleton",
"id",
"Equiv",
"Fintype.ofBijective",
"funext",
"... | [] | by ext; simp [eq_iff_true_of_subsingleton] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Control.LawfulFix | {
"line": 94,
"column": 4
} | {
"line": 94,
"column": 40
} | {
"line": 95,
"column": 4
} | [
{
"pp": "case pos\nα : Type u_1\nβ : α → Type u_2\nf : ((a : α) → Part (β a)) →o (a : α) → Part (β a)\nx : α\ni : ℕ\nb : β x\nhb : b ∈ approx (⇑f) i x\nb' : β x\nh' : b' ∈ Part.fix (⇑f) x\nhb' : b ∈ Part.fix (⇑f) x\n⊢ b' ∈ approx (⇑f) i x",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
... | [
"case pos\nα : Type u_1\nβ : α → Type u_2\nf : ((a : α) → Part (β a)) →o (a : α) → Part (β a)\nx : α\ni : ℕ\nb' : β x\nh' : b' ∈ Part.fix (⇑f) x\nhb : b' ∈ approx (⇑f) i x\nhb' : b' ∈ Part.fix (⇑f) x\n⊢ b' ∈ approx (⇑f) i x"
] | obtain rfl := Part.mem_unique h' hb' | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Control.Monad.Cont | {
"line": 307,
"column": 29
} | {
"line": 307,
"column": 82
} | {
"line": 307,
"column": 82
} | [
{
"pp": "m : Type u → Type v\nρ : Type u\ninst✝² : Monad m\ninst✝¹ : MonadCont m\ninst✝ : LawfulMonadCont m\nα✝ β✝ : Type u\ndummy✝ : ReaderT ρ m α✝\n⊢ (callCC fun x ↦ dummy✝) = dummy✝",
"ppTerm": "?m.34",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"MonadCont.Label",
"congrArg"... | [
"m : Type u → Type v\nρ : Type u\ninst✝² : Monad m\ninst✝¹ : MonadCont m\ninst✝ : LawfulMonadCont m\nα✝ β✝ : Type u\ndummy✝ : ReaderT ρ m α✝\n⊢ (ReaderT.mk fun r ↦ dummy✝.run r) = dummy✝"
] | simp only [callCC, ReaderT.callCC, @callCC_dummy m _] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.TypeVec | {
"line": 558,
"column": 12
} | {
"line": 558,
"column": 24
} | {
"line": 560,
"column": 0
} | [
{
"pp": "α : TypeVec.{u} 0\nps : α ⟹ «repeat» 0 Prop\n⊢ ∀ (x : Fin2 0), subtypeVal ps x = nilFun x",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"HEq.refl",
"False.elim",
"Fin2.fz",
"noConfusion_of_Nat",
"Fin2.casesOn",
"instOfNatNat",
"Fin2.fs",... | [] | by rintro ⟨⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Analysis.Filter | {
"line": 106,
"column": 89
} | {
"line": 107,
"column": 23
} | {
"line": 109,
"column": 0
} | [
{
"pp": "α : Type u_1\nf : Filter α\nF : f.Realizer\na : Set α\n⊢ a ∈ f ↔ ∃ b, F.F.f b ⊆ a",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Filter.instMembership",
"Filter.Realizer.mk",
"CFilter.toFilter",
"Filter.Realizer.casesOn",
"Iff.rfl",
"Membershi... | [] | by
cases F; subst f; rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Fin.Tuple.BubbleSortInduction | {
"line": 47,
"column": 2
} | {
"line": 47,
"column": 62
} | {
"line": 48,
"column": 2
} | [
{
"pp": "n : ℕ\nα : Type u_1\ninst✝ : LinearOrder α\nf : Fin n → α\nP : (Fin n → α) → Prop\nhf : P f\nh :\n ∀ (σ : Equiv.Perm (Fin n)) (i j : Fin n),\n i < j → (f ∘ ⇑σ) j < (f ∘ ⇑σ) i → P (f ∘ ⇑σ) → P (f ∘ ⇑σ ∘ ⇑(Equiv.swap i j))\nthis : Preorder (Equiv.Perm (Fin n)) := Preorder.lift fun σ ↦ toLex (f ∘ ⇑σ)\... | [
"n : ℕ\nα : Type u_1\ninst✝ : LinearOrder α\nf : Fin n → α\nP : (Fin n → α) → Prop\nhf : P f\nh :\n ∀ (σ : Equiv.Perm (Fin n)) (i j : Fin n),\n i < j → (f ∘ ⇑σ) j < (f ∘ ⇑σ) i → P (f ∘ ⇑σ) → P (f ∘ ⇑σ ∘ ⇑(Equiv.swap i j))\nthis : Preorder (Equiv.Perm (Fin n)) := Preorder.lift fun σ ↦ toLex (f ∘ ⇑σ)\nσ : Fin n ≃... | obtain ⟨i, j, hij₁, hij₂⟩ := antitone_pair_of_not_sorted' hσ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.FinEnum | {
"line": 77,
"column": 60
} | {
"line": 78,
"column": 97
} | {
"line": 80,
"column": 0
} | [
{
"pp": "α : Type u\ninst✝ : FinEnum α\n⊢ (toList α).Nodup",
"ppTerm": "?m.3",
"assigned": true,
"usedConstants": [
"FinEnum.toList",
"Equiv.instEquivLike",
"FinEnum.card",
"id",
"Equiv",
"List.Nodup",
"List.Nodup.map",
"List.nodup_finRange",
"Eq... | [] | by
simp only [toList]; apply List.Nodup.map <;> [apply Equiv.injective; apply List.nodup_finRange] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Lookmap | {
"line": 67,
"column": 17
} | {
"line": 71,
"column": 72
} | {
"line": 73,
"column": 0
} | [
{
"pp": "α : Type u_1\nf g : α → Option α\na : α\nl : List α\nH : ∀ (a_1 : α), a_1 ∈ a :: l → f a_1 = g a_1\n⊢ lookmap f (a :: l) = lookmap g (a :: l)",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"congrArg",
"Option.casesOn",
"Option.some",
"Membership.mem",
... | [] | by
obtain ⟨H₁, H₂⟩ := forall_mem_cons.1 H
rcases h : g a with - | b
· simp [h, H₁.trans h, lookmap_congr H₂]
· simp [lookmap_cons_some _ _ h, lookmap_cons_some _ _ (H₁.trans h)] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Sigma | {
"line": 447,
"column": 12
} | {
"line": 447,
"column": 24
} | {
"line": 447,
"column": 24
} | [
{
"pp": "α : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nhd : Sigma β\ntl : List (Sigma β)\nih : a ∈ tl.keys → ∃ b l₁ l₂, ¬a ∈ l₁.keys ∧ tl = l₁ ++ ⟨a, b⟩ :: l₂ ∧ kerase a tl = l₁ ++ l₂\ne : ¬a = hd.fst\nh : a ∈ tl.keys\nb : β a\ntl₁ tl₂ : List (Sigma β)\nh₁ : ¬a ∈ tl₁.keys\nh₂ : tl = tl₁ ++ ⟨a, b⟩ ::... | [] | simp [e, h₃] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.List.Sigma | {
"line": 447,
"column": 12
} | {
"line": 447,
"column": 24
} | {
"line": 447,
"column": 24
} | [
{
"pp": "α : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nhd : Sigma β\ntl : List (Sigma β)\nih : a ∈ tl.keys → ∃ b l₁ l₂, ¬a ∈ l₁.keys ∧ tl = l₁ ++ ⟨a, b⟩ :: l₂ ∧ kerase a tl = l₁ ++ l₂\ne : ¬a = hd.fst\nh : a ∈ tl.keys\nb : β a\ntl₁ tl₂ : List (Sigma β)\nh₁ : ¬a ∈ tl₁.keys\nh₂ : tl = tl₁ ++ ⟨a, b⟩ ::... | [] | simp [e, h₃] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Sigma | {
"line": 447,
"column": 12
} | {
"line": 447,
"column": 24
} | {
"line": 447,
"column": 24
} | [
{
"pp": "α : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\nhd : Sigma β\ntl : List (Sigma β)\nih : a ∈ tl.keys → ∃ b l₁ l₂, ¬a ∈ l₁.keys ∧ tl = l₁ ++ ⟨a, b⟩ :: l₂ ∧ kerase a tl = l₁ ++ l₂\ne : ¬a = hd.fst\nh : a ∈ tl.keys\nb : β a\ntl₁ tl₂ : List (Sigma β)\nh₁ : ¬a ∈ tl₁.keys\nh₂ : tl = tl₁ ++ ⟨a, b⟩ ::... | [] | simp [e, h₃] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.Functor | {
"line": 164,
"column": 34
} | {
"line": 164,
"column": 83
} | {
"line": 164,
"column": 84
} | [
{
"pp": "inst✝ : (P : Prop) → Decidable P\nα✝ β✝ γ✝ : Type u_1\ns : Finset α✝\nf : α✝ → Finset β✝\ng : β✝ → Finset γ✝\n⊢ s >>= f >>= g = s >>= fun x ↦ f x >>= g",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"Lattice.toSemilatticeSup",
"congrArg",
"Finset",
"Finset... | [] | simp only [bind, sup_eq_biUnion, biUnion_biUnion] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Finset.Functor | {
"line": 164,
"column": 34
} | {
"line": 164,
"column": 83
} | {
"line": 164,
"column": 84
} | [
{
"pp": "inst✝ : (P : Prop) → Decidable P\nα✝ β✝ γ✝ : Type u_1\ns : Finset α✝\nf : α✝ → Finset β✝\ng : β✝ → Finset γ✝\n⊢ s >>= f >>= g = s >>= fun x ↦ f x >>= g",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"Lattice.toSemilatticeSup",
"congrArg",
"Finset",
"Finset... | [] | simp only [bind, sup_eq_biUnion, biUnion_biUnion] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finset.Functor | {
"line": 164,
"column": 34
} | {
"line": 164,
"column": 83
} | {
"line": 164,
"column": 84
} | [
{
"pp": "inst✝ : (P : Prop) → Decidable P\nα✝ β✝ γ✝ : Type u_1\ns : Finset α✝\nf : α✝ → Finset β✝\ng : β✝ → Finset γ✝\n⊢ s >>= f >>= g = s >>= fun x ↦ f x >>= g",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"Lattice.toSemilatticeSup",
"congrArg",
"Finset",
"Finset... | [] | simp only [bind, sup_eq_biUnion, biUnion_biUnion] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.NatDivisors | {
"line": 71,
"column": 14
} | {
"line": 71,
"column": 58
} | {
"line": 71,
"column": 58
} | [
{
"pp": "m n : ℕ\nhmn : m.Coprime n\n⊢ image (fun p ↦ p.1 * p.2) (image Subtype.val (m.divisors ×ˢ n.divisors).attach) =\n map { toFun := fun p ↦ (↑p).1 * (↑p).2, inj' := ⋯ } (m.divisors ×ˢ n.divisors).attach",
"ppTerm": "?m.102",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.h... | [
"m n : ℕ\nhmn : m.Coprime n\n⊢ image ((fun p ↦ p.1 * p.2) ∘ Subtype.val) (m.divisors ×ˢ n.divisors).attach =\n image (⇑{ toFun := fun p ↦ (↑p).1 * (↑p).2, inj' := ⋯ }) (m.divisors ×ˢ n.divisors).attach"
] | rw [Finset.map_eq_image, Finset.image_image] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Finsupp.Sigma | {
"line": 52,
"column": 4
} | {
"line": 54,
"column": 30
} | {
"line": 55,
"column": 2
} | [
{
"pp": "case pos\nκ : Type u_1\nι : κ → Type u_2\nM : Type u_3\ninst✝¹ : Zero M\ninst✝ : DecidableEq κ\nk✝ : κ\nf : ι k✝ →₀ M\nk : κ\ni : ι k\nh : ⟨k, i⟩.fst = k✝\n⊢ f.embSigma ⟨k, i⟩ = f (h ▸ ⟨k, i⟩.snd)",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"... | [] | subst h
simp only [embSigma, Embedding.sigmaMk]
apply embDomain_apply_self | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Finsupp.Sigma | {
"line": 52,
"column": 4
} | {
"line": 54,
"column": 30
} | {
"line": 55,
"column": 2
} | [
{
"pp": "case pos\nκ : Type u_1\nι : κ → Type u_2\nM : Type u_3\ninst✝¹ : Zero M\ninst✝ : DecidableEq κ\nk✝ : κ\nf : ι k✝ →₀ M\nk : κ\ni : ι k\nh : ⟨k, i⟩.fst = k✝\n⊢ f.embSigma ⟨k, i⟩ = f (h ▸ ⟨k, i⟩.snd)",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"Finsupp.instFunLike",
"... | [] | subst h
simp only [embSigma, Embedding.sigmaMk]
apply embDomain_apply_self | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Int.Lemmas | {
"line": 52,
"column": 61
} | {
"line": 52,
"column": 82
} | {
"line": 52,
"column": 82
} | [
{
"pp": "a b : ℤ\nha : 0 ≤ a\nhb : 0 ≤ b\n⊢ a.natAbs = b.natAbs ↔ a ^ 2 = b ^ 2",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"instOfNatNat",
"Int",
"NPow.toPow",
"Int.instMonoid",
"Int.natAbs_eq_iff_sq_eq",
... | [
"a b : ℤ\nha : 0 ≤ a\nhb : 0 ≤ b\n⊢ a.natAbs = b.natAbs ↔ a.natAbs = b.natAbs"
] | ← natAbs_eq_iff_sq_eq | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.LawfulXor.Basic | {
"line": 33,
"column": 49
} | {
"line": 33,
"column": 68
} | {
"line": 33,
"column": 69
} | [
{
"pp": "α : Type u_1\ninst✝² : XorOp α\ninst✝¹ : Zero α\ninst✝ : LawfulXor α\na : α\n⊢ 0 ^^^ a = a",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"LawfulXor.xor_comm",
"HXor.hXor",
"Zero.toOfNat0",
"OfNat.ofNat",
... | [
"α : Type u_1\ninst✝² : XorOp α\ninst✝¹ : Zero α\ninst✝ : LawfulXor α\na : α\n⊢ a ^^^ 0 = a"
] | LawfulXor.xor_comm, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Int.CardIntervalMod | {
"line": 116,
"column": 2
} | {
"line": 117,
"column": 69
} | {
"line": 119,
"column": 0
} | [
{
"pp": "a b r : ℕ\nhr : 0 < r\nv : ℕ\n⊢ ↑(#({x ∈ Ico a b | x ≡ v [MOD r]})) = max (⌈(↑b - ↑v) / ↑r⌉ - ⌈(↑a - ↑v) / ↑r⌉) 0",
"ppTerm": "?m.45",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Int.cast",
"Rat.instSub",
"Eq.mpr",
"Int.cast_natCast",
"Preorder.toLT"... | [] | simp_rw [← Ico_filter_modEq_cast _ _ ▸ card_map _,
Int.Ico_filter_modEq_card _ _ (cast_lt.mpr hr), Int.cast_natCast] | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | Mathlib.Tactic.tacticSimp_rw___ |
Mathlib.Data.Int.CardIntervalMod | {
"line": 116,
"column": 2
} | {
"line": 117,
"column": 69
} | {
"line": 119,
"column": 0
} | [
{
"pp": "a b r : ℕ\nhr : 0 < r\nv : ℕ\n⊢ ↑(#({x ∈ Ico a b | x ≡ v [MOD r]})) = max (⌈(↑b - ↑v) / ↑r⌉ - ⌈(↑a - ↑v) / ↑r⌉) 0",
"ppTerm": "?m.45",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Int.cast",
"Rat.instSub",
"Eq.mpr",
"Int.cast_natCast",
"Preorder.toLT"... | [] | simp_rw [← Ico_filter_modEq_cast _ _ ▸ card_map _,
Int.Ico_filter_modEq_card _ _ (cast_lt.mpr hr), Int.cast_natCast] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Int.CardIntervalMod | {
"line": 116,
"column": 2
} | {
"line": 117,
"column": 69
} | {
"line": 119,
"column": 0
} | [
{
"pp": "a b r : ℕ\nhr : 0 < r\nv : ℕ\n⊢ ↑(#({x ∈ Ico a b | x ≡ v [MOD r]})) = max (⌈(↑b - ↑v) / ↑r⌉ - ⌈(↑a - ↑v) / ↑r⌉) 0",
"ppTerm": "?m.45",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Int.cast",
"Rat.instSub",
"Eq.mpr",
"Int.cast_natCast",
"Preorder.toLT"... | [] | simp_rw [← Ico_filter_modEq_cast _ _ ▸ card_map _,
Int.Ico_filter_modEq_card _ _ (cast_lt.mpr hr), Int.cast_natCast] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.TakeWhile | {
"line": 53,
"column": 4
} | {
"line": 53,
"column": 18
} | {
"line": 54,
"column": 4
} | [
{
"pp": "case cons\nα : Type u_1\np : α → Bool\nhd : α\ntl : List α\n⊢ dropWhile p (hd :: tl) = hd :: tl ↔ ∀ (hl : 0 < (hd :: tl).length), ¬p (hd :: tl)[0] = true",
"ppTerm": "?cons",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"List.filter.match_1",
"id",
... | [
"case cons\nα : Type u_1\np : α → Bool\nhd : α\ntl : List α\n⊢ (match p hd with\n | true => dropWhile p tl\n | false => hd :: tl) =\n hd :: tl ↔\n ∀ (hl : 0 < (hd :: tl).length), ¬p (hd :: tl)[0] = true"
] | rw [dropWhile] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.List.TakeWhile | {
"line": 90,
"column": 70
} | {
"line": 93,
"column": 95
} | {
"line": 95,
"column": 0
} | [
{
"pp": "α : Type u_1\np q : α → Bool\nl : List α\n⊢ takeWhile p (takeWhile q l) = takeWhile (fun a ↦ decide (p a = true ∧ q a = true)) l",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"False",
"List.takeWhile_cons_of_neg",
"instDecidableTrue",
"and_true",
"Li... | [] | by
induction l with
| nil => simp
| cons hd tl IH => by_cases hp : p hd <;> by_cases hq : q hd <;> simp [takeWhile, hp, hq, IH] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Palindrome | {
"line": 52,
"column": 2
} | {
"line": 52,
"column": 13
} | {
"line": 52,
"column": 14
} | [
{
"pp": "α : Type u_1\nl : List α\np : l.Palindrome\n⊢ l.reverse = l",
"ppTerm": "?m.4",
"assigned": true,
"usedConstants": [
"List.Palindrome.rec",
"List.Palindrome",
"List",
"List.reverse",
"Eq"
],
"usedFVars": [
"α",
"l",
"p"
],
"use... | [
"case nil\nα : Type u_1\nl : List α\n⊢ [].reverse = []",
"case singleton\nα : Type u_1\nl : List α\nx✝ : α\n⊢ [x✝].reverse = [x✝]",
"case cons_concat\nα : Type u_1\nl : List α\nx✝ : α\nl✝ : List α\na✝ : l✝.Palindrome\na_ih✝ : l✝.reverse = l✝\n⊢ (x✝ :: (l✝ ++ [x✝])).reverse = x✝ :: (l✝ ++ [x✝])"
] | induction p | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.List.Shortlex | {
"line": 64,
"column": 39
} | {
"line": 65,
"column": 24
} | {
"line": 67,
"column": 0
} | [
{
"pp": "α : Type u_1\nr : α → α → Prop\ns t : List α\nh : s.length = t.length\n⊢ Shortlex r s t ↔ Lex r s t",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"False",
"congrArg",
"lt_self_iff_false._simp_1",
"false_or",
"iff_self",
"And",
"Iff",
... | [] | by
simp [shortlex_def, h] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Multiset.DershowitzManna | {
"line": 161,
"column": 2
} | {
"line": 161,
"column": 9
} | {
"line": 162,
"column": 2
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\n⊢ TransGen OneStep = IsDershowitzMannaLT",
"ppTerm": "?m.7",
"assigned": true,
"usedConstants": [
"Multiset",
"funext",
"Multiset.IsDershowitzMannaLT",
"Relation.TransGen",
"propext",
"_private.Mathlib.Data.Multiset.Dersh... | [
"α : Type u_1\ninst✝ : Preorder α\nM N : Multiset α\n⊢ TransGen OneStep M N ↔ M.IsDershowitzMannaLT N"
] | ext M N | _private.Lean.Elab.Tactic.Ext.0.Lean.Elab.Tactic.Ext.evalExt | Lean.Elab.Tactic.Ext.ext |
Mathlib.Data.Num.Prime | {
"line": 95,
"column": 8
} | {
"line": 95,
"column": 96
} | {
"line": 96,
"column": 8
} | [
{
"pp": "case refine_1\nn : PosNum\n⊢ 2 ≤ ↑n.bit0",
"ppTerm": "?refine_1",
"assigned": true,
"usedConstants": [
"castPosNum",
"Nat.instIsOrderedAddMonoid",
"Nat.instOne",
"Nat.succ_le_of_lt",
"covariant_swap_add_of_covariant_add",
"add_le_add",
"Preorder.toL... | [
"case refine_2\nn : PosNum\n⊢ ↑n.bit0 = (↑n.bit0).minFac ↔ n = 1"
] | · exact add_le_add (Nat.succ_le_of_lt (to_nat_pos _)) (Nat.succ_le_of_lt (to_nat_pos _)) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Ordmap.Ordnode | {
"line": 267,
"column": 6
} | {
"line": 278,
"column": 49
} | {
"line": 280,
"column": 0
} | [
{
"pp": "case node.node\nα : Type u_1\nl : Ordnode α\nx : α\nr : Ordnode α\nls : ℕ\nl✝ : Ordnode α\nx✝ : α\nr✝ : Ordnode α\nrs : ℕ\nrl : Ordnode α\nrx : α\nrr : Ordnode α\n⊢ Ordnode α",
"ppTerm": "?node.node",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"Ordnode",
"id",
... | [] | refine if rs > delta * ls then ?_ else node (ls + rs + 1) l x r
rcases id rr with _ | rrs
· exact nil
--should not happen
rcases id rl with _ | ⟨rls, rll, rlx, rlr⟩
· exact nil
--should not happen
exact
if rls < ratio * rrs then node (ls + rs + 1) (node (ls + rls + 1) l... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Ordmap.Ordnode | {
"line": 267,
"column": 6
} | {
"line": 278,
"column": 49
} | {
"line": 280,
"column": 0
} | [
{
"pp": "case node.node\nα : Type u_1\nl : Ordnode α\nx : α\nr : Ordnode α\nls : ℕ\nl✝ : Ordnode α\nx✝ : α\nr✝ : Ordnode α\nrs : ℕ\nrl : Ordnode α\nrx : α\nrr : Ordnode α\n⊢ Ordnode α",
"ppTerm": "?node.node",
"assigned": true,
"usedConstants": [
"HMul.hMul",
"Ordnode",
"id",
... | [] | refine if rs > delta * ls then ?_ else node (ls + rs + 1) l x r
rcases id rr with _ | rrs
· exact nil
--should not happen
rcases id rl with _ | ⟨rls, rll, rlx, rlr⟩
· exact nil
--should not happen
exact
if rls < ratio * rrs then node (ls + rs + 1) (node (ls + rls + 1) l... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Nth | {
"line": 403,
"column": 10
} | {
"line": 403,
"column": 12
} | {
"line": 404,
"column": 2
} | [
{
"pp": "p : ℕ → Prop\ninst✝ : DecidablePred p\nk a : ℕ\n⊢ a ∈ {n ∈ range (nth p (k + 1)) | p n} → a ∈ insert (nth p k) ({n ∈ range (nth p k) | p n})",
"ppTerm": "?m.26",
"assigned": true,
"usedConstants": [
"Finset",
"Membership.mem",
"instOfNatNat",
"Finset.range",
"i... | [
"p : ℕ → Prop\ninst✝ : DecidablePred p\nk a : ℕ\nha : a ∈ {n ∈ range (nth p (k + 1)) | p n}\n⊢ a ∈ insert (nth p k) ({n ∈ range (nth p k) | p n})"
] | ha | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.Data.Nat.Nth | {
"line": 452,
"column": 70
} | {
"line": 452,
"column": 91
} | {
"line": 452,
"column": 91
} | [
{
"pp": "p : ℕ → Prop\ninst✝ : DecidablePred p\nn : ℕ\nhn : ∀ (hf : (Set.ofPred p).Finite), n < #hf.toFinset\n⊢ (n + if p (nth p n) then 1 else 0) = n + 1",
"ppTerm": "?m.31",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Nat.nth_mem",
"id",
"instOfNatNat"... | [
"p : ℕ → Prop\ninst✝ : DecidablePred p\nn : ℕ\nhn : ∀ (hf : (Set.ofPred p).Finite), n < #hf.toFinset\n⊢ n + 1 = n + 1"
] | if_pos (nth_mem _ hn) | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PFunctor.Univariate.Basic | {
"line": 192,
"column": 4
} | {
"line": 194,
"column": 14
} | {
"line": 195,
"column": 2
} | [
{
"pp": "case mp\nP : PFunctor.{uA, uB}\nα : Type u\np : α → Prop\na : P.A\nf : P.B a → α\nh : ∃ a_1 f_1, ⟨a, f⟩ = ⟨a_1, f_1⟩ ∧ ∀ (i : P.B a_1), p (f_1 i)\n⊢ ∀ (i : P.B a), p (f i)",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"PFunctor.A",
"PFunctor.Obj",
"HEq.refl",
... | [] | rcases h with ⟨a', f', heq, h'⟩
cases heq
assumption | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.PFunctor.Univariate.Basic | {
"line": 192,
"column": 4
} | {
"line": 194,
"column": 14
} | {
"line": 195,
"column": 2
} | [
{
"pp": "case mp\nP : PFunctor.{uA, uB}\nα : Type u\np : α → Prop\na : P.A\nf : P.B a → α\nh : ∃ a_1 f_1, ⟨a, f⟩ = ⟨a_1, f_1⟩ ∧ ∀ (i : P.B a_1), p (f_1 i)\n⊢ ∀ (i : P.B a), p (f i)",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"PFunctor.A",
"PFunctor.Obj",
"HEq.refl",
... | [] | rcases h with ⟨a', f', heq, h'⟩
cases heq
assumption | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.ZNum | {
"line": 169,
"column": 8
} | {
"line": 169,
"column": 13
} | {
"line": 169,
"column": 14
} | [
{
"pp": "α : Type u_1\ninst✝ : AddGroupWithOne α\na b : PosNum\n⊢ ↑(a.bit0.sub' b.bit0) = ↑a.bit0 - ↑b.bit0",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"castZNum",
"NegZeroClass.toNeg",
"castPosNum",
"AddMono... | [
"α : Type u_1\ninst✝ : AddGroupWithOne α\na b : PosNum\n⊢ ↑(a.sub' b).bit0 = ↑a.bit0 - ↑b.bit0"
] | sub', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.ZNum | {
"line": 173,
"column": 8
} | {
"line": 173,
"column": 13
} | {
"line": 173,
"column": 14
} | [
{
"pp": "α : Type u_1\ninst✝ : AddGroupWithOne α\na b : PosNum\n⊢ ↑(a.bit0.sub' b.bit1) = ↑a.bit0 - ↑b.bit1",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"castZNum",
"NegZeroClass.toNeg",
"castPosNum",
"AddMono... | [
"α : Type u_1\ninst✝ : AddGroupWithOne α\na b : PosNum\n⊢ ↑(a.sub' b).bitm1 = ↑a.bit0 - ↑b.bit1"
] | sub', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.ZNum | {
"line": 178,
"column": 8
} | {
"line": 178,
"column": 13
} | {
"line": 178,
"column": 14
} | [
{
"pp": "α : Type u_1\ninst✝ : AddGroupWithOne α\na b : PosNum\n⊢ ↑(a.bit1.sub' b.bit0) = ↑a.bit1 - ↑b.bit0",
"ppTerm": "?m.28",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"castZNum",
"NegZeroClass.toNeg",
"castPosNum",
"ZNum.bi... | [
"α : Type u_1\ninst✝ : AddGroupWithOne α\na b : PosNum\n⊢ ↑(a.sub' b).bit1 = ↑a.bit1 - ↑b.bit0"
] | sub', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.ZNum | {
"line": 183,
"column": 8
} | {
"line": 183,
"column": 13
} | {
"line": 183,
"column": 14
} | [
{
"pp": "α : Type u_1\ninst✝ : AddGroupWithOne α\na b : PosNum\n⊢ ↑(a.bit1.sub' b.bit1) = ↑a.bit1 - ↑b.bit1",
"ppTerm": "?m.32",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"castZNum",
"NegZeroClass.toNeg",
"castPosNum",
"AddMono... | [
"α : Type u_1\ninst✝ : AddGroupWithOne α\na b : PosNum\n⊢ ↑(a.sub' b).bit0 = ↑a.bit1 - ↑b.bit1"
] | sub', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.ZNum | {
"line": 226,
"column": 4
} | {
"line": 228,
"column": 38
} | {
"line": 229,
"column": 2
} | [
{
"pp": "⊢ ZNum.ofInt' (-[0+1] + 1) = ZNum.ofInt' -[0+1] + 1",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"ZNum.ofInt'",
"congrArg",
"id",
"Num.ofNat'_zero",
"instOfNatNat",
"Int",
"Num.toZNum",
"instOneNum",
"ZNum",
... | [] | change ZNum.ofInt' 0 = ZNum.ofInt' (-[0+1]) + 1
dsimp only [ZNum.ofInt', ZNum.ofInt']
rw [ofNat'_succ, ofNat'_zero]; rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.ZNum | {
"line": 226,
"column": 4
} | {
"line": 228,
"column": 38
} | {
"line": 229,
"column": 2
} | [
{
"pp": "⊢ ZNum.ofInt' (-[0+1] + 1) = ZNum.ofInt' -[0+1] + 1",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"ZNum.ofInt'",
"congrArg",
"id",
"Num.ofNat'_zero",
"instOfNatNat",
"Int",
"Num.toZNum",
"instOneNum",
"ZNum",
... | [] | change ZNum.ofInt' 0 = ZNum.ofInt' (-[0+1]) + 1
dsimp only [ZNum.ofInt', ZNum.ofInt']
rw [ofNat'_succ, ofNat'_zero]; rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.PFunctor.Univariate.M | {
"line": 323,
"column": 6
} | {
"line": 323,
"column": 37
} | {
"line": 324,
"column": 6
} | [
{
"pp": "case mpr.succ\nF : PFunctor.{uA, uB}\nn✝ : ℕ\nn_ih : ∀ (x y : F.M), Agree' n✝ x y → Agree (x.approx n✝) (y.approx (n✝ + 1))\nx y : F.M\nh : Agree' (n✝ + 1) x y\n⊢ Agree (x.approx (n✝ + 1)) (y.approx (n✝ + 1 + 1))",
"ppTerm": "?mpr.succ",
"assigned": true,
"usedConstants": [
"PFunctor.... | [
"case mpr.succ.step\nF : PFunctor.{uA, uB}\nn✝ : ℕ\nn_ih : ∀ (x y : F.M), Agree' n✝ x y → Agree (x.approx n✝) (y.approx (n✝ + 1))\nx y : F.M\na : F.A\nx' y' : F.B a → F.M\na✝² : ∀ (i : F.B a), Agree' n✝ (x' i) (y' i)\na✝¹ : x = M.mk ⟨a, x'⟩\na✝ : y = M.mk ⟨a, y'⟩\n⊢ Agree (x.approx (n✝ + 1)) (y.approx (n✝ + 1 + 1))... | obtain - | @⟨_, a, x', y'⟩ := h | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.Ordmap.Invariants | {
"line": 341,
"column": 2
} | {
"line": 341,
"column": 33
} | {
"line": 343,
"column": 0
} | [
{
"pp": "case neg\nα : Type u_1\nl : Ordnode α\nx : α\nhl : l.Sized\nsize✝ : ℕ\nl✝ : Ordnode α\nx✝ : α\nr✝ : Ordnode α\nhr : (node size✝ l✝ x✝ r✝).Sized\nh✝ : ¬l✝.size < ratio * r✝.size\n⊢ (l.node4L x l✝ x✝ r✝).Sized",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstants": [
"instOfNatNat",
... | [] | · exact hl.node4L hr.2.1 hr.2.2 | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Ordmap.Invariants | {
"line": 395,
"column": 30
} | {
"line": 395,
"column": 44
} | {
"line": 395,
"column": 44
} | [
{
"pp": "α : Type u_1\nP : α → Prop\n⊢ ∀ (x : α), Emem x nil → P x",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"False.casesOn",
"Ordnode.nil",
"Ordnode.Emem"
],
"usedFVars": [
"α",
"P"
],
"usedGoals": []
}
] | [] | by rintro _ ⟨⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Ordmap.Invariants | {
"line": 399,
"column": 12
} | {
"line": 399,
"column": 24
} | {
"line": 399,
"column": 24
} | [
{
"pp": "α : Type u_1\nP : α → Prop\n⊢ Any P nil → ∃ x, Emem x nil ∧ P x",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Exists",
"False.casesOn",
"Ordnode.Any",
"And",
"Ordnode.nil",
"Ordnode.Emem"
],
"usedFVars": [
"α",
"P"
],
... | [] | by rintro ⟨⟩ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Ordmap.Invariants | {
"line": 417,
"column": 77
} | {
"line": 418,
"column": 66
} | {
"line": 420,
"column": 0
} | [
{
"pp": "α : Type u_1\nP : α → Prop\nl : Ordnode α\nx : α\nm : Ordnode α\ny : α\nr : Ordnode α\n⊢ All P (l.node4L x m y r) ↔ All P l ∧ P x ∧ All P m ∧ P y ∧ All P r",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Ordnode.node'",
"Ordnode.node3L",
"Ordnode",
"congrA... | [] | by
cases m <;> simp [node4L, all_node', All, all_node3L, and_assoc] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.PFunctor.Multivariate.W | {
"line": 118,
"column": 39
} | {
"line": 118,
"column": 76
} | {
"line": 120,
"column": 0
} | [
{
"pp": "n : ℕ\nP : MvPFunctor.{u} (n + 1)\n⊢ MvFunctor P.W",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"MvPFunctor.Obj",
"inferInstance",
"id",
"MvPFunctor.wp",
"MvFunctor",
"MvPFunctor.W",
"MvPFunctor.instMvFunctorObj",
"TypeVec"
],
... | [] | by delta MvPFunctor.W; infer_instance | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.PNat.Find | {
"line": 70,
"column": 2
} | {
"line": 74,
"column": 100
} | {
"line": 76,
"column": 0
} | [
{
"pp": "p : ℕ+ → Prop\ninst✝ : DecidablePred p\nh : ∃ n, p n\nm : ℕ+\n⊢ PNat.find h = m ↔ p m ∧ ∀ (n : ℕ+), n < m → ¬p n",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"PNat.find_spec",
"Preorder.toLT",
"instLinearOrderPNat",
"PartialOrder.toPreorder",
"Preo... | [] | constructor
· rintro rfl
exact ⟨PNat.find_spec h, fun _ => PNat.find_min h⟩
· rintro ⟨hm, hlt⟩
exact le_antisymm (PNat.find_min' h hm) (not_lt.1 <| imp_not_comm.1 (hlt _) <| PNat.find_spec h) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.PNat.Find | {
"line": 70,
"column": 2
} | {
"line": 74,
"column": 100
} | {
"line": 76,
"column": 0
} | [
{
"pp": "p : ℕ+ → Prop\ninst✝ : DecidablePred p\nh : ∃ n, p n\nm : ℕ+\n⊢ PNat.find h = m ↔ p m ∧ ∀ (n : ℕ+), n < m → ¬p n",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"PNat.find_spec",
"Preorder.toLT",
"instLinearOrderPNat",
"PartialOrder.toPreorder",
"Preo... | [] | constructor
· rintro rfl
exact ⟨PNat.find_spec h, fun _ => PNat.find_min h⟩
· rintro ⟨hm, hlt⟩
exact le_antisymm (PNat.find_min' h hm) (not_lt.1 <| imp_not_comm.1 (hlt _) <| PNat.find_spec h) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Ordmap.Invariants | {
"line": 594,
"column": 21
} | {
"line": 594,
"column": 30
} | {
"line": 594,
"column": 31
} | [
{
"pp": "α : Type u_1\nx : α\nls : ℕ\nlx : α\nhr : nil.Balanced\nsr : nil.Sized\nlrs : ℕ\nlrl : Ordnode α\nlrx : α\nlrr : Ordnode α\nhl : (nil.node' lx (node lrs lrl lrx lrr)).Balanced\nsl : (node ls nil lx (node lrs lrl lrx lrr)).Sized\nthis : lrs ≤ 1\n⊢ lrl.size = 0 ∧ lrr.size = 0",
"ppTerm": "?m.688",
... | [
"α : Type u_1\nx : α\nls : ℕ\nlx : α\nhr : nil.Balanced\nsr : nil.Sized\nlrs : ℕ\nlrl : Ordnode α\nlrx : α\nlrr : Ordnode α\nhl : (nil.node' lx (node lrs lrl lrx lrr)).Balanced\nsl : (node ls nil lx (node lrs lrl lrx lrr)).Sized\nthis : lrl.size + lrr.size + 1 ≤ 1\n⊢ lrl.size = 0 ∧ lrr.size = 0"
] | sl.2.2.1, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PSigma.Order | {
"line": 117,
"column": 4
} | {
"line": 117,
"column": 30
} | {
"line": 118,
"column": 4
} | [
{
"pp": "case inl\nι : Type u_1\nα : ι → Type u_2\ninst✝³ : PartialOrder ι\ninst✝² : OrderBot ι\ninst✝¹ : (i : ι) → Preorder (α i)\ninst✝ : OrderBot (α ⊥)\nx✝ : Σₗ' (i : ι), α i\nb : α ⊥\n⊢ ⟨⊥, ⊥⟩ ≤ ⟨⊥, b⟩",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
"OrderBo... | [
"case inr\nι : Type u_1\nα : ι → Type u_2\ninst✝³ : PartialOrder ι\ninst✝² : OrderBot ι\ninst✝¹ : (i : ι) → Preorder (α i)\ninst✝ : OrderBot (α ⊥)\nx✝ : Σₗ' (i : ι), α i\na : ι\nb : α a\nha : ⊥ < a\n⊢ ⟨⊥, ⊥⟩ ≤ ⟨a, b⟩"
] | · exact Lex.right _ bot_le | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.QPF.Multivariate.Basic | {
"line": 109,
"column": 6
} | {
"line": 109,
"column": 19
} | {
"line": 109,
"column": 20
} | [
{
"pp": "n : ℕ\nF : TypeVec.{u} n → Type u_1\nq : MvQPF F\nα : TypeVec.{u} n\nx : F α\n⊢ TypeVec.id <$$> x = x",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"MvQPF.abs_repr",
"id",
"MvQPF.toMvFunctor",
"MvQPF.repr",
"MvQPF.a... | [
"n : ℕ\nF : TypeVec.{u} n → Type u_1\nq : MvQPF F\nα : TypeVec.{u} n\nx : F α\n⊢ TypeVec.id <$$> abs (repr x) = abs (repr x)"
] | ← abs_repr x, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.QPF.Multivariate.Basic | {
"line": 115,
"column": 6
} | {
"line": 115,
"column": 19
} | {
"line": 115,
"column": 20
} | [
{
"pp": "n : ℕ\nF : TypeVec.{u} n → Type u_1\nq : MvQPF F\nα β γ : TypeVec.{u} n\nf : α ⟹ β\ng : β ⟹ γ\nx : F α\n⊢ (g ⊚ f) <$$> x = g <$$> f <$$> x",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"MvQPF.abs_repr",
"id",
"TypeVec.comp",
... | [
"n : ℕ\nF : TypeVec.{u} n → Type u_1\nq : MvQPF F\nα β γ : TypeVec.{u} n\nf : α ⟹ β\ng : β ⟹ γ\nx : F α\n⊢ (g ⊚ f) <$$> abs (repr x) = g <$$> f <$$> abs (repr x)"
] | ← abs_repr x, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Ordmap.Invariants | {
"line": 679,
"column": 4
} | {
"line": 679,
"column": 20
} | {
"line": 681,
"column": 0
} | [
{
"pp": "case inr\nk n : ℕ\n⊢ Raised (k + n) (k + (n + 1))",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"OfNat.ofNat",
"Eq",
"Or.inr",
"rfl"
],
"usedFVars": [
... | [] | exact Or.inr rfl | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Ordmap.Invariants | {
"line": 679,
"column": 4
} | {
"line": 679,
"column": 20
} | {
"line": 681,
"column": 0
} | [
{
"pp": "case inr\nk n : ℕ\n⊢ Raised (k + n) (k + (n + 1))",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"OfNat.ofNat",
"Eq",
"Or.inr",
"rfl"
],
"usedFVars": [
... | [] | exact Or.inr rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Ordmap.Invariants | {
"line": 679,
"column": 4
} | {
"line": 679,
"column": 20
} | {
"line": 681,
"column": 0
} | [
{
"pp": "case inr\nk n : ℕ\n⊢ Raised (k + n) (k + (n + 1))",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"instOfNatNat",
"instHAdd",
"HAdd.hAdd",
"Nat",
"instAddNat",
"OfNat.ofNat",
"Eq",
"Or.inr",
"rfl"
],
"usedFVars": [
... | [] | exact Or.inr rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Ordmap.Invariants | {
"line": 689,
"column": 4
} | {
"line": 689,
"column": 20
} | {
"line": 691,
"column": 0
} | [
{
"pp": "case inr\nα : Type u_1\nl : Ordnode α\nx₁ x₂ : α\nr₁ r₂ : Ordnode α\n⊢ Raised (l.size + r₁.size + 1) (l.size + (r₁.size + 1) + 1)",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"instOfNatNat",
"Ordnode.size",
"instHAdd",
"HAdd.hAdd",
"Nat",
"ins... | [] | exact Or.inr rfl | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Ordmap.Invariants | {
"line": 689,
"column": 4
} | {
"line": 689,
"column": 20
} | {
"line": 691,
"column": 0
} | [
{
"pp": "case inr\nα : Type u_1\nl : Ordnode α\nx₁ x₂ : α\nr₁ r₂ : Ordnode α\n⊢ Raised (l.size + r₁.size + 1) (l.size + (r₁.size + 1) + 1)",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"instOfNatNat",
"Ordnode.size",
"instHAdd",
"HAdd.hAdd",
"Nat",
"ins... | [] | exact Or.inr rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Ordmap.Invariants | {
"line": 689,
"column": 4
} | {
"line": 689,
"column": 20
} | {
"line": 691,
"column": 0
} | [
{
"pp": "case inr\nα : Type u_1\nl : Ordnode α\nx₁ x₂ : α\nr₁ r₂ : Ordnode α\n⊢ Raised (l.size + r₁.size + 1) (l.size + (r₁.size + 1) + 1)",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"instOfNatNat",
"Ordnode.size",
"instHAdd",
"HAdd.hAdd",
"Nat",
"ins... | [] | exact Or.inr rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Ordmap.Invariants | {
"line": 774,
"column": 26
} | {
"line": 775,
"column": 81
} | {
"line": 775,
"column": 81
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\nt : Ordnode α\no₁ : WithBot α\no₂ : WithTop α\nh : t.dual.Bounded o₂ o₁\n⊢ t.Bounded o₁ o₂",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"OrderDual.Preorder.dual_dual",
"Ordnode",
"congrArg",
"Ordnode.Bounded.dual",
... | [] | by
have := Bounded.dual h; rwa [dual_dual, OrderDual.Preorder.dual_dual] at this | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.QPF.Multivariate.Constructions.Sigma | {
"line": 71,
"column": 13
} | {
"line": 72,
"column": 70
} | {
"line": 74,
"column": 0
} | [
{
"pp": "n : ℕ\nA : Type u\nF : A → TypeVec.{u} n → Type u\ninst✝ : (α : A) → MvQPF (F α)\n⊢ ∀ {α β : TypeVec.{u} n} (f : α ⟹ β) (p : ↑(Sigma.P F) α), Sigma.abs F (f <$$> p) = f <$$> Sigma.abs F p",
"ppTerm": "?m.33",
"assigned": true,
"usedConstants": [
"MvQPF.Sigma.abs",
"MvQPF.Sigma.P... | [] | by rintro α β f ⟨x, g⟩; simp only [Sigma.abs, MvPFunctor.map_eq]
simp only [(· <$$> ·), ← abs_map, ← MvPFunctor.map_eq] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Ordmap.Ordset | {
"line": 601,
"column": 8
} | {
"line": 606,
"column": 24
} | {
"line": 607,
"column": 6
} | [
{
"pp": "α : 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\nt_r_valid : ... | [] | 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 | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Ordmap.Ordset | {
"line": 601,
"column": 8
} | {
"line": 606,
"column": 24
} | {
"line": 607,
"column": 6
} | [
{
"pp": "α : 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\nt_r_valid : ... | [] | 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 | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.QPF.Univariate.Basic | {
"line": 140,
"column": 6
} | {
"line": 141,
"column": 9
} | {
"line": 142,
"column": 4
} | [
{
"pp": "case h.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⊢ x = abs ⟨a, fun i ↦ (↑(f i)).1⟩",
"ppTerm": "?h... | [] | rw [← xeq, ← abs_repr u, h, ← abs_map]
rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.QPF.Univariate.Basic | {
"line": 140,
"column": 6
} | {
"line": 141,
"column": 9
} | {
"line": 142,
"column": 4
} | [
{
"pp": "case h.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⊢ x = abs ⟨a, fun i ↦ (↑(f i)).1⟩",
"ppTerm": "?h... | [] | rw [← xeq, ← abs_repr u, h, ← abs_map]
rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.QPF.Univariate.Basic | {
"line": 271,
"column": 4
} | {
"line": 271,
"column": 74
} | {
"line": 272,
"column": 4
} | [
{
"pp": "F : Type u → Type u\nq : QPF F\na : (P F).A\nf : (P F).B a → (P F).W\n⊢ abs (PFunctor.W.mk ((P F).map fixToW (repr (abs ⟨a, fun x ↦ ⟦f x⟧⟩)))).dest = abs (Wrepr (WType.mk a f)).dest",
"ppTerm": "?m.50",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"PFunctor.W.dest_mk",
"... | [
"F : Type u → Type u\nq : QPF F\na : (P F).A\nf : (P F).B a → (P F).W\n⊢ abs ⟨a, fixToW ∘ fun x ↦ ⟦f x⟧⟩ = abs (Wrepr (WType.mk a f)).dest"
] | rw [PFunctor.W.dest_mk, abs_map, abs_repr, ← abs_map, PFunctor.map_eq] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.QPF.Multivariate.Constructions.Fix | {
"line": 283,
"column": 2
} | {
"line": 292,
"column": 13
} | {
"line": 294,
"column": 0
} | [
{
"pp": "case ih\nn : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nα : TypeVec.{u} n\np : Fix F α → Prop\nh : ∀ (x : F (α ::: Fix F α)), LiftP (α.PredLast p) x → p (mk x)\na✝¹ : (P F).A\nf'✝ : (P F).drop.B a✝¹ ⟹ α\nf✝ : (P F).last.B a✝¹ → (P F).W α\na✝ : ∀ (i : (P F).last.B a✝¹), p (Quot.mk (⇑(wSetoid α)) ... | [] | case ih a f' f ih =>
change p ⟦q.P.wMk a f' f⟧
rw [← Fix.ind_aux a f' f]
apply h
rw [MvQPF.liftP_iff]
refine ⟨_, _, rfl, ?_⟩
intro i j
cases i
· apply ih
· trivial | Lean.Elab.Tactic.evalCase | Lean.Parser.Tactic.case |
Mathlib.Data.QPF.Multivariate.Constructions.Cofix | {
"line": 380,
"column": 11
} | {
"line": 380,
"column": 38
} | {
"line": 380,
"column": 39
} | [
{
"pp": "case h₀\nn : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nlawful : LawfulMvFunctor F\nα : TypeVec.{u} n\nι ι' : Type u\nR : ι' → ι' → Prop\nx : F (α ::: ι)\nf g : ι → ι'\nhh : ∀ (x : ι), R (f x) (g x)\nh : ι → { x // uncurry R x } := fun x ↦ ⟨(f x, g x), ⋯⟩\nb : α ::: ι ⟹ Subtype_ α.repeatEq ::: {... | [
"case h₀\nn : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nlawful : LawfulMvFunctor F\nα : TypeVec.{u} n\nι ι' : Type u\nR : ι' → ι' → Prop\nx : F (α ::: ι)\nf g : ι → ι'\nhh : ∀ (x : ι), R (f x) (g x)\nh : ι → { x // uncurry R x } := fun x ↦ ⟨(f x, g x), ⋯⟩\nb : α ::: ι ⟹ Subtype_ α.repeatEq ::: { x // uncurr... | toSubtype_of_subtype_assoc, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.WSeq.Relation | {
"line": 101,
"column": 6
} | {
"line": 101,
"column": 22
} | {
"line": 101,
"column": 23
} | [
{
"pp": "α : Type u\nβ : Type v\nR : α → β → Prop\ns1 : WSeq α\ns2 : WSeq β\nh✝ : LiftRel R s1 s2\ns : WSeq β\nt : WSeq α\nh : LiftRel R t s\n⊢ Computation.LiftRel (LiftRelO (swap R) (swap (LiftRel R))) s.destruct t.destruct",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"Eq.mpr",
... | [
"α : Type u\nβ : Type v\nR : α → β → Prop\ns1 : WSeq α\ns2 : WSeq β\nh✝ : LiftRel R s1 s2\ns : WSeq β\nt : WSeq α\nh : LiftRel R t s\n⊢ Computation.LiftRel (swap (LiftRelO R (LiftRel R))) s.destruct t.destruct"
] | ← LiftRelO.swap, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Set.Enumerate | {
"line": 85,
"column": 6
} | {
"line": 85,
"column": 54
} | {
"line": 86,
"column": 6
} | [
{
"pp": "case zero.succ\nα : Type u_1\nsel : Set α → Option α\na : α\nh_sel : ∀ (s : Set α) (a : α), sel s = some a → a ∈ s\ns : Set α\nh₁ : enumerate sel s 0 = some a\nm : ℕ\nh₂ : enumerate sel s (0 + (m + 1)) = some a\nh' : enumerate sel (s \\ {a}) m = some a\n⊢ 0 = 0 + (m + 1)",
"ppTerm": "?zero.succ",
... | [
"case zero.succ\nα : Type u_1\nsel : Set α → Option α\na : α\nh_sel : ∀ (s : Set α) (a : α), sel s = some a → a ∈ s\ns : Set α\nh₁ : enumerate sel s 0 = some a\nm : ℕ\nh₂ : enumerate sel s (0 + (m + 1)) = some a\nh' : enumerate sel (s \\ {a}) m = some a\nthis : a ∈ s \\ {a}\n⊢ 0 = 0 + (m + 1)"
] | have : a ∈ s \ {a} := enumerate_mem sel h_sel h' | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.WSeq.Relation | {
"line": 338,
"column": 6
} | {
"line": 347,
"column": 39
} | {
"line": 347,
"column": 39
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\nδ : Type u_1\nR : α → β → Prop\nS : γ → δ → Prop\ns1✝ : WSeq α\ns2✝ : WSeq β\nf1 : α → γ\nf2 : β → δ\nh1 : LiftRel R s1✝ s2✝\nh2 : ∀ {a : α} {b : β}, R a b → S (f1 a) (f2 b)\ns1 : WSeq γ\ns2 : WSeq δ\nh✝ : (fun s1 s2 ↦ ∃ s t, s1 = map f1 s ∧ s2 = map f2 t ∧ LiftRel R... | [] | simp only [exists_and_left, destruct_map]
apply Computation.liftRel_map _ _ (liftRel_destruct h)
intro o p h
rcases o with - | a <;> rcases p with - | b
· simp
· cases b; cases h
· cases a; cases h
· obtain ⟨a, s⟩ := a; obtain ⟨b, t⟩ := b
obtain ⟨r, h⟩ := h
exac... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.WSeq.Relation | {
"line": 338,
"column": 6
} | {
"line": 347,
"column": 39
} | {
"line": 347,
"column": 39
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\nδ : Type u_1\nR : α → β → Prop\nS : γ → δ → Prop\ns1✝ : WSeq α\ns2✝ : WSeq β\nf1 : α → γ\nf2 : β → δ\nh1 : LiftRel R s1✝ s2✝\nh2 : ∀ {a : α} {b : β}, R a b → S (f1 a) (f2 b)\ns1 : WSeq γ\ns2 : WSeq δ\nh✝ : (fun s1 s2 ↦ ∃ s t, s1 = map f1 s ∧ s2 = map f2 t ∧ LiftRel R... | [] | simp only [exists_and_left, destruct_map]
apply Computation.liftRel_map _ _ (liftRel_destruct h)
intro o p h
rcases o with - | a <;> rcases p with - | b
· simp
· cases b; cases h
· cases a; cases h
· obtain ⟨a, s⟩ := a; obtain ⟨b, t⟩ := b
obtain ⟨r, h⟩ := h
exac... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.WSeq.Basic | {
"line": 617,
"column": 18
} | {
"line": 617,
"column": 40
} | {
"line": 617,
"column": 41
} | [
{
"pp": "α : Type u\nl : List α\ns✝ : WSeq α\ns1 s2 : Computation (List α)\nl' : List α\ns : WSeq α\nh :\n s1 =\n Computation.corec\n (fun x ↦\n match x with\n | (l, s) =>\n match Seq.destruct s with\n | none => Sum.inl l.reverse\n | some (none, s'... | [
"case refine_1\nα : Type u\nl : List α\ns✝ : WSeq α\ns1 s2 : Computation (List α)\nl' : List α\ns : WSeq α\nh :\n s1 =\n Computation.corec\n (fun x ↦\n match x with\n | (l, s) =>\n match Seq.destruct s with\n | none => Sum.inl l.reverse\n | some (none,... | refine ⟨l', s, ?_, ?_⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Seq.Parallel | {
"line": 212,
"column": 10
} | {
"line": 215,
"column": 30
} | {
"line": 216,
"column": 10
} | [
{
"pp": "case inr.inr.inl\nα : Type u\nS : WSeq (Computation α)\na : α\nh✝ : a ∈ parallel S\nF : List (Computation α) → α ⊕ List (Computation α) → Prop :=\n fun l a ↦ Sum.casesOn a (fun a ↦ ∃ c ∈ l, a ∈ c) fun l' ↦ ∀ (a' : α), (∃ c ∈ l', a' ∈ c) → ∃ c ∈ l, a' ∈ c\nc : Computation α\nl val✝ : List (Computation ... | [
"case inr.inr.inr\nα : Type u\nS : WSeq (Computation α)\na : α\nh✝ : a ∈ parallel S\nF : List (Computation α) → α ⊕ List (Computation α) → Prop :=\n fun l a ↦ Sum.casesOn a (fun a ↦ ∃ c ∈ l, a ∈ c) fun l' ↦ ∀ (a' : α), (∃ c ∈ l', a' ∈ c) → ∃ c ∈ l, a' ∈ c\nc : Computation α\nl val✝ : List (Computation α)\nIH : F l... | · rw [e] at ad
refine ⟨c, List.mem_cons_self, ?_⟩
rw [destruct_eq_think h]
exact think_mem ad | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Sigma.Order | {
"line": 192,
"column": 4
} | {
"line": 192,
"column": 32
} | {
"line": 193,
"column": 4
} | [
{
"pp": "case inl\nι : Type u_1\nα : ι → Type u_2\ninst✝³ : PartialOrder ι\ninst✝² : OrderTop ι\ninst✝¹ : (i : ι) → Preorder (α i)\ninst✝ : OrderTop (α ⊤)\nx✝ : Σₗ (i : ι), α i\nb : α ⊤\n⊢ ⟨⊤, b⟩ ≤ ⟨⊤, ⊤⟩",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
"PartialO... | [
"case inr\nι : Type u_1\nα : ι → Type u_2\ninst✝³ : PartialOrder ι\ninst✝² : OrderTop ι\ninst✝¹ : (i : ι) → Preorder (α i)\ninst✝ : OrderTop (α ⊤)\nx✝ : Σₗ (i : ι), α i\na : ι\nb : α a\nha : a < ⊤\n⊢ ⟨a, b⟩ ≤ ⟨⊤, ⊤⟩"
] | · exact Lex.right _ _ le_top | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.MeasureTheory.Measure.ContinuousPreimage | {
"line": 67,
"column": 59
} | {
"line": 67,
"column": 61
} | {
"line": 68,
"column": 4
} | [
{
"pp": "α : Type u_1\nX : Type u_2\nY : Type u_3\ninst✝⁹ : TopologicalSpace X\ninst✝⁸ : MeasurableSpace X\ninst✝⁷ : BorelSpace X\ninst✝⁶ : R1Space X\ninst✝⁵ : TopologicalSpace Y\ninst✝⁴ : MeasurableSpace Y\ninst✝³ : BorelSpace Y\ninst✝² : R1Space Y\nμ : Measure X\nν : Measure Y\ninst✝¹ : μ.InnerRegularCompactL... | [
"α : Type u_1\nX : Type u_2\nY : Type u_3\ninst✝⁹ : TopologicalSpace X\ninst✝⁸ : MeasurableSpace X\ninst✝⁷ : BorelSpace X\ninst✝⁶ : R1Space X\ninst✝⁵ : TopologicalSpace Y\ninst✝⁴ : MeasurableSpace Y\ninst✝³ : BorelSpace Y\ninst✝² : R1Space Y\nμ : Measure X\nν : Measure Y\ninst✝¹ : μ.InnerRegularCompactLTTop\ninst✝ ... | ha | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | {
"line": 644,
"column": 18
} | {
"line": 644,
"column": 74
} | {
"line": 645,
"column": 6
} | [
{
"pp": "f : CircleDeg1Lift\nn : ℕ\n⊢ τ (f ^ n * f) = ↑(n + 1) * τ f",
"ppTerm": "?m.38",
"assigned": true,
"usedConstants": [
"CircleDeg1Lift.translationNumber_mul_of_commute",
"Eq.mpr",
"Real",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"CircleDeg1Li... | [
"f : CircleDeg1Lift\nn : ℕ\n⊢ τ (f ^ n) + τ f = ↑(n + 1) * τ f"
] | translationNumber_mul_of_commute (Commute.pow_self f n), | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.MeasureTheory.Measure.ContinuousPreimage | {
"line": 89,
"column": 97
} | {
"line": 89,
"column": 99
} | {
"line": 92,
"column": 2
} | [
{
"pp": "α : Type u_1\nX : Type u_2\nY : Type u_3\ninst✝⁹ : TopologicalSpace X\ninst✝⁸ : MeasurableSpace X\ninst✝⁷ : BorelSpace X\ninst✝⁶ : R1Space X\ninst✝⁵ : TopologicalSpace Y\ninst✝⁴ : MeasurableSpace Y\ninst✝³ : BorelSpace Y\ninst✝² : R1Space Y\nμ : Measure X\nν : Measure Y\ninst✝¹ : μ.InnerRegularCompactL... | [
"α : Type u_1\nX : Type u_2\nY : Type u_3\ninst✝⁹ : TopologicalSpace X\ninst✝⁸ : MeasurableSpace X\ninst✝⁷ : BorelSpace X\ninst✝⁶ : R1Space X\ninst✝⁵ : TopologicalSpace Y\ninst✝⁴ : MeasurableSpace Y\ninst✝³ : BorelSpace Y\ninst✝² : R1Space Y\nμ : Measure X\nν : Measure Y\ninst✝¹ : μ.InnerRegularCompactLTTop\ninst✝ ... | ha | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.Dynamics.Ergodic.Extreme | {
"line": 35,
"column": 2
} | {
"line": 35,
"column": 36
} | {
"line": 36,
"column": 2
} | [
{
"pp": "X : Type u_1\nm : MeasurableSpace X\nμ : Measure X\nf : X → X\nc : ℝ≥0∞\nhc : c ≠ ∞\nh : μ ∈ extremePoints ℝ≥0∞ {ν | MeasurePreserving f ν ν ∧ ν univ = c}\nhf : MeasurePreserving f μ μ\n⊢ Ergodic f μ",
"ppTerm": "?m.35",
"assigned": true,
"usedConstants": [
"MeasureTheory.MeasurePrese... | [
"case inl\nX : Type u_1\nm : MeasurableSpace X\nμ : Measure X\nf : X → X\nhf : MeasurePreserving f μ μ\nhc : 0 ≠ ∞\nh : μ ∈ extremePoints ℝ≥0∞ {ν | MeasurePreserving f ν ν ∧ ν univ = 0}\n⊢ Ergodic f μ",
"case inr\nX : Type u_1\nm : MeasurableSpace X\nμ : Measure X\nf : X → X\nc : ℝ≥0∞\nhc : c ≠ ∞\nh : μ ∈ extreme... | rcases eq_or_ne c 0 with rfl | hc₀ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Dynamics.OmegaLimit | {
"line": 131,
"column": 67
} | {
"line": 132,
"column": 67
} | {
"line": 134,
"column": 0
} | [
{
"pp": "τ : Type u_1\nα : Type u_2\nβ : Type u_3\ninst✝ : TopologicalSpace β\nf : Filter τ\nϕ : τ → α → β\ns : Set α\ny : β\n⊢ y ∈ ω f ϕ s ↔ ∀ n ∈ 𝓝 y, ∃ᶠ (t : τ) in f, (ϕ t '' s ∩ n).Nonempty",
"ppTerm": "?m.22",
"assigned": true,
"usedConstants": [
"Filter.instMembership",
"omegaLimi... | [] | by
simp_rw [mem_omegaLimit_iff_frequently, image_inter_nonempty_iff] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 218,
"column": 6
} | {
"line": 219,
"column": 95
} | {
"line": 219,
"column": 95
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\nμ ν ν' : Measure α\ninst✝² : μ.HaveLebesgueDecomposition ν\ninst✝¹ : μ.HaveLebesgueDecomposition (ν + ν')\ninst✝ : SigmaFinite ν\nhμν : μ ≪ ν\nhνν' : ν ⟂ₘ ν'\nt : Set α := hνν'.nullSet\nht : MeasurableSet t\n⊢ μ.rnDeriv (ν + ν') =ᵐ[ν.restrict tᶜ] μ.rnDeriv ν",
"... | [
"α : Type u_1\nm : MeasurableSpace α\nμ ν ν' : Measure α\ninst✝² : μ.HaveLebesgueDecomposition ν\ninst✝¹ : μ.HaveLebesgueDecomposition (ν + ν')\ninst✝ : SigmaFinite ν\nhμν : μ ≪ ν\nhνν' : ν ⟂ₘ ν'\nt : Set α := hνν'.nullSet\nht : MeasurableSet t\n⊢ (ν.restrict tᶜ).withDensity (μ.rnDeriv (ν + ν')) = (ν.restrict tᶜ).w... | ← withDensity_eq_iff_of_sigmaFinite (μ := ν.restrict tᶜ)
(Measure.measurable_rnDeriv _ _).aemeasurable (Measure.measurable_rnDeriv _ _).aemeasurable | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Dynamics.TopologicalEntropy.CoverEntropy | {
"line": 153,
"column": 10
} | {
"line": 153,
"column": 63
} | {
"line": 153,
"column": 64
} | [
{
"pp": "case inr\nX : Type u_1\nT : X → X\nU : SetRel X X\nF : Set X\nm : ℕ\nF_inv : MapsTo T F F\ninst✝ : U.IsSymm\nn : ℕ\ns : Finset X\nh : IsDynCoverOf T F U m ↑s\nx✝ : Nonempty X\ns_nemp : (↑s).Nonempty\nx : X\nx_F : x ∈ F\nm_pos : m > 0\nt : Fin n → ↥s\ny z : X\nk : ℕ\nk_mn : k / m < n\ny_int : (T^[k % m]... | [
"case inr\nX : Type u_1\nT : X → X\nU : SetRel X X\nF : Set X\nm : ℕ\nF_inv : MapsTo T F F\ninst✝ : U.IsSymm\nn : ℕ\ns : Finset X\nh : IsDynCoverOf T F U m ↑s\nx✝ : Nonempty X\ns_nemp : (↑s).Nonempty\nx : X\nx_F : x ∈ F\nm_pos : m > 0\nt : Fin n → ↥s\ny z : X\nk : ℕ\nk_mn : k / m < n\ny_int : (T^[k % m] ↑(t ⟨k / m,... | ← Function.iterate_add_apply T (k % m) (m * (k / m)), | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Dynamics.TopologicalEntropy.CoverEntropy | {
"line": 231,
"column": 29
} | {
"line": 231,
"column": 41
} | {
"line": 231,
"column": 41
} | [
{
"pp": "X : Type u_1\nT : X → X\nF : Set X\nU : SetRel X X\nn : ℕ\nh_fin : coverMincard T F U n < ⊤\nk : ℕ\nk_min : ↑k = coverMincard T F U n\nh : ¬Nonempty { s // IsDynCoverOf T F U n ↑s }\n⊢ ⨅ s, ⨅ (_ : IsDynCoverOf T F U n ↑s), ↑(#s) = ⊤",
"ppTerm": "?m.79",
"assigned": true,
"usedConstants": [
... | [
"X : Type u_1\nT : X → X\nF : Set X\nU : SetRel X X\nn : ℕ\nh_fin : coverMincard T F U n < ⊤\nk : ℕ\nk_min : ↑k = coverMincard T F U n\nh : ¬Nonempty { s // IsDynCoverOf T F U n ↑s }\n⊢ ∀ (i : Finset X), IsDynCoverOf T F U n ↑i → ↑(#i) = ⊤"
] | iInf₂_eq_top | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Dynamics.TopologicalEntropy.NetEntropy | {
"line": 168,
"column": 2
} | {
"line": 168,
"column": 30
} | {
"line": 170,
"column": 0
} | [
{
"pp": "X : Type u_1\nT : X → X\nF : Set X\nU : SetRel X X\nn : ℕ\nh : netMaxcard T F U n = 0\nx : X\nx_F : x ∈ F\nkey : 1 ≤ 0\n⊢ False",
"ppTerm": "?m.67",
"assigned": true,
"usedConstants": [
"instCompleteLinearOrderENat",
"instCharZeroENat",
"instAddMonoidWithOneENat",
"C... | [] | exact key.not_gt zero_lt_one | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Dynamics.TopologicalEntropy.NetEntropy | {
"line": 222,
"column": 2
} | {
"line": 243,
"column": 36
} | {
"line": 245,
"column": 0
} | [
{
"pp": "X : Type u_1\nU : SetRel X X\nT : X → X\nF : Set X\ninst✝¹ : U.IsRefl\ninst✝ : U.IsSymm\nn : ℕ\n⊢ coverMincard T F (U ○ U) n ≤ netMaxcard T F U n",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"False",
"Preorder.toLT",
"instCompl... | [] | rcases eq_top_or_lt_top (netMaxcard T F U n) with h | h
· exact h ▸ le_top
obtain ⟨s, s_net, s_card⟩ := (netMaxcard_finite_iff T F U n).1 h
rw [← s_card]
apply IsDynCoverOf.coverMincard_le_card
-- We have to check that `s` is a cover for `dynEntourage T F (U ○ U) n`.
-- If `s` is not a cover, then we can a... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Dynamics.TopologicalEntropy.NetEntropy | {
"line": 222,
"column": 2
} | {
"line": 243,
"column": 36
} | {
"line": 245,
"column": 0
} | [
{
"pp": "X : Type u_1\nU : SetRel X X\nT : X → X\nF : Set X\ninst✝¹ : U.IsRefl\ninst✝ : U.IsSymm\nn : ℕ\n⊢ coverMincard T F (U ○ U) n ≤ netMaxcard T F U n",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"False",
"Preorder.toLT",
"instCompl... | [] | rcases eq_top_or_lt_top (netMaxcard T F U n) with h | h
· exact h ▸ le_top
obtain ⟨s, s_net, s_card⟩ := (netMaxcard_finite_iff T F U n).1 h
rw [← s_card]
apply IsDynCoverOf.coverMincard_le_card
-- We have to check that `s` is a cover for `dynEntourage T F (U ○ U) n`.
-- If `s` is not a cover, then we can a... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 455,
"column": 51
} | {
"line": 455,
"column": 53
} | {
"line": 455,
"column": 54
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\nμ ν : Measure α\ninst✝¹ : SigmaFinite μ\ninst✝ : SigmaFinite ν\nh_add : (μ + ν).rnDeriv (μ + ν) =ᵐ[ν] μ.rnDeriv (μ + ν) + ν.rnDeriv (μ + ν)\nh_one_add : ∀ᵐ (x : α) ∂ν, (μ + ν).rnDeriv (μ + ν) x = (fun x ↦ 1) x\nthis : μ.rnDeriv (μ + ν) =ᵐ[ν] fun x ↦ 1 - (μ.rnDeriv ν... | [
"α : Type u_1\nm : MeasurableSpace α\nμ ν : Measure α\ninst✝¹ : SigmaFinite μ\ninst✝ : SigmaFinite ν\nh_add : (μ + ν).rnDeriv (μ + ν) =ᵐ[ν] μ.rnDeriv (μ + ν) + ν.rnDeriv (μ + ν)\nh_one_add : ∀ᵐ (x : α) ∂ν, (μ + ν).rnDeriv (μ + ν) x = (fun x ↦ 1) x\nthis : μ.rnDeriv (μ + ν) =ᵐ[ν] fun x ↦ 1 - (μ.rnDeriv ν x + 1)⁻¹\na... | ha | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.FieldTheory.AbelRuffini | {
"line": 53,
"column": 14
} | {
"line": 53,
"column": 17
} | {
"line": 53,
"column": 18
} | [
{
"pp": "case h₂\nF : Type u_1\ninst✝ : Field F\ns : Multiset F[X]\nhs : ∀ p ∈ s, Group.IsSolvable p.Gal\np : F[X]\nt : Multiset F[X]\n⊢ p ∈ s → t ⊆ s → Group.IsSolvable t.prod.Gal → Group.IsSolvable (insert p t).prod.Gal",
"ppTerm": "?h₂",
"assigned": true,
"usedConstants": [
"Membership.mem"... | [
"case h₂\nF : Type u_1\ninst✝ : Field F\ns : Multiset F[X]\nhs : ∀ p ∈ s, Group.IsSolvable p.Gal\np : F[X]\nt : Multiset F[X]\nhps : p ∈ s\n⊢ t ⊆ s → Group.IsSolvable t.prod.Gal → Group.IsSolvable (insert p t).prod.Gal"
] | hps | Lean.Elab.Tactic.evalIntro | ident |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 509,
"column": 2
} | {
"line": 509,
"column": 40
} | {
"line": 510,
"column": 2
} | [
{
"pp": "case refine_2\nα : Type u_1\nβ : Type u_2\nm : MeasurableSpace α\nμ ν : Measure α\nmβ : MeasurableSpace β\nf : α → β\nhf : MeasurableEmbedding f\nhμν : μ ≪ ν\ninst✝¹ : SigmaFinite μ\ninst✝ : SigmaFinite ν\n⊢ Measurable (μ.rnDeriv ν)",
"ppTerm": "?refine_2",
"assigned": true,
"usedConstants"... | [
"case refine_3\nα : Type u_1\nβ : Type u_2\nm : MeasurableSpace α\nμ ν : Measure α\nmβ : MeasurableSpace β\nf : α → β\nhf : MeasurableEmbedding f\nhμν : μ ≪ ν\ninst✝¹ : SigmaFinite μ\ninst✝ : SigmaFinite ν\ns : Set α\nx✝¹ : MeasurableSet s\nx✝ : ν s < ∞\n⊢ ∫⁻ (x : α) in s, (map f μ).rnDeriv (map f ν) (f x) ∂ν = ∫⁻ ... | · exact Measure.measurable_rnDeriv _ _ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 544,
"column": 45
} | {
"line": 544,
"column": 47
} | {
"line": 544,
"column": 48
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nm : MeasurableSpace α\nmβ : MeasurableSpace β\nf : α → β\nhf : MeasurableEmbedding f\nμ ν : Measure α\ninst✝¹ : SigmaFinite μ\ninst✝ : SigmaFinite ν\ns : Set β\nhs : MeasurableSet s\na : α\n⊢ (map f μ).rnDeriv (map f ν) (f a) = μ.rnDeriv ν a → a ∈ f ⁻¹' s → μ.rnDeriv ν a = (... | [
"α : Type u_1\nβ : Type u_2\nm : MeasurableSpace α\nmβ : MeasurableSpace β\nf : α → β\nhf : MeasurableEmbedding f\nμ ν : Measure α\ninst✝¹ : SigmaFinite μ\ninst✝ : SigmaFinite ν\ns : Set β\nhs : MeasurableSet s\na : α\nha : (map f μ).rnDeriv (map f ν) (f a) = μ.rnDeriv ν a\n⊢ a ∈ f ⁻¹' s → μ.rnDeriv ν a = (map f μ)... | ha | Lean.Elab.Tactic.evalIntro | ident |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.