module string | startPos dict | endPos dict | nextStartPos dict | goals list | goalsAfter list | ppTac string | elaborator string | kind string |
|---|---|---|---|---|---|---|---|---|
Mathlib.Computability.TuringMachine.StackTuringMachine | {
"line": 595,
"column": 12
} | {
"line": 595,
"column": 23
} | {
"line": 595,
"column": 24
} | [
{
"pp": "K : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\ninst✝ : DecidableEq K\nk : K\nq : TM1.Stmt (Γ' K Γ) (Λ' K Γ Λ σ) σ\nv : σ\nS : (k : K) → List (Γ k)\nL : ListBlank ((k : K) → Option (Γ k))\nhL : ∀ (k : K), ListBlank.map (proj k) L = ListBlank.mk (List.map some (S k)).reverse\nf : σ → Option ... | [
"K : Type u_1\nΓ : K → Type u_2\nΛ : Type u_3\nσ : Type u_4\ninst✝ : DecidableEq K\nk : K\nq : TM1.Stmt (Γ' K Γ) (Λ' K Γ Λ σ) σ\nv : σ\nS : (k : K) → List (Γ k)\nL : ListBlank ((k : K) → Option (Γ k))\nhL : ∀ (k : K), ListBlank.map (proj k) L = ListBlank.mk (List.map some (S k)).reverse\nf : σ → Option (Γ k) → σ\nh... | List.head?, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.ExtremallyDisconnected | {
"line": 188,
"column": 4
} | {
"line": 203,
"column": 77
} | {
"line": 205,
"column": 0
} | [
{
"pp": "case neg\nA E : Type u\ninst✝¹ : TopologicalSpace A\ninst✝ : TopologicalSpace E\nρ : E → A\nρ_cont : Continuous ρ\nρ_surj : Surjective ρ\nzorn_subset : ∀ (E₀ : Set E), E₀ ≠ univ → IsClosed E₀ → ρ '' E₀ ≠ univ\nG : Set E\nhG : IsOpen G\nG_empty : ¬G = ∅\n⊢ ρ '' G ⊆ closure (ρ '' Gᶜ)ᶜ",
"ppTerm": "?n... | [] | intro a ha
rw [mem_closure_iff]
-- let $N$ be a neighbourhood of $a$
intro N N_open hN
-- get $x \in A$ from nonempty open $G \cap \rho^{-1}(N)$
rcases (G.mem_image ρ a).mp ha with ⟨e, he, rfl⟩
have nonempty : (G ∩ ρ ⁻¹' N).Nonempty := ⟨e, mem_inter he <| mem_preimage.mpr hN⟩
have is_open : ... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.ExtremallyDisconnected | {
"line": 188,
"column": 4
} | {
"line": 203,
"column": 77
} | {
"line": 205,
"column": 0
} | [
{
"pp": "case neg\nA E : Type u\ninst✝¹ : TopologicalSpace A\ninst✝ : TopologicalSpace E\nρ : E → A\nρ_cont : Continuous ρ\nρ_surj : Surjective ρ\nzorn_subset : ∀ (E₀ : Set E), E₀ ≠ univ → IsClosed E₀ → ρ '' E₀ ≠ univ\nG : Set E\nhG : IsOpen G\nG_empty : ¬G = ∅\n⊢ ρ '' G ⊆ closure (ρ '' Gᶜ)ᶜ",
"ppTerm": "?n... | [] | intro a ha
rw [mem_closure_iff]
-- let $N$ be a neighbourhood of $a$
intro N N_open hN
-- get $x \in A$ from nonempty open $G \cap \rho^{-1}(N)$
rcases (G.mem_image ρ a).mp ha with ⟨e, he, rfl⟩
have nonempty : (G ∩ ρ ⁻¹' N).Nonempty := ⟨e, mem_inter he <| mem_preimage.mpr hN⟩
have is_open : ... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 897,
"column": 4
} | {
"line": 897,
"column": 52
} | {
"line": 898,
"column": 4
} | [
{
"pp": "case comp\nf : Code\nk : Cont\na_ih✝ :\n ∀ (v : List ℕ) (s : Option Γ'),\n ∃ b₂,\n TrCfg (stepRet k v) b₂ ∧\n Reaches₁ (TM2.step tr) { l := some (Λ'.ret (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }\n b₂\nv : List ℕ\ns : Option Γ'\n⊢ ∃ b₂,\n TrCfg (st... | [
"case comp\nf : Code\nk : Cont\na_ih✝ :\n ∀ (v : List ℕ) (s : Option Γ'),\n ∃ b₂,\n TrCfg (stepRet k v) b₂ ∧\n Reaches₁ (TM2.step tr) { l := some (Λ'.ret (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }\n b₂\nv : List ℕ\ns : Option Γ'\ns' : Cfg'\nh₁ : TrCfg (stepNormal ... | obtain ⟨s', h₁, h₂⟩ := trNormal_respects f k v s | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Topology.Category.TopCat.Yoneda | {
"line": 58,
"column": 2
} | {
"line": 58,
"column": 40
} | {
"line": 59,
"column": 2
} | [
{
"pp": "Y : Type w'\ninst✝ : TopologicalSpace Y\nα : Type\nX : α → TopCat\n⊢ (piComparison (yonedaPresheaf' Y) fun x ↦ op (X x)) =\n (yonedaPresheaf' Y).map ((opCoproductIsoProduct X).inv ≫ (TopCat.sigmaIsoSigma X).inv.op) ≫\n (equivEquivIso (sigmaEquiv Y fun x ↦ ↑(X x))).inv ≫ (Types.productIso fun i ... | [
"Y : Type w'\ninst✝ : TopologicalSpace Y\nα : Type\nX : α → TopCat\n⊢ (piComparison (yonedaPresheaf' Y) fun x ↦ op (X x)) ≫ (Types.productIso fun i ↦ C(↑(X i), Y)).hom =\n (yonedaPresheaf' Y).map ((opCoproductIsoProduct X).inv ≫ (TopCat.sigmaIsoSigma X).inv.op) ≫\n (equivEquivIso (sigmaEquiv Y fun x ↦ ↑(X x... | rw [← Category.assoc, Iso.eq_comp_inv] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1261,
"column": 4
} | {
"line": 1262,
"column": 82
} | {
"line": 1263,
"column": 2
} | [
{
"pp": "case cons₂\nS : Finset Λ'\nk : Cont'\nIH : contSupp k ⊆ S → Supports (contSupp k) S\nH : contSupp k.cons₂ ⊆ S\n⊢ Supports (contSupp k.cons₂) S",
"ppTerm": "?cons₂",
"assigned": true,
"usedConstants": [
"Turing.PartrecToTM2.trStmts₁",
"Finset.instUnion",
"congrArg",
"... | [] | have H' := H; rw [contSupp_cons₂] at H'
exact trStmts₁_supports' (head_supports <| Finset.union_subset_right H') H' IH | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1261,
"column": 4
} | {
"line": 1262,
"column": 82
} | {
"line": 1263,
"column": 2
} | [
{
"pp": "case cons₂\nS : Finset Λ'\nk : Cont'\nIH : contSupp k ⊆ S → Supports (contSupp k) S\nH : contSupp k.cons₂ ⊆ S\n⊢ Supports (contSupp k.cons₂) S",
"ppTerm": "?cons₂",
"assigned": true,
"usedConstants": [
"Turing.PartrecToTM2.trStmts₁",
"Finset.instUnion",
"congrArg",
"... | [] | have H' := H; rw [contSupp_cons₂] at H'
exact trStmts₁_supports' (head_supports <| Finset.union_subset_right H') H' IH | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Category.CompHausLike.Cartesian | {
"line": 49,
"column": 2
} | {
"line": 50,
"column": 48
} | {
"line": 51,
"column": 2
} | [
{
"pp": "P : TopCat → Prop\nX Y : CompHausLike P\ninst✝ : HasProp P (↑X.toTop × ↑Y.toTop)\n⊢ IsLimit (X.productCone Y)",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"CategoryTheory.Limits.BinaryFan.isLimitMk",
"CompHausLike.ofHom",
"CategoryTheory.Functor",
"Catego... | [
"P : TopCat → Prop\nX Y : CompHausLike P\ninst✝ : HasProp P (↑X.toTop × ↑Y.toTop)\nx✝¹ : BinaryFan X Y\nx✝ : x✝¹.pt ⟶ of P (↑X.toTop × ↑Y.toTop)\nh₁ : x✝ ≫ ofHom P { toFun := Prod.fst, continuous_toFun := ⋯ } = x✝¹.fst\nh₂ : x✝ ≫ ofHom P { toFun := Prod.snd, continuous_toFun := ⋯ } = x✝¹.snd\n⊢ x✝ =\n ofHom P\n ... | refine BinaryFan.isLimitMk (fun s ↦ ofHom _ { toFun x := (s.fst x, s.snd x) })
(by rfl_cat) (by rfl_cat) fun _ _ h₁ h₂ ↦ ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Condensed.Light.InternallyProjective | {
"line": 110,
"column": 4
} | {
"line": 110,
"column": 20
} | {
"line": 111,
"column": 4
} | [
{
"pp": "case refine_1\nR : Type u\ninst✝ : CommRing R\nP : LightCondMod R\nx✝ : InternallyProjective P\nA B : LightCondMod R\ne : A ⟶ B\nhe : Epi e\nS : LightProfinite\ng : P ⊗ (free R).obj S.toCondensed ⟶ B\nh : isInternallyProjective P\n⊢ ∃ S' π,\n ∃ (_ : Function.Surjective ⇑(ConcreteCategory.hom π)),\n ... | [
"case refine_1\nR : Type u\ninst✝ : CommRing R\nP : LightCondMod R\nx✝ : InternallyProjective P\nA B : LightCondMod R\ne : A ⟶ B\nhe : Epi e\nS : LightProfinite\ng : P ⊗ (free R).obj S.toCondensed ⟶ B\nh : isInternallyProjective P\nhh : Epi ((ihom P).map e)\n⊢ ∃ S' π,\n ∃ (_ : Function.Surjective ⇑(ConcreteCateg... | have hh := h.1 e | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Control.EquivFunctor.Instances | {
"line": 40,
"column": 20
} | {
"line": 47,
"column": 15
} | {
"line": 49,
"column": 0
} | [
{
"pp": "α✝ β✝ γ✝ : Type ?u.4\nk : α✝ ≃ β✝\nh : β✝ ≃ γ✝\n⊢ (fun s ↦ Finset.map (k.trans h).toEmbedding s) =\n (fun s ↦ Finset.map h.toEmbedding s) ∘ fun s ↦ Finset.map k.toEmbedding s",
"ppTerm": "?m.30",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Equiv.apply_symm_apply",
"... | [] | by
ext _ a
simp
constructor <;> intro h'
· let ⟨a, ha₁, ha₂⟩ := h'
rw [← ha₂]; simpa
· exists (Equiv.symm k) ((Equiv.symm h) a)
simp [h'] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Fin.Fin2 | {
"line": 136,
"column": 51
} | {
"line": 137,
"column": 48
} | {
"line": 139,
"column": 0
} | [
{
"pp": "n : ℕ\n⊢ last.rev = fz",
"ppTerm": "?m.5",
"assigned": true,
"usedConstants": [
"Nat.recAux",
"Fin2.castSucc",
"congrArg",
"Fin2.castSucc.eq_1",
"Fin2.fz",
"Fin2.rev",
"instOfNatNat",
"Fin2.rev.eq_2",
"Fin2.fs",
"instHAdd",
"... | [] | by
induction n <;> simp_all [rev, castSucc, last] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Control.Fold | {
"line": 380,
"column": 2
} | {
"line": 382,
"column": 70
} | {
"line": 384,
"column": 0
} | [
{
"pp": "α β : Type u\nt : Type u → Type u\ninst✝³ : Traversable t\ninst✝² : LawfulTraversable t\nm : Type u → Type u\ninst✝¹ : Monad m\ninst✝ : LawfulMonad m\nf : α → β → m β\nx : β\nxs : t α\n⊢ foldrm f x xs = List.foldrM f x (toList xs)",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
... | [] | change _ = foldrM.ofFreeMonoid f (FreeMonoid.ofList <| toList xs) x
simp only [foldrm, toList_spec, foldMap_hom_free (foldrM.ofFreeMonoid f),
foldrm.ofFreeMonoid_comp_of, foldrM.get, FreeMonoid.ofList_toList] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Control.Fold | {
"line": 380,
"column": 2
} | {
"line": 382,
"column": 70
} | {
"line": 384,
"column": 0
} | [
{
"pp": "α β : Type u\nt : Type u → Type u\ninst✝³ : Traversable t\ninst✝² : LawfulTraversable t\nm : Type u → Type u\ninst✝¹ : Monad m\ninst✝ : LawfulMonad m\nf : α → β → m β\nx : β\nxs : t α\n⊢ foldrm f x xs = List.foldrM f x (toList xs)",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
... | [] | change _ = foldrM.ofFreeMonoid f (FreeMonoid.ofList <| toList xs) x
simp only [foldrm, toList_spec, foldMap_hom_free (foldrM.ofFreeMonoid f),
foldrm.ofFreeMonoid_comp_of, foldrM.get, FreeMonoid.ofList_toList] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Condensed.Light.Sequence | {
"line": 108,
"column": 4
} | {
"line": 108,
"column": 34
} | {
"line": 109,
"column": 4
} | [
{
"pp": "case none\nS : Type u_1\nT : Type u_2\nX : Type u_3\nπ : T → S × Option X\nhπ : Function.Surjective π\nσ : Option X → S → T\nhσ : ∀ (x : Option X) (s : S), (π (σ x s)).1 = s\nhσ' : ∀ (x : Option X) (s : S), (π (σ x s)).2 = x\ns : S\n⊢ ∃ a, (fun x ↦ π ↑x) a = (s, none)",
"ppTerm": "?none",
"assi... | [
"case none\nS : Type u_1\nT : Type u_2\nX : Type u_3\nπ : T → S × Option X\nhπ : Function.Surjective π\nσ : Option X → S → T\nhσ : ∀ (x : Option X) (s : S), (π (σ x s)).1 = s\nhσ' : ∀ (x : Option X) (s : S), (π (σ x s)).2 = x\ns : S\ny : T\nhy : π y = (s, none)\n⊢ ∃ a, (fun x ↦ π ↑x) a = (s, none)"
] | obtain ⟨y, hy⟩ := hπ (s, none) | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.TypeVec | {
"line": 428,
"column": 8
} | {
"line": 428,
"column": 21
} | {
"line": 428,
"column": 21
} | [
{
"pp": "case fs\nn : ℕ\np : Prop\nn✝ : ℕ\na✝ : Fin2 n✝\nih : ∀ {α : TypeVec.{u_1} n✝} {x : α a✝}, ofRepeat (TypeVec.const p α a✝ x) ↔ p\nα : TypeVec.{u_1} (n✝ + 1)\nx : α a✝.fs\n⊢ ofRepeat (TypeVec.const p α a✝.fs x) ↔ p",
"ppTerm": "?fs",
"assigned": true,
"usedConstants": [
"Eq.mpr",
... | [
"case fs\nn : ℕ\np : Prop\nn✝ : ℕ\na✝ : Fin2 n✝\nih : ∀ {α : TypeVec.{u_1} n✝} {x : α a✝}, ofRepeat (TypeVec.const p α a✝ x) ↔ p\nα : TypeVec.{u_1} (n✝ + 1)\nx : α a✝.fs\n⊢ ofRepeat (TypeVec.const p α.drop a✝ x) ↔ p"
] | TypeVec.const | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Condensed.Light.Sequence | {
"line": 227,
"column": 4
} | {
"line": 229,
"column": 91
} | {
"line": 230,
"column": 4
} | [
{
"pp": "case right\nR : Type\ninst✝¹ : CommRing R\nX : LightCondMod R\nS T : LightProfinite\nπ : T ⟶ S ⊗ ℕ∪{∞}\ninst✝ : Epi ((lightProfiniteToLightCondSet ⋙ free R).map (cover π))\ng : (lightProfiniteToLightCondSet ⋙ free R).obj T ⟶ X\nr_inf : T ⟶ LightProfinite.fibre ∞ (π ≫ snd S ℕ∪{∞})\nσ : S ⟶ LightProfinit... | [
"case right\nR : Type\ninst✝¹ : CommRing R\nX : LightCondMod R\nS T : LightProfinite\nπ : T ⟶ S ⊗ ℕ∪{∞}\ninst✝ : Epi ((lightProfiniteToLightCondSet ⋙ free R).map (cover π))\ng : (lightProfiniteToLightCondSet ⋙ free R).obj T ⟶ X\nr_inf : T ⟶ LightProfinite.fibre ∞ (π ≫ snd S ℕ∪{∞})\nσ : S ⟶ LightProfinite.fibre ∞ (π... | simp only [pair_obj_right, mapCocone_ι_app,
Functor.comp_map, parallelPair_obj_zero, parallelPair_obj_one, parallelPair_map_left,
Preadditive.comp_add, Preadditive.comp_sub, ← map_comp_assoc, parallelPair_map_right] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Analysis.Filter | {
"line": 127,
"column": 4
} | {
"line": 127,
"column": 27
} | {
"line": 128,
"column": 4
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nσ : Type u_3\nτ : Type u_4\nf : Filter α\nF : f.Realizer\nE : F.σ ≃ τ\n⊢ (CFilter.ofEquiv E F.F).toFilter = f",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"CFilter.toFilter",
"Filter.Realizer.eq",
"CompleteLattice.toConditionallyCom... | [
"α : Type u_1\nβ : Type u_2\nσ : Type u_3\nτ : Type u_4\nf : Filter α\nF : f.Realizer\nE : F.σ ≃ τ\n⊢ (CFilter.ofEquiv E F.F).toFilter = F.F.toFilter"
] | refine Eq.trans ?_ F.eq | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Analysis.Filter | {
"line": 309,
"column": 2
} | {
"line": 309,
"column": 68
} | {
"line": 310,
"column": 2
} | [
{
"pp": "α : Type u_1\nf : Filter α\nF : f.Realizer\n⊢ f ≠ ⊥ ↔ ∀ (a : F.σ), (F.F.f a).Nonempty",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"le_bot_iff",
"Eq.mpr",
"Filter.Realizer.bot",
"congrArg",
"Filter.instCompleteLatticeFilter",
"OrderBot.toBot"... | [
"α : Type u_1\nf : Filter α\nF : f.Realizer\n⊢ (∃ x, ¬(F.F.f x).Nonempty) ↔ ∀ (b : Realizer.bot.σ), ∃ a, F.F.f a ⊆ Realizer.bot.F.f b"
] | rw [not_iff_comm, ← le_bot_iff, F.le_iff Realizer.bot, not_forall] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Bool.Count | {
"line": 93,
"column": 8
} | {
"line": 93,
"column": 18
} | {
"line": 93,
"column": 19
} | [
{
"pp": "case pos\nl : List Bool\nhl : IsChain (fun x1 x2 ↦ x1 ≠ x2) l\nb : Bool\nh2 : Even l.length\n⊢ 2 * count b l = if Even l.length then l.length else if (some b == l.head?) = true then l.length + 1 else l.length - 1",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"List.head?",
... | [
"case pos\nl : List Bool\nhl : IsChain (fun x1 x2 ↦ x1 ≠ x2) l\nb : Bool\nh2 : Even l.length\n⊢ 2 * count b l = l.length"
] | if_pos h2, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.ENat.BigOperators | {
"line": 101,
"column": 30
} | {
"line": 101,
"column": 33
} | {
"line": 101,
"column": 33
} | [
{
"pp": "case cons\nα : Type u_1\nι : Type u_2\nf : α → ι → ℕ∞\nhf : ∀ (i j : ι), ∃ k, ∀ (a : α), f a i ≤ f a k ∧ f a j ≤ f a k\na : α\ns : Finset α\nha : a ∉ s\nihs : ∑ a ∈ s, ⨆ i, f a i = ⨆ i, ∑ a ∈ s, f a i\n⊢ (⨆ i, f a i) + ∑ a ∈ s, ⨆ i, f a i = ⨆ i, f a i + ∑ a ∈ s, f a i",
"ppTerm": "?cons",
"assi... | [
"case cons\nα : Type u_1\nι : Type u_2\nf : α → ι → ℕ∞\nhf : ∀ (i j : ι), ∃ k, ∀ (a : α), f a i ≤ f a k ∧ f a j ≤ f a k\na : α\ns : Finset α\nha : a ∉ s\nihs : ∑ a ∈ s, ⨆ i, f a i = ⨆ i, ∑ a ∈ s, f a i\n⊢ (⨆ i, f a i) + ⨆ i, ∑ a ∈ s, f a i = ⨆ i, f a i + ∑ a ∈ s, f a i"
] | ihs | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.FP.Basic | {
"line": 92,
"column": 7
} | {
"line": 92,
"column": 50
} | {
"line": 92,
"column": 50
} | [
{
"pp": "C : FloatCfg\n⊢ emin = max (emin + ↑(Nat.size 0) - ↑prec) emin",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"FP.emin",
"Lattice.toSemilatticeSup",
"FP.prec",
"congrArg",
"Int.instLin... | [] | (simp [sub_eq_add_neg, Int.natCast_nonneg]) | Lean.Elab.Tactic.evalParen | Lean.Parser.Tactic.paren |
Mathlib.Data.FP.Basic | {
"line": 92,
"column": 7
} | {
"line": 92,
"column": 50
} | {
"line": 92,
"column": 50
} | [
{
"pp": "C : FloatCfg\n⊢ emin = max (emin + ↑(Nat.size 0) - ↑prec) emin",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"FP.emin",
"Lattice.toSemilatticeSup",
"FP.prec",
"congrArg",
"Int.instLin... | [] | (simp [sub_eq_add_neg, Int.natCast_nonneg]) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.FP.Basic | {
"line": 92,
"column": 7
} | {
"line": 92,
"column": 50
} | {
"line": 92,
"column": 50
} | [
{
"pp": "C : FloatCfg\n⊢ emin = max (emin + ↑(Nat.size 0) - ↑prec) emin",
"ppTerm": "?m.29",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"NegZeroClass.toNeg",
"FP.emin",
"Lattice.toSemilatticeSup",
"FP.prec",
"congrArg",
"Int.instLin... | [] | (simp [sub_eq_add_neg, Int.natCast_nonneg]) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Fin.FlagRange | {
"line": 44,
"column": 2
} | {
"line": 48,
"column": 79
} | {
"line": 50,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝¹ : PartialOrder α\ninst✝ : BoundedOrder α\nn : ℕ\nf : Fin (n + 1) → α\nh0 : f 0 = ⊥\nhlast : f (Fin.last n) = ⊤\nhcovBy : ∀ (k : Fin n), f k.castSucc ⩿ f k.succ\nhmono : Monotone f\nt : Set α\nhtc : IsChain (fun x1 x2 ↦ x1 ≤ x2) t\nhbt : range f ⊆ t\nx : α\nhx : x ∈ t\nh : ∀ (y : Fi... | [] | induction k using Fin.induction with
| zero => simpa [h0, bot_lt_iff_ne_bot] using (h 0).symm
| succ k ihk =>
rw [range_subset_iff] at hbt
exact (htc.lt_of_le (hbt k.succ) hx (h _)).resolve_right ((hcovBy k).2 ihk) | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Data.Finsupp.AList | {
"line": 34,
"column": 26
} | {
"line": 34,
"column": 36
} | {
"line": 34,
"column": 37
} | [
{
"pp": "α : Type u_1\nM : Type u_2\ninst✝ : Zero M\nf : α →₀ M\n⊢ (List.map Prod.toSigma f.graph.toList).keys.Nodup",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Prod.toSigma",
"congrArg",
"List.map",
"List.keys",
"id",
"Sigma.fst",
... | [
"α : Type u_1\nM : Type u_2\ninst✝ : Zero M\nf : α →₀ M\n⊢ (List.map Sigma.fst (List.map Prod.toSigma f.graph.toList)).Nodup"
] | List.keys, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Finsupp.BigOperators | {
"line": 56,
"column": 57
} | {
"line": 57,
"column": 58
} | {
"line": 59,
"column": 0
} | [
{
"pp": "ι : Type u_1\nM : Type u_2\ninst✝¹ : DecidableEq ι\ninst✝ : AddCommMonoid M\ns : Finset (ι →₀ M)\n⊢ (s.sum id).support ⊆ s.sup Finsupp.support",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"Multiset.sum",
"Eq.mpr",
"Lattice.toSemilatticeSup",
"Multiset.ma... | [] | by
classical convert! Multiset.support_sum_subset s.1; simp | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Int.Order.Lemmas | {
"line": 31,
"column": 2
} | {
"line": 31,
"column": 61
} | {
"line": 32,
"column": 2
} | [
{
"pp": "a b : ℤ\n⊢ a.natAbs < b.natAbs ↔ a * a < b * b",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Int.instIsStrictOrderedRing",
"Preorder.toLT",
"HMul.hMul",
"AddGroupWithOne.toAddGroup",
"abs",
"congrArg",
"Int.instLinearOrd... | [
"a b : ℤ\n⊢ a.natAbs < b.natAbs ↔ ↑a.natAbs < ↑b.natAbs"
] | rw [← abs_lt_iff_mul_self_lt, abs_eq_natAbs, abs_eq_natAbs] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Int.Bitwise | {
"line": 308,
"column": 2
} | {
"line": 312,
"column": 41
} | {
"line": 314,
"column": 0
} | [
{
"pp": "f : Bool → Bool → Bool\nm n : ℤ\nk : ℕ\n⊢ (bitwise f m n).testBit k = f (m.testBit k) (n.testBit k)",
"ppTerm": "?m.5",
"assigned": true,
"usedConstants": [
"cond",
"Int.testBit",
"Bool.not_false",
"Bool.not",
"Int.bitwise",
"congrArg",
"Nat.testBit... | [] | cases m <;> cases n <;> simp only [testBit, bitwise, natBitwise]
· by_cases h : f false false <;> simp [h]
· by_cases h : f false true <;> simp [h]
· by_cases h : f true false <;> simp [h]
· by_cases h : f true true <;> simp [h] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Int.Bitwise | {
"line": 308,
"column": 2
} | {
"line": 312,
"column": 41
} | {
"line": 314,
"column": 0
} | [
{
"pp": "f : Bool → Bool → Bool\nm n : ℤ\nk : ℕ\n⊢ (bitwise f m n).testBit k = f (m.testBit k) (n.testBit k)",
"ppTerm": "?m.5",
"assigned": true,
"usedConstants": [
"cond",
"Int.testBit",
"Bool.not_false",
"Bool.not",
"Int.bitwise",
"congrArg",
"Nat.testBit... | [] | cases m <;> cases n <;> simp only [testBit, bitwise, natBitwise]
· by_cases h : f false false <;> simp [h]
· by_cases h : f false true <;> simp [h]
· by_cases h : f true false <;> simp [h]
· by_cases h : f true true <;> simp [h] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.DropRight | {
"line": 57,
"column": 6
} | {
"line": 57,
"column": 11
} | {
"line": 57,
"column": 11
} | [
{
"pp": "α : Type u_1\nl : List α\nn : ℕ\n⊢ l.rdrop n = (drop n l.reverse).reverse",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"List.rdrop",
"congrArg",
"HSub.hSub",
"id",
"instSubNat",
"List",
"instHSub",
"List.drop",
... | [
"α : Type u_1\nl : List α\nn : ℕ\n⊢ take (l.length - n) l = (drop n l.reverse).reverse"
] | rdrop | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.TakeWhile | {
"line": 26,
"column": 4
} | {
"line": 26,
"column": 22
} | {
"line": 27,
"column": 4
} | [
{
"pp": "case cons\nα : Type u_1\np : α → Bool\nhd : α\ntl : List α\nIH : ∀ (hl : 0 < (dropWhile p tl).length), ¬p ((dropWhile p tl).get ⟨0, hl⟩) = true\nhl : 0 < (dropWhile p (hd :: tl)).length\n⊢ ¬p\n ((match p hd with\n | true => dropWhile p tl\n | false => hd :: tl).get\n ... | [
"case pos\nα : Type u_1\np : α → Bool\nhd : α\ntl : List α\nIH : ∀ (hl : 0 < (dropWhile p tl).length), ¬p ((dropWhile p tl).get ⟨0, hl⟩) = true\nhl : 0 < (dropWhile p (hd :: tl)).length\nhp : p hd = true\n⊢ ¬p\n ((match p hd with\n | true => dropWhile p tl\n | false => hd :: tl).get\n ... | by_cases hp : p hd | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.Data.List.DropRight | {
"line": 198,
"column": 69
} | {
"line": 199,
"column": 69
} | {
"line": 201,
"column": 0
} | [
{
"pp": "α : Type u_1\nl : List α\ni j : ℕ\n⊢ (l.rdrop i).rdrop j = l.rdrop (i + j)",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"List.drop_drop",
"List.rdrop",
"List.rdrop_eq_reverse_drop_reverse",
"congrArg",
"id",
"List",
"inst... | [] | by
simp_rw [rdrop_eq_reverse_drop_reverse, reverse_reverse, drop_drop] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.TakeWhile | {
"line": 53,
"column": 4
} | {
"line": 62,
"column": 19
} | {
"line": 64,
"column": 0
} | [
{
"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",
"False",
"Nat.zero_lt_succ._simp_1",
"iff_fal... | [] | rw [dropWhile]
by_cases h_p_hd : p hd
· simp only [h_p_hd, length_cons, Nat.zero_lt_succ, getElem_cons_zero, not_true_eq_false,
imp_false, iff_false]
intro h
replace h := congrArg length h
have := length_dropWhile_le p tl
simp at h
lia
· simp [h_p_hd] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.TakeWhile | {
"line": 53,
"column": 4
} | {
"line": 62,
"column": 19
} | {
"line": 64,
"column": 0
} | [
{
"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",
"False",
"Nat.zero_lt_succ._simp_1",
"iff_fal... | [] | rw [dropWhile]
by_cases h_p_hd : p hd
· simp only [h_p_hd, length_cons, Nat.zero_lt_succ, getElem_cons_zero, not_true_eq_false,
imp_false, iff_false]
intro h
replace h := congrArg length h
have := length_dropWhile_le p tl
simp at h
lia
· simp [h_p_hd] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.TakeWhile | {
"line": 93,
"column": 21
} | {
"line": 93,
"column": 39
} | {
"line": 93,
"column": 40
} | [
{
"pp": "case cons\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\n⊢ takeWhile p (takeWhile q (hd :: tl)) = takeWhile (fun a ↦ decide (p a = true ∧ q a = true)) (hd :: tl)",
"ppTerm": "?cons",
"assigned": tr... | [
"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\n⊢ takeWhile p (takeWhile q (hd :: tl)) = takeWhile (fun a ↦ decide (p a = true ∧ q a = true)) (hd :: tl)",
"case neg\nα : Type u_1\np q : α →... | by_cases hp : p hd | «_aux_Init_ByCases___macroRules_tacticBy_cases_:__2» | «tacticBy_cases_:_» |
Mathlib.Data.Nat.Cast.SetInterval | {
"line": 44,
"column": 2
} | {
"line": 44,
"column": 41
} | {
"line": 46,
"column": 0
} | [
{
"pp": "a : ℕ\n⊢ Nat.cast '' Iic a = Icc 0 ↑a",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.image_cast_int_Icc",
"congrArg",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"id"... | [] | rw [← Icc_bot, image_cast_int_Icc]; rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Cast.SetInterval | {
"line": 44,
"column": 2
} | {
"line": 44,
"column": 41
} | {
"line": 46,
"column": 0
} | [
{
"pp": "a : ℕ\n⊢ Nat.cast '' Iic a = Icc 0 ↑a",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.image_cast_int_Icc",
"congrArg",
"OrderBot.toBot",
"PartialOrder.toPreorder",
"Preorder.toLE",
"SemilatticeInf.toPartialOrder",
"id"... | [] | rw [← Icc_bot, image_cast_int_Icc]; rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Fib.Zeckendorf | {
"line": 55,
"column": 50
} | {
"line": 55,
"column": 75
} | {
"line": 57,
"column": 0
} | [
{
"pp": "⊢ [].IsZeckendorfRep",
"ppTerm": "?m.2",
"assigned": true,
"usedConstants": [
"List.IsChain",
"instOfNatNat",
"LE.le",
"instLENat",
"List.cons",
"instHAdd",
"HAdd.hAdd",
"List.IsChain.singleton._simp_1",
"Nat",
"of_eq_true",
... | [] | by simp [IsZeckendorfRep] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.Choose.Lucas | {
"line": 55,
"column": 6
} | {
"line": 55,
"column": 46
} | {
"line": 56,
"column": 6
} | [
{
"pp": "case mp\nn k p : ℕ\ninst✝ : Fact (Nat.Prime p)\ndecompose : (X + 1) ^ n = (X + 1) ^ (n % p) * (X ^ p + 1) ^ (n / p)\nx₁ x₂ : ℕ\nhx : (x₁, x₂) ∈ range (n % p + 1) ×ˢ range (n / p + 1)\nh : k = (x₁, x₂).1 + p * (x₁, x₂).2\n⊢ k % p = x₁ ∧ k / p = x₂",
"ppTerm": "?mp",
"assigned": true,
"usedCo... | [
"case mp\nn k p : ℕ\ninst✝ : Fact (Nat.Prime p)\ndecompose : (X + 1) ^ n = (X + 1) ^ (n % p) * (X ^ p + 1) ^ (n / p)\nx₁ x₂ : ℕ\nh : k = (x₁, x₂).1 + p * (x₁, x₂).2\nhx : x₁ < n % p + 1 ∧ x₂ < n / p + 1\n⊢ k % p = x₁ ∧ k / p = x₂"
] | simp only [mem_product, mem_range] at hx | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Nat.Choose.Lucas | {
"line": 85,
"column": 23
} | {
"line": 85,
"column": 46
} | {
"line": 85,
"column": 47
} | [
{
"pp": "case h₁\nn k p : ℕ\ninst✝ : Fact (Nat.Prime p)\na✝ a : ℕ\n⊢ ↑((n / p ^ a % p).choose (k / p ^ a % p)) * ↑((n / p ^ a / p).choose (k / p ^ a / p)) ≡\n ↑((n / (p ^ a * p)).choose (k / (p ^ a * p))) * ↑((n / p ^ a % p).choose (k / p ^ a % p)) [ZMOD ↑p]",
"ppTerm": "?h₁",
"assigned": true,
"... | [
"case h₁\nn k p : ℕ\ninst✝ : Fact (Nat.Prime p)\na✝ a : ℕ\n⊢ ↑((n / p ^ a % p).choose (k / p ^ a % p)) * ↑((n / (p ^ a * p)).choose (k / (p ^ a * p))) ≡\n ↑((n / (p ^ a * p)).choose (k / (p ^ a * p))) * ↑((n / p ^ a % p).choose (k / p ^ a % p)) [ZMOD ↑p]"
] | Nat.div_div_eq_div_mul, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Nat.Choose.Lucas | {
"line": 91,
"column": 2
} | {
"line": 93,
"column": 19
} | {
"line": 95,
"column": 0
} | [
{
"pp": "n k p : ℕ\ninst✝ : Fact (Nat.Prime p)\na : ℕ\nha₁ : n < p ^ a\nha₂ : k < p ^ a\n⊢ ↑(n.choose k) ≡ ∏ i ∈ range a, ↑((n / p ^ i % p).choose (k / p ^ i % p)) [ZMOD ↑p]",
"ppTerm": "?m.42",
"assigned": true,
"usedConstants": [
"Int.instCommMonoid",
"Eq.mpr",
"NonAssocSemiring.... | [] | apply (choose_modEq_choose_mul_prod_range_choose a).trans
simp_rw [Nat.div_eq_of_lt ha₁, Nat.div_eq_of_lt ha₂, choose, cast_one, one_mul, cast_prod,
Int.ModEq.refl] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Choose.Lucas | {
"line": 91,
"column": 2
} | {
"line": 93,
"column": 19
} | {
"line": 95,
"column": 0
} | [
{
"pp": "n k p : ℕ\ninst✝ : Fact (Nat.Prime p)\na : ℕ\nha₁ : n < p ^ a\nha₂ : k < p ^ a\n⊢ ↑(n.choose k) ≡ ∏ i ∈ range a, ↑((n / p ^ i % p).choose (k / p ^ i % p)) [ZMOD ↑p]",
"ppTerm": "?m.42",
"assigned": true,
"usedConstants": [
"Int.instCommMonoid",
"Eq.mpr",
"NonAssocSemiring.... | [] | apply (choose_modEq_choose_mul_prod_range_choose a).trans
simp_rw [Nat.div_eq_of_lt ha₁, Nat.div_eq_of_lt ha₂, choose, cast_one, one_mul, cast_prod,
Int.ModEq.refl] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.Prime | {
"line": 80,
"column": 2
} | {
"line": 82,
"column": 20
} | {
"line": 84,
"column": 0
} | [
{
"pp": "case bit0\na✝ : PosNum\n⊢ ↑a✝.bit0.minFac = (↑a✝.bit0).minFac",
"ppTerm": "?bit0",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"castPosNum",
"Dvd.dvd",
"HMul.hMul",
"Nat.instOne",
"congrArg",
"Nat.... | [] | · rw [minFac, Nat.minFac_eq, if_pos]
· rfl
simp [← two_mul] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Num.Prime | {
"line": 67,
"column": 2
} | {
"line": 82,
"column": 20
} | {
"line": 84,
"column": 0
} | [
{
"pp": "n : PosNum\n⊢ ↑n.minFac = (↑n).minFac",
"ppTerm": "?m.2",
"assigned": true,
"usedConstants": [
"PosNum.casesOn",
"Nat.sqrt_lt",
"Distrib.leftDistribClass",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"castPosNum",
"False",
"Nat.instMu... | [] | obtain - | n := n
· simp [minFac]
· rw [minFac, Nat.minFac_eq, if_neg]
swap
· simp [← two_mul]
rw [minFacAux_to_nat]
· rfl
simp only [cast_one, cast_bit1]
rw [Nat.sqrt_lt]
calc
(n : ℕ) + (n : ℕ) + 1 ≤ (n : ℕ) + (n : ℕ) + (n : ℕ) := by simp
_ = (n : ℕ) * (1 + 1 + 1) := by simp... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.Prime | {
"line": 67,
"column": 2
} | {
"line": 82,
"column": 20
} | {
"line": 84,
"column": 0
} | [
{
"pp": "n : PosNum\n⊢ ↑n.minFac = (↑n).minFac",
"ppTerm": "?m.2",
"assigned": true,
"usedConstants": [
"PosNum.casesOn",
"Nat.sqrt_lt",
"Distrib.leftDistribClass",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"castPosNum",
"False",
"Nat.instMu... | [] | obtain - | n := n
· simp [minFac]
· rw [minFac, Nat.minFac_eq, if_neg]
swap
· simp [← two_mul]
rw [minFacAux_to_nat]
· rfl
simp only [cast_one, cast_bit1]
rw [Nat.sqrt_lt]
calc
(n : ℕ) + (n : ℕ) + 1 ≤ (n : ℕ) + (n : ℕ) + (n : ℕ) := by simp
_ = (n : ℕ) * (1 + 1 + 1) := by simp... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.Prime | {
"line": 101,
"column": 10
} | {
"line": 103,
"column": 13
} | {
"line": 104,
"column": 8
} | [
{
"pp": "case refine_1\nn : PosNum\n⊢ 2 ≤ ↑n.bit1",
"ppTerm": "?refine_1",
"assigned": true,
"usedConstants": [
"castPosNum",
"Nat.instOne",
"PosNum.bit1",
"PosNum.to_nat_pos",
"id",
"instOfNatNat",
"LE.le",
"_private.Mathlib.Data.Num.Prime.0.PosNum.de... | [] | simp only [cast_bit1]
have := to_nat_pos n
lia | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.Prime | {
"line": 101,
"column": 10
} | {
"line": 103,
"column": 13
} | {
"line": 104,
"column": 8
} | [
{
"pp": "case refine_1\nn : PosNum\n⊢ 2 ≤ ↑n.bit1",
"ppTerm": "?refine_1",
"assigned": true,
"usedConstants": [
"castPosNum",
"Nat.instOne",
"PosNum.bit1",
"PosNum.to_nat_pos",
"id",
"instOfNatNat",
"LE.le",
"_private.Mathlib.Data.Num.Prime.0.PosNum.de... | [] | simp only [cast_bit1]
have := to_nat_pos n
lia | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.ZNum | {
"line": 116,
"column": 29
} | {
"line": 116,
"column": 37
} | {
"line": 116,
"column": 37
} | [
{
"pp": "α : Type u_1\ninst✝ : AddGroupWithOne α\np : PosNum\n⊢ -↑(Num.casesOn p.pred' 1 bit1) = ↑(neg p) + ↑(neg p) + 1",
"ppTerm": "?m.61",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"castZNum",
"NegZeroClass.toNeg",
"castPosNum",
... | [
"α : Type u_1\ninst✝ : AddGroupWithOne α\np : PosNum\n⊢ -↑(Num.casesOn p.pred' 1 bit1) = -↑p + -↑p + 1"
] | cast_neg | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.ZNum | {
"line": 285,
"column": 10
} | {
"line": 285,
"column": 33
} | {
"line": 285,
"column": 34
} | [
{
"pp": "α : Type u_1\ninst✝ : AddGroupWithOne α\na b : PosNum\n⊢ ↑b + -↑a = -↑a + ↑b",
"ppTerm": "?m.57",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Int.cast",
"Eq.mpr",
"NegZeroClass.toNeg",
"castPosNum",
"AddMonoid.toAddSemigroup",
... | [
"α : Type u_1\ninst✝ : AddGroupWithOne α\na b : PosNum\n⊢ ↑b + -↑↑a = -↑↑a + ↑b"
] | ← PosNum.cast_to_int a, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.ZNum | {
"line": 291,
"column": 10
} | {
"line": 291,
"column": 33
} | {
"line": 291,
"column": 34
} | [
{
"pp": "α : Type u_1\ninst✝ : AddGroupWithOne α\na b : PosNum\n⊢ ↑a + ↑b = ↑b + ↑a",
"ppTerm": "?m.300",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Int.cast",
"Eq.mpr",
"castPosNum",
"AddMonoid.toAddSemigroup",
"AddGroupWithOne.toAddGro... | [
"α : Type u_1\ninst✝ : AddGroupWithOne α\na b : PosNum\n⊢ ↑↑a + ↑b = ↑b + ↑↑a"
] | ← PosNum.cast_to_int a, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Num.ZNum | {
"line": 557,
"column": 6
} | {
"line": 558,
"column": 65
} | {
"line": 559,
"column": 4
} | [
{
"pp": "case bit0.h₁\nd n : PosNum\nq r : Num\nIH : ↑r + ↑d * ↑q = ↑n ∧ ↑r < ↑d\n⊢ ↑r.bit0 + ↑d * (↑q + ↑q) = ↑n.bit0",
"ppTerm": "?bit0.h₁",
"assigned": true,
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"castPosNum",
... | [] | simp only [Num.cast_bit0, cast_bit0]
rw [← two_mul, ← two_mul, mul_left_comm, ← mul_add, ← IH.1] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.ZNum | {
"line": 557,
"column": 6
} | {
"line": 558,
"column": 65
} | {
"line": 559,
"column": 4
} | [
{
"pp": "case bit0.h₁\nd n : PosNum\nq r : Num\nIH : ↑r + ↑d * ↑q = ↑n ∧ ↑r < ↑d\n⊢ ↑r.bit0 + ↑d * (↑q + ↑q) = ↑n.bit0",
"ppTerm": "?bit0.h₁",
"assigned": true,
"usedConstants": [
"Distrib.leftDistribClass",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
"castPosNum",
... | [] | simp only [Num.cast_bit0, cast_bit0]
rw [← two_mul, ← two_mul, mul_left_comm, ← mul_add, ← IH.1] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Ordmap.Invariants | {
"line": 291,
"column": 46
} | {
"line": 291,
"column": 83
} | {
"line": 291,
"column": 84
} | [
{
"pp": "case nil.node.nil\nα : Type u_1\nx : α\nls : ℕ\nlx : α\nlr : Ordnode α\n⊢ (casesOn (id nil)\n (casesOn (id (node ls nil lx lr)) (Ordnode.singleton x) fun ls_1 ll lx_1 lr_1 ↦\n casesOn (id ll)\n (casesOn lr_1 (node 2 (node ls nil lx lr) x nil) fun size l lrx r ↦\n ... | [
"case nil.node.nil.nil\nα : Type u_1\nx : α\nls : ℕ\nlx : α\n⊢ (casesOn (id nil)\n (casesOn (id (node ls nil lx nil)) (Ordnode.singleton x) fun ls_1 ll lx_1 lr ↦\n casesOn (id ll)\n (casesOn lr (node 2 (node ls nil lx nil) x nil) fun size l lrx r ↦\n node 3 (Ordnode.singleton... | obtain - | ⟨lrs, lrl, lrx, lrr⟩ := lr | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.Ordmap.Invariants | {
"line": 291,
"column": 46
} | {
"line": 291,
"column": 83
} | {
"line": 291,
"column": 84
} | [
{
"pp": "case nil.node.node\nα : Type u_1\nx : α\nls : ℕ\nlx : α\nlr : Ordnode α\nlls : ℕ\nlll : Ordnode α\nllx : α\nllr : Ordnode α\n⊢ (casesOn (id nil)\n (casesOn (id (node ls (node lls lll llx llr) lx lr)) (Ordnode.singleton x) fun ls_1 ll lx_1 lr_1 ↦\n casesOn (id ll)\n (casesOn l... | [
"case nil.node.node.nil\nα : Type u_1\nx : α\nls : ℕ\nlx : α\nlls : ℕ\nlll : Ordnode α\nllx : α\nllr : Ordnode α\n⊢ (casesOn (id nil)\n (casesOn (id (node ls (node lls lll llx llr) lx nil)) (Ordnode.singleton x) fun ls_1 ll lx_1 lr ↦\n casesOn (id ll)\n (casesOn lr (node 2 (node ls (node ... | obtain - | ⟨lrs, lrl, lrx, lrr⟩ := lr | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.Ordmap.Invariants | {
"line": 290,
"column": 2
} | {
"line": 293,
"column": 47
} | {
"line": 294,
"column": 2
} | [
{
"pp": "case nil\nα : Type u_1\nl : Ordnode α\nx : α\n⊢ (casesOn (id nil)\n (casesOn (id l) (Ordnode.singleton x) fun ls ll lx lr ↦\n casesOn (id ll)\n (casesOn lr (node 2 l x nil) fun size l lrx r ↦ node 3 (Ordnode.singleton lx) lrx (Ordnode.singleton x))\n fun lls l x_1 ... | [
"case node\nα : Type u_1\nl : Ordnode α\nx : α\nrs : ℕ\nrl : Ordnode α\nrx : α\nrr : Ordnode α\n⊢ (casesOn (id (node rs rl rx rr))\n (casesOn (id l) (Ordnode.singleton x) fun ls ll lx lr ↦\n casesOn (id ll)\n (casesOn lr (node 2 l x nil) fun size l lrx r ↦ node 3 (Ordnode.singleton lx) lr... | · obtain - | ⟨ls, ll, lx, lr⟩ := l; · rfl
obtain - | ⟨lls, lll, llx, llr⟩ := ll <;> obtain - | ⟨lrs, lrl, lrx, lrr⟩ := lr <;>
dsimp only [dual, id] <;> try rfl
split_ifs with h <;> repeat simp [add_comm] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Ordmap.Invariants | {
"line": 297,
"column": 46
} | {
"line": 297,
"column": 83
} | {
"line": 297,
"column": 84
} | [
{
"pp": "case pos.nil\nα : Type u_1\nx : α\nrs : ℕ\nrl : Ordnode α\nrx : α\nrr : Ordnode α\nls : ℕ\nlx : α\nlr : Ordnode α\nh✝ : ls > delta * rs\n⊢ (rec nil\n (fun size l x_1 r l_ih r_ih ↦\n rec nil\n (fun size_1 l x_2 r l_ih r_ih ↦\n if size_1 < ratio * size then node (l... | [
"case pos.nil.nil\nα : Type u_1\nx : α\nrs : ℕ\nrl : Ordnode α\nrx : α\nrr : Ordnode α\nls : ℕ\nlx : α\nh✝ : ls > delta * rs\n⊢ (rec nil\n (fun size l x_1 r l_ih r_ih ↦\n rec nil\n (fun size_1 l x_2 r l_ih r_ih ↦\n if size_1 < ratio * size then node (ls + rs + 1) nil lx (node... | obtain - | ⟨lrs, lrl, lrx, lrr⟩ := lr | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.Ordmap.Invariants | {
"line": 297,
"column": 46
} | {
"line": 297,
"column": 83
} | {
"line": 297,
"column": 84
} | [
{
"pp": "case pos.node\nα : Type u_1\nx : α\nrs : ℕ\nrl : Ordnode α\nrx : α\nrr : Ordnode α\nls : ℕ\nlx : α\nlr : Ordnode α\nh✝ : ls > delta * rs\nlls : ℕ\nlll : Ordnode α\nllx : α\nllr : Ordnode α\n⊢ (rec nil\n (fun size l x_1 r l_ih r_ih ↦\n rec nil\n (fun size_1 l x_2 r l_ih r_ih ↦... | [
"case pos.node.nil\nα : Type u_1\nx : α\nrs : ℕ\nrl : Ordnode α\nrx : α\nrr : Ordnode α\nls : ℕ\nlx : α\nh✝ : ls > delta * rs\nlls : ℕ\nlll : Ordnode α\nllx : α\nllr : Ordnode α\n⊢ (rec nil\n (fun size l x_1 r l_ih r_ih ↦\n rec nil\n (fun size_1 l x_2 r l_ih r_ih ↦\n if size_... | obtain - | ⟨lrs, lrl, lrx, lrr⟩ := lr | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.Ordmap.Invariants | {
"line": 588,
"column": 48
} | {
"line": 588,
"column": 85
} | {
"line": 588,
"column": 86
} | [
{
"pp": "case node.nil.nil\nα : Type u_1\nx : α\nls : ℕ\nlx : α\nlr : Ordnode α\nhr : nil.Balanced\nsr : nil.Sized\nhl : (nil.node' lx lr).Balanced\nsl : (node ls nil lx lr).Sized\n⊢ (nil.node' lx lr).balance x nil = (nil.node' lx lr).balance' x nil",
"ppTerm": "?node.nil.nil",
"assigned": true,
"us... | [
"case node.nil.nil.nil\nα : Type u_1\nx : α\nls : ℕ\nlx : α\nhr : nil.Balanced\nsr : nil.Sized\nhl : (nil.node' lx nil).Balanced\nsl : (node ls nil lx nil).Sized\n⊢ (nil.node' lx nil).balance x nil = (nil.node' lx nil).balance' x nil",
"case node.nil.nil.node\nα : Type u_1\nx : α\nls : ℕ\nlx : α\nhr : nil.Balance... | obtain - | ⟨lrs, lrl, lrx, lrr⟩ := lr | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.Ordmap.Invariants | {
"line": 588,
"column": 48
} | {
"line": 588,
"column": 85
} | {
"line": 588,
"column": 86
} | [
{
"pp": "case node.nil.node\nα : Type u_1\nx : α\nls : ℕ\nlx : α\nlr : Ordnode α\nhr : nil.Balanced\nsr : nil.Sized\nlls : ℕ\nlll : Ordnode α\nllx : α\nllr : Ordnode α\nhl : ((node lls lll llx llr).node' lx lr).Balanced\nsl : (node ls (node lls lll llx llr) lx lr).Sized\n⊢ ((node lls lll llx llr).node' lx lr).b... | [
"case node.nil.node.nil\nα : Type u_1\nx : α\nls : ℕ\nlx : α\nhr : nil.Balanced\nsr : nil.Sized\nlls : ℕ\nlll : Ordnode α\nllx : α\nllr : Ordnode α\nhl : ((node lls lll llx llr).node' lx nil).Balanced\nsl : (node ls (node lls lll llx llr) lx nil).Sized\n⊢ ((node lls lll llx llr).node' lx nil).balance x nil = ((node... | obtain - | ⟨lrs, lrl, lrx, lrr⟩ := lr | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.Ordmap.Invariants | {
"line": 605,
"column": 8
} | {
"line": 605,
"column": 41
} | {
"line": 605,
"column": 41
} | [
{
"pp": "case node.nil.node.nil.refl.refl\nα : Type u_1\nx : α\nls : ℕ\nlx : α\nhr : nil.Balanced\nsr : nil.Sized\nllx : α\nthis : nil.size = 0 ∧ nil.size = 0\nhl : ((node 1 nil llx nil).node' lx nil).Balanced\nsl : (node ls (node 1 nil llx nil) lx nil).Sized\n⊢ node 3 (node 1 nil llx nil) lx (Ordnode.singleton... | [
"case node.nil.node.nil.refl.refl\nα : Type u_1\nx : α\nls : ℕ\nlx : α\nhr : nil.Balanced\nsr : nil.Sized\nllx : α\nthis : nil.size = 0 ∧ nil.size = 0\nhl : ((node 1 nil llx nil).node' lx nil).Balanced\nsl : (node ls (node 1 nil llx nil) lx nil).Sized\n⊢ node 3 (node 1 nil llx nil) lx (Ordnode.singleton x) = (node ... | rw [if_neg, rotateR_node, if_pos] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.PNat.Xgcd | {
"line": 128,
"column": 47
} | {
"line": 128,
"column": 54
} | {
"line": 130,
"column": 0
} | [
{
"pp": "case fst\nu : XgcdType\n⊢ (u.wp + 1) * (u.ap + 1) + u.x * (u.bp + 1) = u.wp + u.x + u.ap + u.wp * u.ap + u.x * u.bp + 1",
"ppTerm": "?fst",
"assigned": true,
"usedConstants": [
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
... | [] | ring_nf | Mathlib.Tactic.RingNF._aux_Mathlib_Tactic_Ring_RingNF___elabRules_Mathlib_Tactic_RingNF_ringNF_1 | Mathlib.Tactic.RingNF.ringNF |
Mathlib.Data.PNat.Xgcd | {
"line": 128,
"column": 47
} | {
"line": 128,
"column": 54
} | {
"line": 130,
"column": 0
} | [
{
"pp": "case snd\nu : XgcdType\n⊢ u.y * (u.ap + 1) + (u.zp + 1) * (u.bp + 1) = u.y + u.zp + u.bp + u.y * u.ap + u.zp * u.bp + 1",
"ppTerm": "?snd",
"assigned": true,
"usedConstants": [
"Mathlib.Tactic.Ring.Common.mul_pf_left",
"Eq.mpr",
"NonAssocSemiring.toAddCommMonoidWithOne",
... | [] | ring_nf | Mathlib.Tactic.RingNF._aux_Mathlib_Tactic_Ring_RingNF___elabRules_Mathlib_Tactic_RingNF_ringNF_1 | Mathlib.Tactic.RingNF.ringNF |
Mathlib.Data.Ordmap.Invariants | {
"line": 632,
"column": 10
} | {
"line": 632,
"column": 47
} | {
"line": 633,
"column": 10
} | [
{
"pp": "case pos.node\nα : Type u_1\nx : α\nls : ℕ\nlx : α\nlr : Ordnode α\nrs : ℕ\nrl : Ordnode α\nrx : α\nrr : Ordnode α\nhr : (node rs rl rx rr).Balanced\nsr : (node rs rl rx rr).Sized\nh : ¬delta * ls < rs\nh_1 : delta * rs < ls\nlls : ℕ\nlll : Ordnode α\nllx : α\nllr : Ordnode α\nhl : (node ls (node lls l... | [
"case pos.node.nil\nα : Type u_1\nx : α\nls : ℕ\nlx : α\nrs : ℕ\nrl : Ordnode α\nrx : α\nrr : Ordnode α\nhr : (node rs rl rx rr).Balanced\nsr : (node rs rl rx rr).Sized\nh : ¬delta * ls < rs\nh_1 : delta * rs < ls\nlls : ℕ\nlll : Ordnode α\nllx : α\nllr : Ordnode α\nhl : (node ls (node lls lll llx llr) lx nil).Bala... | obtain - | ⟨lrs, lrl, lrx, lrr⟩ := lr | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.Ordmap.Ordset | {
"line": 300,
"column": 2
} | {
"line": 300,
"column": 30
} | {
"line": 301,
"column": 2
} | [
{
"pp": "case refine_2\nα : Type u_1\ninst✝ : Preorder α\nl : Ordnode α\nx : α\nr : Ordnode α\no₁ : WithBot α\no₂ : WithTop α\nhl : Valid' o₁ l ↑x\nhr : Valid' (↑x) r o₂\nH1 : ¬l.size + r.size ≤ 1\nH2 : delta * r.size < l.size\nH3 : 2 * l.size ≤ 9 * r.size + 5 ∨ l.size ≤ 3\n⊢ delta * r.dual.size < l.dual.size",... | [
"case refine_3\nα : Type u_1\ninst✝ : Preorder α\nl : Ordnode α\nx : α\nr : Ordnode α\no₁ : WithBot α\no₂ : WithTop α\nhl : Valid' o₁ l ↑x\nhr : Valid' (↑x) r o₂\nH1 : ¬l.size + r.size ≤ 1\nH2 : delta * r.size < l.size\nH3 : 2 * l.size ≤ 9 * r.size + 5 ∨ l.size ≤ 3\n⊢ 2 * l.dual.size ≤ 9 * r.dual.size + 5 ∨ l.dual.... | · rwa [size_dual, size_dual] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Ordmap.Ordset | {
"line": 301,
"column": 2
} | {
"line": 301,
"column": 30
} | {
"line": 303,
"column": 0
} | [
{
"pp": "case refine_3\nα : Type u_1\ninst✝ : Preorder α\nl : Ordnode α\nx : α\nr : Ordnode α\no₁ : WithBot α\no₂ : WithTop α\nhl : Valid' o₁ l ↑x\nhr : Valid' (↑x) r o₂\nH1 : ¬l.size + r.size ≤ 1\nH2 : delta * r.size < l.size\nH3 : 2 * l.size ≤ 9 * r.size + 5 ∨ l.size ≤ 3\n⊢ 2 * l.dual.size ≤ 9 * r.dual.size +... | [] | · rwa [size_dual, size_dual] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Ordmap.Ordset | {
"line": 296,
"column": 2
} | {
"line": 301,
"column": 30
} | {
"line": 303,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\nl : Ordnode α\nx : α\nr : Ordnode α\no₁ : WithBot α\no₂ : WithTop α\nhl : Valid' o₁ l ↑x\nhr : Valid' (↑x) r o₂\nH1 : ¬l.size + r.size ≤ 1\nH2 : delta * r.size < l.size\nH3 : 2 * l.size ≤ 9 * r.size + 5 ∨ l.size ≤ 3\n⊢ Valid' o₁ (l.rotateR x r) o₂",
"ppTerm": "?m.6... | [] | refine Valid'.dual_iff.2 ?_
rw [dual_rotateR]
refine hr.dual.rotateL hl.dual ?_ ?_ ?_
· rwa [size_dual, size_dual, add_comm]
· rwa [size_dual, size_dual]
· rwa [size_dual, size_dual] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Ordmap.Ordset | {
"line": 296,
"column": 2
} | {
"line": 301,
"column": 30
} | {
"line": 303,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\nl : Ordnode α\nx : α\nr : Ordnode α\no₁ : WithBot α\no₂ : WithTop α\nhl : Valid' o₁ l ↑x\nhr : Valid' (↑x) r o₂\nH1 : ¬l.size + r.size ≤ 1\nH2 : delta * r.size < l.size\nH3 : 2 * l.size ≤ 9 * r.size + 5 ∨ l.size ≤ 3\n⊢ Valid' o₁ (l.rotateR x r) o₂",
"ppTerm": "?m.6... | [] | refine Valid'.dual_iff.2 ?_
rw [dual_rotateR]
refine hr.dual.rotateL hl.dual ?_ ?_ ?_
· rwa [size_dual, size_dual, add_comm]
· rwa [size_dual, size_dual]
· rwa [size_dual, size_dual] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.PNat.Xgcd | {
"line": 260,
"column": 20
} | {
"line": 260,
"column": 30
} | {
"line": 260,
"column": 30
} | [
{
"pp": "case fst\nu : XgcdType\nhr : u.r = 0\nha : ↑u.b * u.q = ↑u.a\nthis : u.wp + 1 = ↑u.w\n⊢ ↑u.w * ↑u.b + (↑u.w * u.qp + u.x) * ↑u.b = ↑u.w * (↑u.b * u.q) + u.x * ↑u.b",
"ppTerm": "?fst",
"assigned": true,
"usedConstants": [
"PNat.val",
"Eq.mpr",
"HMul.hMul",
"congrArg",... | [
"case fst\nu : XgcdType\nhr : u.r = 0\nha : ↑u.b * u.q = ↑u.a\nthis : u.wp + 1 = ↑u.w\n⊢ ↑u.w * ↑u.b + (↑u.w * u.qp + u.x) * ↑u.b = ↑u.w * (↑u.b * (u.qp + 1)) + u.x * ↑u.b"
] | u.qp_eq hr | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PNat.Xgcd | {
"line": 263,
"column": 14
} | {
"line": 263,
"column": 24
} | {
"line": 263,
"column": 24
} | [
{
"pp": "case snd\nu : XgcdType\nhr : u.r = 0\nha : ↑u.b * u.q = ↑u.a\n⊢ u.y * ↑u.b + (u.y * u.qp + ↑u.z) * ↑u.b = u.y * (↑u.b * u.q) + ↑u.z * ↑u.b",
"ppTerm": "?snd",
"assigned": true,
"usedConstants": [
"PNat.val",
"Eq.mpr",
"HMul.hMul",
"PNat.XgcdType.y",
"congrArg",... | [
"case snd\nu : XgcdType\nhr : u.r = 0\nha : ↑u.b * u.q = ↑u.a\n⊢ u.y * ↑u.b + (u.y * u.qp + ↑u.z) * ↑u.b = u.y * (↑u.b * (u.qp + 1)) + ↑u.z * ↑u.b"
] | u.qp_eq hr | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PSigma.Order | {
"line": 107,
"column": 6
} | {
"line": 107,
"column": 39
} | {
"line": 107,
"column": 39
} | [
{
"pp": "case inr.inr\nι : Type u_1\nα : ι → Type u_2\ninst✝¹ : LinearOrder ι\ninst✝ : (i : ι) → LinearOrder (α i)\ni : ι\na : α i\nj : ι\nb : α j\nhji : j < i\n⊢ ⟨i, a⟩ ≤ ⟨j, b⟩ ∨ ⟨j, b⟩ ≤ ⟨i, a⟩",
"ppTerm": "?inr.inr",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
"PSigma.Lex.l... | [] | · exact Or.inr (Lex.left _ _ hji) | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.QPF.Multivariate.Constructions.Cofix | {
"line": 115,
"column": 24
} | {
"line": 115,
"column": 35
} | {
"line": 115,
"column": 36
} | [
{
"pp": "case h.left\nn : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nα β : TypeVec.{u} n\ng : α ⟹ β\naa₁ aa₂ : (P F).M α\nr : (P F).M α → (P F).M α → Prop\npr : IsPrecongr r\nra₁a₂✝ : r aa₁ aa₂\nr' : (P F).M β → (P F).M β → Prop := fun b₁ b₂ ↦ ∃ a₁ a₂, r a₁ a₂ ∧ b₁ = g <$$> a₁ ∧ b₂ = g <$$> a₂\nb₁ b₂ : (... | [
"case h.left\nn : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nα β : TypeVec.{u} n\ng : α ⟹ β\naa₁ aa₂ : (P F).M α\nr : (P F).M α → (P F).M α → Prop\npr : IsPrecongr r\nra₁a₂✝ : r aa₁ aa₂\nr' : (P F).M β → (P F).M β → Prop := fun b₁ b₂ ↦ ∃ a₁ a₂, r a₁ a₂ ∧ b₁ = g <$$> a₁ ∧ b₂ = g <$$> a₂\nb₁ b₂ : (P F).M β\na₁... | M.dest_map, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.QPF.Multivariate.Constructions.Cofix | {
"line": 115,
"column": 36
} | {
"line": 115,
"column": 47
} | {
"line": 115,
"column": 48
} | [
{
"pp": "case h.left\nn : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nα β : TypeVec.{u} n\ng : α ⟹ β\naa₁ aa₂ : (P F).M α\nr : (P F).M α → (P F).M α → Prop\npr : IsPrecongr r\nra₁a₂✝ : r aa₁ aa₂\nr' : (P F).M β → (P F).M β → Prop := fun b₁ b₂ ↦ ∃ a₁ a₂, r a₁ a₂ ∧ b₁ = g <$$> a₁ ∧ b₂ = g <$$> a₂\nb₁ b₂ : (... | [
"case h.left\nn : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nα β : TypeVec.{u} n\ng : α ⟹ β\naa₁ aa₂ : (P F).M α\nr : (P F).M α → (P F).M α → Prop\npr : IsPrecongr r\nra₁a₂✝ : r aa₁ aa₂\nr' : (P F).M β → (P F).M β → Prop := fun b₁ b₂ ↦ ∃ a₁ a₂, r a₁ a₂ ∧ b₁ = g <$$> a₁ ∧ b₂ = g <$$> a₂\nb₁ b₂ : (P F).M β\na₁... | M.dest_map, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Ordmap.Ordset | {
"line": 418,
"column": 10
} | {
"line": 418,
"column": 96
} | {
"line": 419,
"column": 8
} | [
{
"pp": "case refine_2\nα : Type u_1\ninst✝ : Preorder α\no₁ : WithBot α\no₂ : WithTop α\nls : ℕ\nll : Ordnode α\nlx : α\nlr : Ordnode α\nhl : Valid' o₁ (Ordnode.node ls ll lx lr) o₂\nrs : ℕ\nrl : Ordnode α\nrx : α\nrr : Ordnode α\nhr : Valid' o₁ (Ordnode.node rs rl rx rr) o₂\nsep : All (fun x ↦ All (fun y ↦ x ... | [] | exact @findMax'_all _ (fun a => All (· > a) (.node rs rl rx rr)) lx lr sep.2.1 sep.2.2 | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Ordmap.Ordset | {
"line": 418,
"column": 10
} | {
"line": 418,
"column": 96
} | {
"line": 419,
"column": 8
} | [
{
"pp": "case refine_2\nα : Type u_1\ninst✝ : Preorder α\no₁ : WithBot α\no₂ : WithTop α\nls : ℕ\nll : Ordnode α\nlx : α\nlr : Ordnode α\nhl : Valid' o₁ (Ordnode.node ls ll lx lr) o₂\nrs : ℕ\nrl : Ordnode α\nrx : α\nrr : Ordnode α\nhr : Valid' o₁ (Ordnode.node rs rl rx rr) o₂\nsep : All (fun x ↦ All (fun y ↦ x ... | [] | exact @findMax'_all _ (fun a => All (· > a) (.node rs rl rx rr)) lx lr sep.2.1 sep.2.2 | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Ordmap.Ordset | {
"line": 418,
"column": 10
} | {
"line": 418,
"column": 96
} | {
"line": 419,
"column": 8
} | [
{
"pp": "case refine_2\nα : Type u_1\ninst✝ : Preorder α\no₁ : WithBot α\no₂ : WithTop α\nls : ℕ\nll : Ordnode α\nlx : α\nlr : Ordnode α\nhl : Valid' o₁ (Ordnode.node ls ll lx lr) o₂\nrs : ℕ\nrl : Ordnode α\nrx : α\nrr : Ordnode α\nhr : Valid' o₁ (Ordnode.node rs rl rx rr) o₂\nsep : All (fun x ↦ All (fun y ↦ x ... | [] | exact @findMax'_all _ (fun a => All (· > a) (.node rs rl rx rr)) lx lr sep.2.1 sep.2.2 | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Ordmap.Ordset | {
"line": 456,
"column": 12
} | {
"line": 456,
"column": 51
} | {
"line": 456,
"column": 52
} | [
{
"pp": "case refine_2\nα : Type u_1\ninst✝ : Preorder α\no₁ : WithBot α\no₂ : WithTop α\nls : ℕ\nll : Ordnode α\nlx : α\nlr : Ordnode α\nrs : ℕ\nrl : Ordnode α\nrx : α\nrr t : Ordnode α\nhl : Valid' o₁ (Ordnode.node ls ll lx lr) o₂\nhr : Valid' o₁ (Ordnode.node rs rl rx rr) o₂\nh : 3 * (ll.size + lr.size + 1) ... | [
"case refine_2\nα : Type u_1\ninst✝ : Preorder α\no₁ : WithBot α\no₂ : WithTop α\nls : ℕ\nll : Ordnode α\nlx : α\nlr : Ordnode α\nrs : ℕ\nrl : Ordnode α\nrx : α\nrr t : Ordnode α\nhl : Valid' o₁ (Ordnode.node ls ll lx lr) o₂\nhr : Valid' o₁ (Ordnode.node rs rl rx rr) o₂\nh : 3 * (ll.size + lr.size + 1) < rl.size + ... | balanceL_eq_balance v.2 hr.2.2.2 H₁ H₂, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.QPF.Multivariate.Constructions.Fix | {
"line": 319,
"column": 4
} | {
"line": 319,
"column": 55
} | {
"line": 320,
"column": 4
} | [
{
"pp": "n : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nα : TypeVec.{u} n\nβ : Fix F α → Type u\ng : (x : F (α ::: Sigma β)) → β (mk ((TypeVec.id ::: Sigma.fst) <$$> x))\nx : Fix F α\ny : Sigma β := rec (fun i ↦ ⟨mk ((TypeVec.id ::: Sigma.fst) <$$> i), g i⟩) x\nx' : F (α ::: Fix F α)\nih :\n (TypeVec.id... | [
"n : ℕ\nF : TypeVec.{u} (n + 1) → Type u\nq : MvQPF F\nα : TypeVec.{u} n\nβ : Fix F α → Type u\ng : (x : F (α ::: Sigma β)) → β (mk ((TypeVec.id ::: Sigma.fst) <$$> x))\nx : Fix F α\ny : Sigma β := rec (fun i ↦ ⟨mk ((TypeVec.id ::: Sigma.fst) <$$> i), g i⟩) x\nx' : F (α ::: Fix F α)\nih : (TypeVec.id ::: fun x ↦ (r... | simp only [appendFun_id_id, MvFunctor.id_map] at ih | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Ordmap.Ordset | {
"line": 731,
"column": 2
} | {
"line": 731,
"column": 63
} | {
"line": 732,
"column": 2
} | [
{
"pp": "α : Type u_1\ninst✝¹ : Preorder α\ninst✝ : DecidableLE α\nx : α\nt : Ordset α\nh_mem : x ∈ t\n⊢ 0 < t.size",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Ordnode",
"Ordset",
"congrArg",
"Preorder.toLE",
"Membership.mem",
"Eq.mp",
"Ordnod... | [
"α : Type u_1\ninst✝¹ : Preorder α\ninst✝ : DecidableLE α\nx : α\nt : Ordset α\nh_mem : Ordnode.mem x ↑t = true\n⊢ 0 < t.size"
] | simp only [Membership.mem, mem, Bool.decide_eq_true] at h_mem | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Real.Sign | {
"line": 59,
"column": 57
} | {
"line": 66,
"column": 30
} | {
"line": 68,
"column": 0
} | [
{
"pp": "r : ℝ\n⊢ r.sign = 0 ↔ r = 0",
"ppTerm": "?m.7",
"assigned": true,
"usedConstants": [
"NegZeroClass.toNeg",
"Real.partialOrder",
"Real",
"Preorder.toLT",
"Real.instZero",
"congrArg",
"NeZero.charZero_one",
"False.elim",
"PartialOrder.toPr... | [] | by
refine ⟨fun h => ?_, fun h => h.symm ▸ sign_zero⟩
obtain hn | rfl | hp := lt_trichotomy r (0 : ℝ)
· rw [sign_of_neg hn, neg_eq_zero] at h
exact (one_ne_zero h).elim
· rfl
· rw [sign_of_pos hp] at h
exact (one_ne_zero h).elim | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.WSeq.Relation | {
"line": 311,
"column": 4
} | {
"line": 329,
"column": 15
} | {
"line": 329,
"column": 15
} | [
{
"pp": "α : Type u\ns✝ t✝ : WSeq α\nh✝ : ∀ (n : ℕ), s✝.get? n ~ t✝.get? n\ns t : WSeq α\nh : (fun s t ↦ ∀ (n : ℕ), s.get? n ~ t.get? n) s t\n⊢ Computation.LiftRel (LiftRelO Eq fun s t ↦ ∀ (n : ℕ), s.get? n ~ t.get? n) s.destruct t.destruct",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
... | [] | refine liftRel_def.2 ⟨?_, ?_⟩
· rw [← head_terminates_iff, ← head_terminates_iff]
exact terminates_congr (h 0)
· intro a b ma mb
rcases a with - | a <;> rcases b with - | b
· trivial
· injection mem_unique (Computation.mem_map _ ma) ((h 0 _).2 (Computation.mem_map _ mb))
· injectio... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.WSeq.Relation | {
"line": 311,
"column": 4
} | {
"line": 329,
"column": 15
} | {
"line": 329,
"column": 15
} | [
{
"pp": "α : Type u\ns✝ t✝ : WSeq α\nh✝ : ∀ (n : ℕ), s✝.get? n ~ t✝.get? n\ns t : WSeq α\nh : (fun s t ↦ ∀ (n : ℕ), s.get? n ~ t.get? n) s t\n⊢ Computation.LiftRel (LiftRelO Eq fun s t ↦ ∀ (n : ℕ), s.get? n ~ t.get? n) s.destruct t.destruct",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
... | [] | refine liftRel_def.2 ⟨?_, ?_⟩
· rw [← head_terminates_iff, ← head_terminates_iff]
exact terminates_congr (h 0)
· intro a b ma mb
rcases a with - | a <;> rcases b with - | b
· trivial
· injection mem_unique (Computation.mem_map _ ma) ((h 0 _).2 (Computation.mem_map _ mb))
· injectio... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.WSeq.Basic | {
"line": 679,
"column": 66
} | {
"line": 679,
"column": 76
} | {
"line": 681,
"column": 0
} | [
{
"pp": "α : Type u\nβ : Type v\nf : α → β\na : α\n⊢ map f (ret a) = ret (f a)",
"ppTerm": "?m.7",
"assigned": true,
"usedConstants": [
"congrArg",
"Stream'.WSeq.cons",
"Stream'.WSeq.map_cons",
"Stream'.WSeq.ofList_cons",
"congr",
"Stream'.WSeq.map",
"True",... | [] | simp [ret] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.WSeq.Basic | {
"line": 679,
"column": 66
} | {
"line": 679,
"column": 76
} | {
"line": 681,
"column": 0
} | [
{
"pp": "α : Type u\nβ : Type v\nf : α → β\na : α\n⊢ map f (ret a) = ret (f a)",
"ppTerm": "?m.7",
"assigned": true,
"usedConstants": [
"congrArg",
"Stream'.WSeq.cons",
"Stream'.WSeq.map_cons",
"Stream'.WSeq.ofList_cons",
"congr",
"Stream'.WSeq.map",
"True",... | [] | simp [ret] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.WSeq.Basic | {
"line": 679,
"column": 66
} | {
"line": 679,
"column": 76
} | {
"line": 681,
"column": 0
} | [
{
"pp": "α : Type u\nβ : Type v\nf : α → β\na : α\n⊢ map f (ret a) = ret (f a)",
"ppTerm": "?m.7",
"assigned": true,
"usedConstants": [
"congrArg",
"Stream'.WSeq.cons",
"Stream'.WSeq.map_cons",
"Stream'.WSeq.ofList_cons",
"congr",
"Stream'.WSeq.map",
"True",... | [] | simp [ret] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.WSeq.Basic | {
"line": 696,
"column": 2
} | {
"line": 723,
"column": 39
} | {
"line": 725,
"column": 0
} | [
{
"pp": "α : Type u\na : α\n⊢ ∀ {S : WSeq (WSeq α)}, a ∈ S.join → ∃ s ∈ S, a ∈ s",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Stream'.WSeq.seq_destruct_cons",
"Stream'.Seq",
"False",
"Stream'.WSeq.join",
"Stream'.WSeq.seq_destruct_think",
... | [] | suffices
∀ ss : WSeq α,
a ∈ ss → ∀ s S, append s (join S) = ss → a ∈ append s (join S) → a ∈ s ∨ ∃ s, s ∈ S ∧ a ∈ s
from fun S h => (this _ h nil S (by simp) (by simp [h])).resolve_left (notMem_nil _)
intro ss h
apply mem_rec_on h
· intro b ss o s S ej m
induction s using WSeq.recOn <;>
[i... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.WSeq.Basic | {
"line": 696,
"column": 2
} | {
"line": 723,
"column": 39
} | {
"line": 725,
"column": 0
} | [
{
"pp": "α : Type u\na : α\n⊢ ∀ {S : WSeq (WSeq α)}, a ∈ S.join → ∃ s ∈ S, a ∈ s",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Stream'.WSeq.seq_destruct_cons",
"Stream'.Seq",
"False",
"Stream'.WSeq.join",
"Stream'.WSeq.seq_destruct_think",
... | [] | suffices
∀ ss : WSeq α,
a ∈ ss → ∀ s S, append s (join S) = ss → a ∈ append s (join S) → a ∈ s ∨ ∃ s, s ∈ S ∧ a ∈ s
from fun S h => (this _ h nil S (by simp) (by simp [h])).resolve_left (notMem_nil _)
intro ss h
apply mem_rec_on h
· intro b ss o s S ej m
induction s using WSeq.recOn <;>
[i... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Sym.NatCard | {
"line": 36,
"column": 13
} | {
"line": 36,
"column": 37
} | {
"line": 36,
"column": 37
} | [
{
"pp": "case inl\nα : Type u_1\nk : ℕ\nh✝ : Finite α\nval✝ : Fintype α\nthis : DecidableEq α := Classical.decEq α\n⊢ Nat.card (Sym α k) = (Nat.card α).multichoose k",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Sym.instFintype",
"Fintype.car... | [
"case inl\nα : Type u_1\nk : ℕ\nh✝ : Finite α\nval✝ : Fintype α\nthis : DecidableEq α := Classical.decEq α\n⊢ Fintype.card (Sym α k) = (Fintype.card α).multichoose k"
] | Nat.card_eq_fintype_card | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Sym.NatCard | {
"line": 66,
"column": 13
} | {
"line": 66,
"column": 37
} | {
"line": 66,
"column": 37
} | [
{
"pp": "case inl\nα : Type u_1\nh✝ : Finite α\nval✝ : Fintype α\nthis : DecidableEq α := Classical.decEq α\n⊢ Nat.card { a // ¬a.IsDiag } = (Nat.card α).choose 2",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"instDecidableNot",
"Nat.choose",
"congrArg",
... | [
"case inl\nα : Type u_1\nh✝ : Finite α\nval✝ : Fintype α\nthis : DecidableEq α := Classical.decEq α\n⊢ Fintype.card { a // ¬a.IsDiag } = (Fintype.card α).choose 2"
] | Nat.card_eq_fintype_card | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Sym.NatCard | {
"line": 80,
"column": 13
} | {
"line": 80,
"column": 37
} | {
"line": 80,
"column": 37
} | [
{
"pp": "case inl\nα : Type u_1\nh✝ : Finite α\nval✝ : Fintype α\nthis : DecidableEq α := Classical.decEq α\n⊢ Nat.card (Sym2 α) = (Nat.card α + 1).choose 2",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.choose",
"congrArg",
"Fintype.card",
"id"... | [
"case inl\nα : Type u_1\nh✝ : Finite α\nval✝ : Fintype α\nthis : DecidableEq α := Classical.decEq α\n⊢ Fintype.card (Sym2 α) = (Fintype.card α + 1).choose 2"
] | Nat.card_eq_fintype_card | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Order.SemiconjSup | {
"line": 89,
"column": 34
} | {
"line": 92,
"column": 61
} | {
"line": 94,
"column": 0
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\ninst✝¹ : PartialOrder α\ninst✝ : Preorder β\nfa : α ≃o α\nfb : β ↪o β\ng : α → β\nh : Semiconj g ⇑fa ⇑fb\ng' : β → α\nhg' : IsOrderRightAdjoint g g'\n⊢ Semiconj g' ⇑fb ⇑fa",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
... | [] | by
refine fun y => (hg' _).unique ?_
rw [← fa.surjective.image_preimage { x | g x ≤ fb y }, preimage_setOf_eq]
simp only [h.eq, fb.le_iff_le, fa.isLUB_image'.mpr (hg' _)] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Dynamics.Ergodic.Ergodic | {
"line": 97,
"column": 4
} | {
"line": 99,
"column": 60
} | {
"line": 101,
"column": 0
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\nf : α → α\nμ : Measure α\nβ : Type u_2\nm' : MeasurableSpace β\nμ' : Measure β\ng : α → β\nhg : MeasurePreserving g μ μ'\nhf : PreErgodic f μ\nf' : β → β\nh_comm : Semiconj g f f'\ns : Set β\nhs₀ : MeasurableSet s\nhs₁ : f' ⁻¹' s = s\n⊢ EventuallyConst s (ae μ')",
... | [] | rw [← hg.aeconst_preimage hs₀.nullMeasurableSet]
apply hf.aeconst_set (hg.measurable hs₀)
rw [← preimage_comp, h_comm.comp_eq, preimage_comp, hs₁] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Dynamics.Ergodic.Ergodic | {
"line": 97,
"column": 4
} | {
"line": 99,
"column": 60
} | {
"line": 101,
"column": 0
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\nf : α → α\nμ : Measure α\nβ : Type u_2\nm' : MeasurableSpace β\nμ' : Measure β\ng : α → β\nhg : MeasurePreserving g μ μ'\nhf : PreErgodic f μ\nf' : β → β\nh_comm : Semiconj g f f'\ns : Set β\nhs₀ : MeasurableSet s\nhs₁ : f' ⁻¹' s = s\n⊢ EventuallyConst s (ae μ')",
... | [] | rw [← hg.aeconst_preimage hs₀.nullMeasurableSet]
apply hf.aeconst_set (hg.measurable hs₀)
rw [← preimage_comp, h_comm.comp_eq, preimage_comp, hs₁] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Dynamics.Ergodic.Ergodic | {
"line": 118,
"column": 2
} | {
"line": 122,
"column": 78
} | {
"line": 124,
"column": 0
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\nf : α → α\nμ : Measure α\nβ : Type u_2\nm' : MeasurableSpace β\nμ' : Measure β\ne : α ≃ᵐ β\nh : MeasurePreserving (⇑e) μ μ'\n⊢ Ergodic (⇑e ∘ f ∘ ⇑e.symm) μ' ↔ Ergodic f μ",
"ppTerm": "?m.26",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"M... | [] | have : MeasurePreserving (e ∘ f ∘ e.symm) μ' μ' ↔ MeasurePreserving f μ μ := by
rw [h.comp_left_iff, (MeasurePreserving.symm e h).comp_right_iff]
replace h : PreErgodic (e ∘ f ∘ e.symm) μ' ↔ PreErgodic f μ := h.preErgodic_conjugate_iff
exact ⟨fun hf => { this.mp hf.toMeasurePreserving, h.mp hf.toPreErgodic with... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Dynamics.Ergodic.Ergodic | {
"line": 118,
"column": 2
} | {
"line": 122,
"column": 78
} | {
"line": 124,
"column": 0
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\nf : α → α\nμ : Measure α\nβ : Type u_2\nm' : MeasurableSpace β\nμ' : Measure β\ne : α ≃ᵐ β\nh : MeasurePreserving (⇑e) μ μ'\n⊢ Ergodic (⇑e ∘ f ∘ ⇑e.symm) μ' ↔ Ergodic f μ",
"ppTerm": "?m.26",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"M... | [] | have : MeasurePreserving (e ∘ f ∘ e.symm) μ' μ' ↔ MeasurePreserving f μ μ := by
rw [h.comp_left_iff, (MeasurePreserving.symm e h).comp_right_iff]
replace h : PreErgodic (e ∘ f ∘ e.symm) μ' ↔ PreErgodic f μ := h.preErgodic_conjugate_iff
exact ⟨fun hf => { this.mp hf.toMeasurePreserving, h.mp hf.toPreErgodic with... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | {
"line": 626,
"column": 2
} | {
"line": 632,
"column": 55
} | {
"line": 634,
"column": 0
} | [
{
"pp": "f g : CircleDeg1Lift\nh : Commute f g\n⊢ τ (f * g) = τ f + τ g",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Real.instLE",
"Real",
"instHDiv",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CircleDeg1Lift.tendsto_translationNumbe... | [] | refine tendsto_nhds_unique ?_
(f.tendsto_translationNumber_aux.add g.tendsto_translationNumber_aux)
simp only [transnumAuxSeq, ← add_div]
refine (f * g).tendsto_translationNumber_of_dist_bounded_aux
(fun n ↦ (f ^ n) 0 + (g ^ n) 0) 1 fun n ↦ ?_
rw [h.mul_pow, dist_comm]
exact le_of_lt ((f ^ n).dist_map_m... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | {
"line": 626,
"column": 2
} | {
"line": 632,
"column": 55
} | {
"line": 634,
"column": 0
} | [
{
"pp": "f g : CircleDeg1Lift\nh : Commute f g\n⊢ τ (f * g) = τ f + τ g",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Real.instLE",
"Real",
"instHDiv",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CircleDeg1Lift.tendsto_translationNumbe... | [] | refine tendsto_nhds_unique ?_
(f.tendsto_translationNumber_aux.add g.tendsto_translationNumber_aux)
simp only [transnumAuxSeq, ← add_div]
refine (f * g).tendsto_translationNumber_of_dist_bounded_aux
(fun n ↦ (f ^ n) 0 + (g ^ n) 0) 1 fun n ↦ ?_
rw [h.mul_pow, dist_comm]
exact le_of_lt ((f ^ n).dist_map_m... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.MeasureTheory.Group.AddCircle | {
"line": 86,
"column": 33
} | {
"line": 86,
"column": 57
} | {
"line": 86,
"column": 57
} | [
{
"pp": "T : ℝ\nhT : Fact (0 < T)\nI : Set (AddCircle T)\nu x : AddCircle T\nhu : IsOfFinAddOrder u\nG : AddSubgroup (AddCircle T) := AddSubgroup.zmultiples u\nn : ℕ := addOrderOf u\nB : Set (AddCircle T) := ball x (T / (2 * ↑n))\nhn : 1 ≤ ↑n\nhI : I =ᵐ[volume] closedBall x (T / (2 * ↑n))\nthis : Fintype ↥G\n⊢ ... | [
"T : ℝ\nhT : Fact (0 < T)\nI : Set (AddCircle T)\nu x : AddCircle T\nhu : IsOfFinAddOrder u\nG : AddSubgroup (AddCircle T) := AddSubgroup.zmultiples u\nn : ℕ := addOrderOf u\nB : Set (AddCircle T) := ball x (T / (2 * ↑n))\nhn : 1 ≤ ↑n\nhI : I =ᵐ[volume] closedBall x (T / (2 * ↑n))\nthis : Fintype ↥G\n⊢ #Finset.univ... | Nat.card_eq_fintype_card | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Dynamics.Ergodic.Conservative | {
"line": 152,
"column": 2
} | {
"line": 152,
"column": 66
} | {
"line": 153,
"column": 2
} | [
{
"pp": "α : Type u_1\ninst✝ : MeasurableSpace α\nf : α → α\ns : Set α\nμ : Measure α\nhf : Conservative f μ\nhs : NullMeasurableSet s μ\nn : ℕ\nH : ¬μ {x | x ∈ s ∧ ∀ m ≥ n, f^[m] x ∉ s} = 0\nthis : NullMeasurableSet (s ∩ {x | ∀ m ≥ n, f^[m] x ∉ s}) μ\nm : ℕ\nhmn : m > n\nhm : μ (s ∩ {x | ∀ m ≥ n, f^[m] x ∉ s} ... | [
"α : Type u_1\ninst✝ : MeasurableSpace α\nf : α → α\ns : Set α\nμ : Measure α\nhf : Conservative f μ\nhs : NullMeasurableSet s μ\nn : ℕ\nH : ¬μ {x | x ∈ s ∧ ∀ m ≥ n, f^[m] x ∉ s} = 0\nthis : NullMeasurableSet (s ∩ {x | ∀ m ≥ n, f^[m] x ∉ s}) μ\nm : ℕ\nhmn : m > n\nhm : μ (s ∩ {x | ∀ m ≥ n, f^[m] x ∉ s} ∩ f^[m] ⁻¹' ... | rcases nonempty_of_measure_ne_zero hm with ⟨x, ⟨_, hxn⟩, hxm, -⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 119,
"column": 2
} | {
"line": 119,
"column": 76
} | {
"line": 120,
"column": 2
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\nμ : Measure α\nf : α → ℝ≥0∞\nν : Measure α\ninst✝¹ : SigmaFinite μ\ninst✝ : SigmaFinite ν\nhμν : μ ≪ ν\nhf : AEMeasurable f ν\n⊢ (μ.withDensity f).rnDeriv ν =ᵐ[ν] fun x ↦ f x * μ.rnDeriv ν x",
"ppTerm": "?m.31",
"assigned": true,
"usedConstants": [
... | [
"case refine_1\nα : Type u_1\nm : MeasurableSpace α\nμ : Measure α\nf : α → ℝ≥0∞\nν : Measure α\ninst✝¹ : SigmaFinite μ\ninst✝ : SigmaFinite ν\nhμν : μ ≪ ν\nhf : AEMeasurable f ν\n⊢ AEMeasurable (fun x ↦ f x * μ.rnDeriv ν x) ν",
"case refine_2\nα : Type u_1\nm : MeasurableSpace α\nμ : Measure α\nf : α → ℝ≥0∞\nν :... | refine (Measure.eq_rnDeriv₀ ?_ Measure.MutuallySingular.zero_left ?_).symm | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 189,
"column": 2
} | {
"line": 189,
"column": 40
} | {
"line": 190,
"column": 2
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\nμ ν ν' : Measure α\ninst✝¹ : μ.HaveLebesgueDecomposition ν'\ninst✝ : SigmaFinite ν'\nh : μ ⟂ₘ ν\nhνν' : ν ≪ ν'\nt : Set α := h.nullSet\nht : MeasurableSet t\n⊢ ∀ᵐ (x : α) ∂ν.restrict t, μ.rnDeriv ν' x = 0 x",
"ppTerm": "?m.42",
"assigned": true,
"usedCon... | [
"α : Type u_1\nm : MeasurableSpace α\nμ ν ν' : Measure α\ninst✝¹ : μ.HaveLebesgueDecomposition ν'\ninst✝ : SigmaFinite ν'\nh : μ ⟂ₘ ν\nhνν' : ν ≪ ν'\nt : Set α := h.nullSet\nht : MeasurableSet t\n⊢ μ.rnDeriv ν' =ᵐ[ν.restrict t] 0"
] | change μ.rnDeriv ν' =ᵐ[ν.restrict t] 0 | Lean.Elab.Tactic.evalChange | Lean.Parser.Tactic.change |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.