module string | startPos dict | endPos dict | nextStartPos dict | goals list | goalsAfter list | ppTac string | elaborator string | kind string |
|---|---|---|---|---|---|---|---|---|
Mathlib.Computability.RegularExpressions | {
"line": 203,
"column": 2
} | {
"line": 207,
"column": 16
} | {
"line": 209,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nP Q : RegularExpression α\nx : List α\n⊢ (P + Q).rmatch x = true ↔ P.rmatch x = true ∨ Q.rmatch x = true",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"RegularExpression.deriv_add",
"Eq.mpr",
"RegularExpression.rmatch",
... | [] | induction x generalizing P Q with
| nil => simp only [rmatch, matchEpsilon, Bool.or_eq_true_iff]
| cons _ _ ih =>
rw [rmatch, deriv_add]
exact ih _ _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.RegularExpressions | {
"line": 203,
"column": 2
} | {
"line": 207,
"column": 16
} | {
"line": 209,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nP Q : RegularExpression α\nx : List α\n⊢ (P + Q).rmatch x = true ↔ P.rmatch x = true ∨ Q.rmatch x = true",
"ppTerm": "?m.11",
"assigned": true,
"usedConstants": [
"RegularExpression.deriv_add",
"Eq.mpr",
"RegularExpression.rmatch",
... | [] | induction x generalizing P Q with
| nil => simp only [rmatch, matchEpsilon, Bool.or_eq_true_iff]
| cons _ _ ih =>
rw [rmatch, deriv_add]
exact ih _ _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.RegularExpressions | {
"line": 218,
"column": 11
} | {
"line": 218,
"column": 31
} | {
"line": 218,
"column": 31
} | [
{
"pp": "case nil.mp\nα : Type u_1\ninst✝ : DecidableEq α\nP Q : RegularExpression α\nh : (P.matchEpsilon && Q.matchEpsilon) = true\n⊢ P.matchEpsilon = true ∧ Q.matchEpsilon = true",
"ppTerm": "?nil.mp",
"assigned": true,
"usedConstants": [
"congrArg",
"Eq.mp",
"Bool.and",
"R... | [
"case nil.mp\nα : Type u_1\ninst✝ : DecidableEq α\nP Q : RegularExpression α\nh : P.matchEpsilon = true ∧ Q.matchEpsilon = true\n⊢ P.matchEpsilon = true ∧ Q.matchEpsilon = true"
] | Bool.and_eq_true_iff | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 702,
"column": 4
} | {
"line": 704,
"column": 11
} | {
"line": 706,
"column": 0
} | [
{
"pp": "case succ\nΓ : Type u_1\nΛ : Type u_2\nσ : Type u_3\nn : ℕ\nd : Dir\nq : Stmt Bool (Λ' Γ Λ σ) σ\nv : σ\ni : ℕ\nIH : ∀ (T : Tape Bool), stepAux ((Stmt.move d)^[i] q) v T = stepAux q v ((Tape.move d)^[i] T)\nT : Tape Bool\n⊢ stepAux ((Stmt.move d)^[i + 1] q) v T = stepAux q v ((Tape.move d)^[i + 1] T)",
... | [] | rw [iterate_succ', iterate_succ]
simp only [stepAux, Function.comp_apply]
rw [IH] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 702,
"column": 4
} | {
"line": 704,
"column": 11
} | {
"line": 706,
"column": 0
} | [
{
"pp": "case succ\nΓ : Type u_1\nΛ : Type u_2\nσ : Type u_3\nn : ℕ\nd : Dir\nq : Stmt Bool (Λ' Γ Λ σ) σ\nv : σ\ni : ℕ\nIH : ∀ (T : Tape Bool), stepAux ((Stmt.move d)^[i] q) v T = stepAux q v ((Tape.move d)^[i] T)\nT : Tape Bool\n⊢ stepAux ((Stmt.move d)^[i + 1] q) v T = stepAux q v ((Tape.move d)^[i + 1] T)",
... | [] | rw [iterate_succ', iterate_succ]
simp only [stepAux, Function.comp_apply]
rw [IH] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 736,
"column": 47
} | {
"line": 741,
"column": 28
} | {
"line": 743,
"column": 0
} | [
{
"pp": "Γ : Type u_1\nΛ : Type u_2\nσ : Type u_3\nn : ℕ\nenc : Γ → List.Vector Bool n\ndec : List.Vector Bool n → Γ\nM : Λ → Stmt Γ Λ σ\ninst✝ : Inhabited Γ\nenc0 : enc default = List.Vector.replicate n false\nL R : ListBlank Γ\n⊢ Tape Bool",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
... | [] | by
refine
Tape.mk' (L.flatMap (fun x ↦ (enc x).toList.reverse) ⟨n, ?_⟩)
(R.flatMap (fun x ↦ (enc x).toList) ⟨n, ?_⟩) <;>
simp only [enc0, List.Vector.replicate, List.reverse_replicate, Bool.default_bool,
List.Vector.toList_mk] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 789,
"column": 41
} | {
"line": 789,
"column": 61
} | {
"line": 789,
"column": 62
} | [
{
"pp": "case succ\nΓ : Type u_1\nn : ℕ\nenc : Γ → List.Vector Bool n\ninst✝ : Inhabited Γ\nenc0 : enc default = List.Vector.replicate n false\nL R : ListBlank Γ\nL✝ : Tape Bool\ni : ℕ\nIH : (Tape.move Dir.right)^[i] ((Tape.move Dir.left)^[i] L✝) = L✝\n⊢ (Tape.move Dir.right)^[i] (Tape.move Dir.right ((Tape.mov... | [
"case succ\nΓ : Type u_1\nn : ℕ\nenc : Γ → List.Vector Bool n\ninst✝ : Inhabited Γ\nenc0 : enc default = List.Vector.replicate n false\nL R : ListBlank Γ\nL✝ : Tape Bool\ni : ℕ\nIH : (Tape.move Dir.right)^[i] ((Tape.move Dir.left)^[i] L✝) = L✝\n⊢ (Tape.move Dir.right)^[i] (Tape.move Dir.right (Tape.move Dir.left ((... | iterate_succ_apply', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 836,
"column": 6
} | {
"line": 837,
"column": 9
} | {
"line": 839,
"column": 0
} | [
{
"pp": "Γ : Type u_1\nΛ : Type u_2\nσ : Type u_3\nn : ℕ\nenc : Γ → List.Vector Bool n\ndec : List.Vector Bool n → Γ\ninst✝ : Inhabited Γ\nenc0 : enc default = List.Vector.replicate n false\nencdec : ∀ (a : Γ), dec (enc a) = a\nv : σ\nL' R' : ListBlank Bool\na : Bool\nl₂ : List Bool\nIH :\n ∀ (l₁ : List Bool) ... | [] | rw [← ListBlank.append, IH]
rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.PostTuringMachine | {
"line": 836,
"column": 6
} | {
"line": 837,
"column": 9
} | {
"line": 839,
"column": 0
} | [
{
"pp": "Γ : Type u_1\nΛ : Type u_2\nσ : Type u_3\nn : ℕ\nenc : Γ → List.Vector Bool n\ndec : List.Vector Bool n → Γ\ninst✝ : Inhabited Γ\nenc0 : enc default = List.Vector.replicate n false\nencdec : ∀ (a : Γ), dec (enc a) = a\nv : σ\nL' R' : ListBlank Bool\na : Bool\nl₂ : List Bool\nIH :\n ∀ (l₁ : List Bool) ... | [] | rw [← ListBlank.append, IH]
rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.Config | {
"line": 609,
"column": 6
} | {
"line": 609,
"column": 55
} | {
"line": 610,
"column": 6
} | [
{
"pp": "f : Code\nk : Cont\nv : List ℕ\nfok : f.Ok\nx : Cfg\nthis :\n ∀ (c : Cfg),\n x ∈ eval step c →\n ∀ (v : List ℕ) (c' : Cfg),\n c = c'.then (Cont.fix f k) →\n Reaches step (stepNormal f Cont.halt v) c' →\n ∃ v₁ ∈ f.eval v,\n ∃ v₂ ∈ if v₁.headI = 0 then pur... | [
"f : Code\nk : Cont\nv : List ℕ\nfok : f.Ok\nx : Cfg\nthis :\n ∀ (c : Cfg),\n x ∈ eval step c →\n ∀ (v : List ℕ) (c' : Cfg),\n c = c'.then (Cont.fix f k) →\n Reaches step (stepNormal f Cont.halt v) c' →\n ∃ v₁ ∈ f.eval v,\n ∃ v₂ ∈ if v₁.headI = 0 then pure v₁.tail el... | simp only [Part.eq_some_iff.2 hv₁, Part.map_some] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Topology.Separation.Profinite | {
"line": 59,
"column": 12
} | {
"line": 59,
"column": 15
} | {
"line": 59,
"column": 16
} | [
{
"pp": "X : Type u_1\ninst✝³ : TopologicalSpace X\ninst✝² : T2Space X\ninst✝¹ : CompactSpace X\ninst✝ : TotallyDisconnectedSpace X\nx : X\nU : Set X\nhx : ⋂ s, ↑s = {x}\nhU : U ∈ 𝓝 x\nN : Type (max 0 u_1) := { s // IsClopen s ∧ x ∈ s }\nthis : Nonempty N\nhNcl : ∀ (s : N), IsClosed[inst✝³] ↑s\nhdir : Directed... | [
"X : Type u_1\ninst✝³ : TopologicalSpace X\ninst✝² : T2Space X\ninst✝¹ : CompactSpace X\ninst✝ : TotallyDisconnectedSpace X\nx : X\nU : Set X\nhx : ⋂ s, ↑s = {x}\nhU : U ∈ 𝓝 x\nN : Type (max 0 u_1) := { s // IsClopen s ∧ x ∈ s }\nthis : Nonempty N\nhNcl : ∀ (s : N), IsClosed[inst✝³] ↑s\nhdir : Directed GE.ge fun s... | hx, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Topology.Category.Stonean.Basic | {
"line": 132,
"column": 2
} | {
"line": 133,
"column": 91
} | {
"line": 134,
"column": 2
} | [
{
"pp": "X Y : Stonean\nf : X ⟶ Y\nh : Epi f\ny : ↑Y.toTop\nhy : ∀ (a : ↑X.toTop), (ConcreteCategory.hom f) a ≠ y\nC : Set ((fun X ↦ ↑X.toTop) Y) := Set.range ⇑(ConcreteCategory.hom f)\nhC : IsClosed C\nU : Set ((fun X ↦ ↑X.toTop) Y) := Cᶜ\n⊢ False",
"ppTerm": "?m.74",
"assigned": true,
"usedConstan... | [
"X Y : Stonean\nf : X ⟶ Y\nh : Epi f\ny : ↑Y.toTop\nhy : ∀ (a : ↑X.toTop), (ConcreteCategory.hom f) a ≠ y\nC : Set ((fun X ↦ ↑X.toTop) Y) := Set.range ⇑(ConcreteCategory.hom f)\nhC : IsClosed C\nU : Set ((fun X ↦ ↑X.toTop) Y) := Cᶜ\nhUy : U ∈ 𝓝 y\n⊢ False"
] | have hUy : U ∈ 𝓝 y := by
simp only [U, C, Set.mem_range, hy, exists_false, not_false_eq_true, hC.compl_mem_nhds] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Topology.Separation.Profinite | {
"line": 201,
"column": 4
} | {
"line": 201,
"column": 49
} | {
"line": 202,
"column": 4
} | [
{
"pp": "case h_option.refine_1\nX : Type u_4\nI✝ : Type u_5\ninst✝⁵ : TopologicalSpace X\ninst✝⁴ : CompactSpace X\ninst✝³ : T2Space X\ninst✝² : TotallyDisconnectedSpace X\ninst✝¹ : Finite I✝\nI : Type u_5\ninst✝ : Fintype I\nIH :\n ∀ {Z D : I → Set X},\n (∀ (i : I), IsClosed[inst✝⁵] (Z i)) →\n (∀ (i :... | [
"case h_option.refine_4\nX : Type u_4\nI✝ : Type u_5\ninst✝⁵ : TopologicalSpace X\ninst✝⁴ : CompactSpace X\ninst✝³ : T2Space X\ninst✝² : TotallyDisconnectedSpace X\ninst✝¹ : Finite I✝\nI : Type u_5\ninst✝ : Fintype I\nIH :\n ∀ {Z D : I → Set X},\n (∀ (i : I), IsClosed[inst✝⁵] (Z i)) →\n (∀ (i : I), IsClope... | all_goals try rintro (_ | i); all_goals grind | Lean.Elab.Tactic.evalAllGoals | Lean.Parser.Tactic.allGoals |
Mathlib.Topology.DiscreteQuotient | {
"line": 205,
"column": 2
} | {
"line": 205,
"column": 18
} | {
"line": 206,
"column": 2
} | [
{
"pp": "X : Type u_2\ninst✝ : TopologicalSpace X\nA B C : DiscreteQuotient X\nh₁ : A ≤ B\nh₂ : B ≤ C\nx : Quotient A.toSetoid\n⊢ ofLE h₂ (ofLE h₁ x) = ofLE ⋯ x",
"ppTerm": "?m.28",
"assigned": true,
"usedConstants": [
"DiscreteQuotient.ofLE",
"DiscreteQuotient.toSetoid",
"PartialO... | [
"case mk\nX : Type u_2\ninst✝ : TopologicalSpace X\nA B C : DiscreteQuotient X\nh₁ : A ≤ B\nh₂ : B ≤ C\nx : Quotient A.toSetoid\na✝ : X\n⊢ ofLE h₂ (ofLE h₁ (Quot.mk (⇑A.toSetoid) a✝)) = ofLE ⋯ (Quot.mk (⇑A.toSetoid) a✝)"
] | rcases x with ⟨⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRCases | Lean.Parser.Tactic.rcases |
Mathlib.Topology.Separation.Profinite | {
"line": 216,
"column": 6
} | {
"line": 217,
"column": 70
} | {
"line": 218,
"column": 6
} | [
{
"pp": "case h_option.refine_5.none.some\nX : Type u_4\nI✝ : Type u_5\ninst✝⁵ : TopologicalSpace X\ninst✝⁴ : CompactSpace X\ninst✝³ : T2Space X\ninst✝² : TotallyDisconnectedSpace X\ninst✝¹ : Finite I✝\nI : Type u_5\ninst✝ : Fintype I\nIH :\n ∀ {Z D : I → Set X},\n (∀ (i : I), IsClosed[inst✝⁵] (Z i)) →\n ... | [
"case h_option.refine_5.some.none\nX : Type u_4\nI✝ : Type u_5\ninst✝⁵ : TopologicalSpace X\ninst✝⁴ : CompactSpace X\ninst✝³ : T2Space X\ninst✝² : TotallyDisconnectedSpace X\ninst✝¹ : Finite I✝\nI : Type u_5\ninst✝ : Fintype I\nIH :\n ∀ {Z D : I → Set X},\n (∀ (i : I), IsClosed[inst✝⁵] (Z i)) →\n (∀ (i : I... | · simpa [C, C0, Set.not_nonempty_iff_eq_empty, ← Set.disjoint_iff_inter_eq_empty] using
Disjoint.mono_right (subset_iUnion C' j) disjoint_sdiff_left | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Topology.Category.TopCat.Limits.Cofiltered | {
"line": 67,
"column": 4
} | {
"line": 67,
"column": 25
} | {
"line": 68,
"column": 4
} | [
{
"pp": "case e'_3.mpr\nJ : Type v\ninst✝¹ : Category.{w, v} J\ninst✝ : IsCofiltered J\nF : J ⥤ TopCat\nC : Cone F\nhC : IsLimit C\nT : (j : J) → Set (Set ↑(F.obj j))\nhT : ∀ (j : J), IsTopologicalBasis (T j)\nuniv : ∀ (i : J), Set.univ ∈ T i\ninter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1... | [
"case e'_3.mpr.refine_1\nJ : Type v\ninst✝¹ : Category.{w, v} J\ninst✝ : IsCofiltered J\nF : J ⥤ TopCat\nC : Cone F\nhC : IsLimit C\nT : (j : J) → Set (Set ↑(F.obj j))\nhT : ∀ (j : J), IsTopologicalBasis (T j)\nuniv : ∀ (i : J), Set.univ ∈ T i\ninter : ∀ (i : J) (U1 U2 : Set ↑(F.obj i)), U1 ∈ T i → U2 ∈ T i → U1 ∩ ... | refine ⟨j, V, ?_, ?_⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Topology.FiberPartition | {
"line": 66,
"column": 2
} | {
"line": 68,
"column": 40
} | {
"line": 70,
"column": 0
} | [
{
"pp": "S : Type u_1\nY : Type u_2\nf : S → Y\ninst✝¹ : TopologicalSpace S\nl : LocallyConstant S Y\ninst✝ : CompactSpace S\nx : Fiber ⇑l\n⊢ CompactSpace ↑↑x",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"isCompact_iff_compactSpace",
"congrArg",
"IsLocal... | [] | obtain ⟨y, hy⟩ := x.prop
rw [← isCompact_iff_compactSpace, ← hy]
exact (l.2.isClosed_fiber _).isCompact | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.FiberPartition | {
"line": 66,
"column": 2
} | {
"line": 68,
"column": 40
} | {
"line": 70,
"column": 0
} | [
{
"pp": "S : Type u_1\nY : Type u_2\nf : S → Y\ninst✝¹ : TopologicalSpace S\nl : LocallyConstant S Y\ninst✝ : CompactSpace S\nx : Fiber ⇑l\n⊢ CompactSpace ↑↑x",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"isCompact_iff_compactSpace",
"congrArg",
"IsLocal... | [] | obtain ⟨y, hy⟩ := x.prop
rw [← isCompact_iff_compactSpace, ← hy]
exact (l.2.isClosed_fiber _).isCompact | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 1223,
"column": 10
} | {
"line": 1223,
"column": 19
} | {
"line": 1223,
"column": 20
} | [
{
"pp": "case cons.refine_2.refine_1\nS : Finset Λ'\nf fs : Code\nIHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S\nIHfs : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Supports (codeSupp' fs k) S\nk : Cont'\nH : codeSupp (f.cons fs) k ⊆ S\nH' : trStmts₁ (trNormal (f.cons fs) k) ⊆ S ∧ codeSupp f (Cont'.c... | [
"case cons.refine_2.refine_1\nS : Finset Λ'\nf fs : Code\nIHf : ∀ {k : Cont'}, codeSupp f k ⊆ S → Supports (codeSupp' f k) S\nIHfs : ∀ {k : Cont'}, codeSupp fs k ⊆ S → Supports (codeSupp' fs k) S\nk : Cont'\nH : codeSupp (f.cons fs) k ⊆ S\nH' : trStmts₁ (trNormal (f.cons fs) k) ⊆ S ∧ codeSupp' f (Cont'.cons₁ fs k) ... | codeSupp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Condensed.Discrete.Characterization | {
"line": 137,
"column": 2
} | {
"line": 137,
"column": 98
} | {
"line": 138,
"column": 2
} | [
{
"pp": "R : Type (u + 1)\ninst✝ : Ring R\nM : CondensedMod R\ntfae_1_iff_2 : Condensed.IsDiscrete M ↔ IsIso ((Condensed.discreteUnderlyingAdj (ModuleCat R)).counit.app M)\ntfae_1_iff_3 : Condensed.IsDiscrete M ↔ (Condensed.discrete (ModuleCat R)).essImage M\n⊢ [Condensed.IsDiscrete M, IsIso ((Condensed.discret... | [
"R : Type (u + 1)\ninst✝ : Ring R\nM : CondensedMod R\ntfae_1_iff_2 : Condensed.IsDiscrete M ↔ IsIso ((Condensed.discreteUnderlyingAdj (ModuleCat R)).counit.app M)\ntfae_1_iff_3 : Condensed.IsDiscrete M ↔ (Condensed.discrete (ModuleCat R)).essImage M\ntfae_1_iff_4 : Condensed.IsDiscrete M ↔ (functor R).essImage M\n... | tfae_have 1 ↔ 4 := Sheaf.isConstant_iff_mem_essImage _ CompHaus.isTerminalPUnit (adjunction R) _ | Mathlib.Tactic.TFAE._aux_Mathlib_Tactic_TFAE___macroRules_Mathlib_Tactic_TFAE_tfaeHave_1 | Mathlib.Tactic.TFAE.tfaeHave |
Mathlib.Condensed.Light.Epi | {
"line": 96,
"column": 60
} | {
"line": 96,
"column": 63
} | {
"line": 97,
"column": 4
} | [
{
"pp": "R : Type u\ninst✝¹ : Ring R\nX Y : LightCondMod R\nf : X ⟶ Y\ninst✝ : Epi f\nS : LightProfinite\np : (LightCondensed.free R).obj S.toCondensed ⟶ Y\nthis :\n ∀ (S : LightProfinite) (y : ((LightCondensed.forget R).obj Y).obj.obj (Opposite.op S)),\n ∃ S' φ,\n ∃ (_ : Function.Surjective ⇑(Concrete... | [
"R : Type u\ninst✝¹ : Ring R\nX Y : LightCondMod R\nf : X ⟶ Y\ninst✝ : Epi f\nS : LightProfinite\np : (LightCondensed.free R).obj S.toCondensed ⟶ Y\nthis :\n ∀ (S : LightProfinite) (y : ((LightCondensed.forget R).obj Y).obj.obj (Opposite.op S)),\n ∃ S' φ,\n ∃ (_ : Function.Surjective ⇑(ConcreteCategory.hom... | hx, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Control.Bitraversable.Instances | {
"line": 144,
"column": 2
} | {
"line": 148,
"column": 36
} | {
"line": 150,
"column": 0
} | [
{
"pp": "t : Type u → Type u → Type u\ninst✝³ : Bitraversable t\nF : Type u → Type u\ninst✝² : Traversable F\ninst✝¹ : LawfulTraversable F\ninst✝ : LawfulBitraversable t\n⊢ LawfulBitraversable (bicompr F t)",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Pure.pure",
"Traversabl... | [] | constructor <;> intros <;>
simp [bitraverse, Bicompr.bitraverse, bitraverse_id_id, functor_norm]
· simp only [bitraverse_eq_bimap_id', traverse_eq_map_id', Function.comp_apply]; rfl
· dsimp only [bicompr]
simp [naturality, binaturality'] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Control.Bitraversable.Instances | {
"line": 144,
"column": 2
} | {
"line": 148,
"column": 36
} | {
"line": 150,
"column": 0
} | [
{
"pp": "t : Type u → Type u → Type u\ninst✝³ : Bitraversable t\nF : Type u → Type u\ninst✝² : Traversable F\ninst✝¹ : LawfulTraversable F\ninst✝ : LawfulBitraversable t\n⊢ LawfulBitraversable (bicompr F t)",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Pure.pure",
"Traversabl... | [] | constructor <;> intros <;>
simp [bitraverse, Bicompr.bitraverse, bitraverse_id_id, functor_norm]
· simp only [bitraverse_eq_bimap_id', traverse_eq_map_id', Function.comp_apply]; rfl
· dsimp only [bicompr]
simp [naturality, binaturality'] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Control.Fold | {
"line": 355,
"column": 19
} | {
"line": 355,
"column": 42
} | {
"line": 355,
"column": 42
} | [
{
"pp": "case cons\nα : Type u\nhead✝ : α\ntail✝ : List α\nih : FreeMonoid.toList (List.traverse (Const.mk' ∘ FreeMonoid.of) tail✝) = tail✝\n⊢ FreeMonoid.toList (List.traverse (Const.mk' ∘ FreeMonoid.of) (head✝ :: tail✝)) = head✝ :: tail✝",
"ppTerm": "?cons",
"assigned": true,
"usedConstants": [
... | [
"case cons\nα : Type u\nhead✝ : α\ntail✝ : List α\nih : FreeMonoid.toList (List.traverse (Const.mk' ∘ FreeMonoid.of) tail✝) = tail✝\n⊢ FreeMonoid.toList (List.traverse (Const.mk' ∘ FreeMonoid.of) (head✝ :: tail✝)) =\n head✝ :: FreeMonoid.toList (List.traverse (Const.mk' ∘ FreeMonoid.of) tail✝)"
] | (conv_rhs => rw [← ih]) | Lean.Elab.Tactic.evalParen | Lean.Parser.Tactic.paren |
Mathlib.Control.Fold | {
"line": 358,
"column": 2
} | {
"line": 365,
"column": 35
} | {
"line": 367,
"column": 0
} | [
{
"pp": "α : Type u\nt : Type u → Type u\ninst✝¹ : Traversable t\ninst✝ : LawfulTraversable t\nxs : t α\n⊢ length xs = (toList xs).length",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Lean.RArray.leaf",
"congrArg",
"AddMonoid.toAddZeroClass",
"ULi... | [] | unfold length
rw [foldl_toList]
generalize toList xs = ys
rw [← Nat.add_zero ys.length]
generalize 0 = n
induction ys generalizing n with
| nil => simp
| cons _ _ ih => simp +arith [ih] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Control.Fold | {
"line": 358,
"column": 2
} | {
"line": 365,
"column": 35
} | {
"line": 367,
"column": 0
} | [
{
"pp": "α : Type u\nt : Type u → Type u\ninst✝¹ : Traversable t\ninst✝ : LawfulTraversable t\nxs : t α\n⊢ length xs = (toList xs).length",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Lean.RArray.leaf",
"congrArg",
"AddMonoid.toAddZeroClass",
"ULi... | [] | unfold length
rw [foldl_toList]
generalize toList xs = ys
rw [← Nat.add_zero ys.length]
generalize 0 = n
induction ys generalizing n with
| nil => simp
| cons _ _ ih => simp +arith [ih] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Condensed.Light.Sequence | {
"line": 263,
"column": 2
} | {
"line": 263,
"column": 41
} | {
"line": 264,
"column": 2
} | [
{
"pp": "S T : LightProfinite\nπ : T ⟶ S ⊗ ℕ∪{∞}\ninst✝ : Epi π\n⊢ ∃ S' T' y' π' g',\n Epi π' ∧\n Epi y' ∧\n π' ≫ y' ▷ ℕ∪{∞} = g' ≫ π ∧\n IsSplitEpi (LightProfinite.fibreIncl ∞ (π' ≫ snd S' ℕ∪{∞}) ≫ π' ≫ fst S' ℕ∪{∞}) ∧ Epi (cover π')",
"ppTerm": "?m.89",
"assigned": true,
"u... | [
"S T : LightProfinite\nπ : T ⟶ S ⊗ ℕ∪{∞}\ninst✝ : Epi π\nthis : CompactSpace ↑(S' ⇑(ConcreteCategory.hom π))\n⊢ ∃ S' T' y' π' g',\n Epi π' ∧\n Epi y' ∧\n π' ≫ y' ▷ ℕ∪{∞} = g' ≫ π ∧\n IsSplitEpi (LightProfinite.fibreIncl ∞ (π' ≫ snd S' ℕ∪{∞}) ≫ π' ≫ fst S' ℕ∪{∞}) ∧ Epi (cover π')"
] | have := S'_compactSpace π (by fun_prop) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.Erased | {
"line": 142,
"column": 19
} | {
"line": 142,
"column": 68
} | {
"line": 143,
"column": 4
} | [
{
"pp": "⊢ ∀ {α β : Type u_1} (x : Erased α) (y : Erased β), x *> y = Function.const α id <$> x <*> y",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Erased.Monad",
"Erased.map_out",
"congrArg",
"Erased",
"Monad.toApplicative",
"Erased.out",
"id",
... | [] | by intros; ext; simp [Seq.seq, SeqRight.seqRight] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.DFinsupp.Interval | {
"line": 168,
"column": 87
} | {
"line": 169,
"column": 45
} | {
"line": 171,
"column": 0
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\ninst✝⁴ : DecidableEq ι\ninst✝³ : (i : ι) → DecidableEq (α i)\ninst✝² : (i : ι) → PartialOrder (α i)\ninst✝¹ : (i : ι) → Zero (α i)\ninst✝ : (i : ι) → LocallyFiniteOrder (α i)\nf g : Π₀ (i : ι), α i\n⊢ #(Ioc f g) = ∏ i ∈ f.support ∪ g.support, #(Icc (f i) (g i)) - 1",
... | [] | by
rw [card_Ioc_eq_card_Icc_sub_one, card_Icc] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.DFinsupp.Interval | {
"line": 192,
"column": 61
} | {
"line": 193,
"column": 42
} | {
"line": 195,
"column": 0
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\ninst✝⁶ : DecidableEq ι\ninst✝⁵ : (i : ι) → DecidableEq (α i)\ninst✝⁴ : (i : ι) → AddCommMonoid (α i)\ninst✝³ : (i : ι) → PartialOrder (α i)\ninst✝² : ∀ (i : ι), IsBotZeroClass (α i)\ninst✝¹ : (i : ι) → OrderBot (α i)\ninst✝ : (i : ι) → LocallyFiniteOrder (α i)\nf : Π₀ (i... | [] | by
simp [Iic_eq_Icc, card_Icc, bot_eq_zero] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Fin.Tuple.Curry | {
"line": 78,
"column": 78
} | {
"line": 81,
"column": 41
} | {
"line": 83,
"column": 0
} | [
{
"pp": "n : ℕ\np : Fin n → Type u\nτ : Type u\nf : FromTypes p τ\n⊢ curry f.uncurry = f",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Nat.recAux",
"Function.FromTypes.uncurry",
"Function.FromTypes",
"instOfNatNat",
"funext",
"instHAdd",
"HAdd.hA... | [] | by
induction n with
| zero => rfl
| succ n ih => exact funext (ih <| f ·) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.AList | {
"line": 292,
"column": 2
} | {
"line": 292,
"column": 33
} | {
"line": 294,
"column": 0
} | [
{
"pp": "case neg\nα : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\nl : AList β\nk k' : α\nv : β k\nh : ¬k' = k\n⊢ lookup k' (insert k v l) = none ↔ k' ≠ k ∧ lookup k' l = none",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstants": [
"False",
"eq_false",
"congrArg",
"AList... | [] | · simp_all [lookup_insert_ne h] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Data.Finsupp.NeLocus | {
"line": 83,
"column": 11
} | {
"line": 83,
"column": 85
} | {
"line": 85,
"column": 0
} | [
{
"pp": "α : Type u_1\nM : Type u_2\nN : Type u_3\ninst✝⁴ : DecidableEq α\ninst✝³ : DecidableEq N\ninst✝² : Zero N\ninst✝¹ : DecidableEq M\ninst✝ : Zero M\nf g : α →₀ N\nF : N → M\nF0 : F 0 = 0\nx : α\n⊢ x ∈ (mapRange F F0 f).neLocus (mapRange F F0 g) → x ∈ f.neLocus g",
"ppTerm": "?m.31",
"assigned": t... | [] | by simpa only [mem_neLocus, mapRange_apply, not_imp_not] using congr_arg F | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Finsupp.Sigma | {
"line": 67,
"column": 30
} | {
"line": 69,
"column": 7
} | {
"line": 71,
"column": 0
} | [
{
"pp": "κ : Type u_1\nι : κ → Type u_2\nM : Type u_3\ninst✝ : Zero M\nk k' : κ\nf : ι k →₀ M\nhk : k' ≠ k\ni : ι k'\n⊢ f.embSigma ⟨k', i⟩ = 0",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"Function.Embedding.sigmaMk",
"_private.Mathlib.Data.Finsupp.Sigma.0.Finsupp.embSigma_a... | [] | by
apply embDomain_notin_range
grind | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Int.CardIntervalMod | {
"line": 37,
"column": 70
} | {
"line": 37,
"column": 90
} | {
"line": 37,
"column": 90
} | [
{
"pp": "a b r v x : ℤ\n⊢ (a ≤ x ∧ x < b) ∧ r ∣ x - v ↔ (a - v ≤ x - v ∧ x < b) ∧ r ∣ x - v",
"ppTerm": "?m.65",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
"Dvd.dvd",
"congrArg",
"covariant_swap_add_of_covariant_add",
"PartialOrder.toPreorder",
"HSub.hS... | [] | sub_le_sub_iff_right | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Int.CardIntervalMod | {
"line": 44,
"column": 70
} | {
"line": 44,
"column": 90
} | {
"line": 44,
"column": 90
} | [
{
"pp": "a b r v x : ℤ\n⊢ (a < x ∧ x ≤ b) ∧ r ∣ x - v ↔ (a < x ∧ x - v ≤ b - v) ∧ r ∣ x - v",
"ppTerm": "?m.65",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
"Dvd.dvd",
"congrArg",
"covariant_swap_add_of_covariant_add",
"PartialOrder.toPreorder",
"HSub.hS... | [] | sub_le_sub_iff_right | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Data.Int.NatPrime | {
"line": 39,
"column": 20
} | {
"line": 41,
"column": 45
} | {
"line": 43,
"column": 0
} | [
{
"pp": "p : ℕ\nhp : Nat.Prime p\nk : ℤ\nh : ↑p ∣ k ^ 2\n⊢ p ∣ k.natAbs",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Dvd.dvd",
"HMul.hMul",
"Int.natAbs_mul",
"Monoid.toMulOneClass",
"congrArg",
"Nat.instMonoid",
"Nat.Prime.dvd_o... | [] | by
apply @Nat.Prime.dvd_of_dvd_pow _ _ 2 hp
rwa [sq, ← natAbs_mul, ← natCast_dvd, ← sq] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.LawfulXor | {
"line": 43,
"column": 17
} | {
"line": 43,
"column": 36
} | {
"line": 43,
"column": 37
} | [
{
"pp": "α : Type u_1\ninst✝² : XorOp α\ninst✝¹ : Zero α\ninst✝ : LawfulXor α\na b : α\n⊢ a ^^^ (b ^^^ b) = a",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"HXor.hXor",
"Zero.toOfNat0",
"LawfulXor.xor_self",
"OfNat.ofN... | [
"α : Type u_1\ninst✝² : XorOp α\ninst✝¹ : Zero α\ninst✝ : LawfulXor α\na b : α\n⊢ a ^^^ 0 = a"
] | LawfulXor.xor_self, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.LawfulXor | {
"line": 47,
"column": 19
} | {
"line": 47,
"column": 38
} | {
"line": 47,
"column": 39
} | [
{
"pp": "α : Type u_1\ninst✝² : XorOp α\ninst✝¹ : Zero α\ninst✝ : LawfulXor α\na b : α\n⊢ a ^^^ a ^^^ b = b",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"HXor.hXor",
"Zero.toOfNat0",
"LawfulXor.xor_self",
"OfNat.ofNat... | [
"α : Type u_1\ninst✝² : XorOp α\ninst✝¹ : Zero α\ninst✝ : LawfulXor α\na b : α\n⊢ 0 ^^^ b = b"
] | LawfulXor.xor_self, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Int.CardIntervalMod | {
"line": 122,
"column": 90
} | {
"line": 124,
"column": 69
} | {
"line": 126,
"column": 0
} | [
{
"pp": "a b r : ℕ\nhr : 0 < r\nv : ℕ\n⊢ ↑(#({x ∈ Ioc 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",
"Nat.Ioc_filter... | [] | by
simp_rw [← Ioc_filter_modEq_cast _ _ ▸ card_map _,
Int.Ioc_filter_modEq_card _ _ (cast_lt.mpr hr), Int.cast_natCast] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Int.CardIntervalMod | {
"line": 155,
"column": 64
} | {
"line": 155,
"column": 75
} | {
"line": 155,
"column": 76
} | [
{
"pp": "case neg\nb r : ℕ\nhr : 0 < r\nv : ℕ\nhr' : 0 < ↑r\nh : ¬v % r < b % r\n⊢ ↑(v % r) < ↑r + ↑(b % r) ∧ ↑(b % r) ≤ ↑(v % r)",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Preorder.toLT",
"NonUnitalCommRing.toNonUnitalNonAssocCommRing",
"CommRing.to... | [
"case neg\nb r : ℕ\nhr : 0 < r\nv : ℕ\nhr' : 0 < ↑r\nh : ¬v % r < b % r\n⊢ ↑(v % r) < ↑(r + b % r) ∧ ↑(b % r) ≤ ↑(v % r)"
] | ← cast_add, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.DropRight | {
"line": 84,
"column": 4
} | {
"line": 86,
"column": 28
} | {
"line": 88,
"column": 0
} | [
{
"pp": "case append_singleton\nα : Type u_1\nxs : List α\nx : α\nIH : ∀ (n : ℕ), drop (xs.length - n) xs = (take n xs.reverse).reverse\nn : ℕ\n⊢ drop ((xs ++ [x]).length - n) (xs ++ [x]) = (take n (xs ++ [x]).reverse).reverse",
"ppTerm": "?append_singleton",
"assigned": true,
"usedConstants": [
... | [] | cases n
· exact drop_length
· simp [drop_append, IH] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.DropRight | {
"line": 84,
"column": 4
} | {
"line": 86,
"column": 28
} | {
"line": 88,
"column": 0
} | [
{
"pp": "case append_singleton\nα : Type u_1\nxs : List α\nx : α\nIH : ∀ (n : ℕ), drop (xs.length - n) xs = (take n xs.reverse).reverse\nn : ℕ\n⊢ drop ((xs ++ [x]).length - n) (xs ++ [x]) = (take n (xs ++ [x]).reverse).reverse",
"ppTerm": "?append_singleton",
"assigned": true,
"usedConstants": [
... | [] | cases n
· exact drop_length
· simp [drop_append, IH] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.DropRight | {
"line": 143,
"column": 81
} | {
"line": 144,
"column": 39
} | {
"line": 146,
"column": 0
} | [
{
"pp": "α : Type u_1\np : α → Bool\nl : List α\n⊢ rdropWhile p l.reverse = (dropWhile p l).reverse",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"congrArg",
"id",
"List",
"List.reverse_reverse",
"True",
"eq_self",
"List.reverse",
"of_eq_tru... | [] | by
simp_rw [rdropWhile, reverse_reverse] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Intervals | {
"line": 168,
"column": 51
} | {
"line": 172,
"column": 50
} | {
"line": 174,
"column": 0
} | [
{
"pp": "n m l : ℕ\nhnl : n ≤ l\n⊢ filter (fun x ↦ decide (l ≤ x)) (Ico n m) = Ico l m",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"le_refl",
"List.Ico.eq_nil_of_le",
"congrArg",
"PartialOrder.toPreorder",
"List.Ico.filter_le_of_le_bot",
... | [] | by
rcases le_total l m with hlm | hml
· rw [← append_consecutive hnl hlm, filter_append, filter_le_of_top_le (le_refl l),
filter_le_of_le_bot (le_refl l), nil_append]
· rw [eq_nil_of_le hml, filter_le_of_top_le hml] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.ModifyLast | {
"line": 55,
"column": 6
} | {
"line": 58,
"column": 21
} | {
"line": 59,
"column": 6
} | [
{
"pp": "case cons.cons\nα : Type u_1\nf : α → α\nl₁ : List α\nhd hd' : α\ntl' : List α\nx✝ : hd :: hd' :: tl' ≠ []\n⊢ modifyLast f (l₁ ++ hd :: hd' :: tl') = l₁ ++ modifyLast f (hd :: hd' :: tl')",
"ppTerm": "?cons.cons",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"List.append_assoc... | [
"α : Type u_1\nf : α → α\nl₁ : List α\nhd hd' : α\ntl' : List α\nx✝ : hd :: hd' :: tl' ≠ []\n⊢ hd' :: tl' ≠ []",
"α : Type u_1\nf : α → α\nl₁ : List α\nhd hd' : α\ntl' : List α\nx✝ : hd :: hd' :: tl' ≠ []\n⊢ hd' :: tl' ≠ []"
] | rw [append_cons, ← nil_append (hd :: hd' :: tl'), append_cons [], nil_append,
modifyLast_append_of_right_ne_nil _ (l₁ ++ [hd]) (hd' :: tl') _,
modifyLast_append_of_right_ne_nil _ [hd] (hd' :: tl') _,
append_assoc] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.NNRat.BigOperators | {
"line": 66,
"column": 2
} | {
"line": 67,
"column": 78
} | {
"line": 69,
"column": 0
} | [
{
"pp": "α : Type u_1\ns : Finset α\nf : α → ℚ\nhf : ∀ a ∈ s, 0 ≤ f a\n⊢ (∏ a ∈ s, f a).toNNRat = ∏ a ∈ s, (f a).toNNRat",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"CommMonoidWithZero.toCommMonoid",
"Eq.mpr",
"congrArg",
"Finset",
"Rat",
"Rat.instZe... | [] | rw [← coe_inj, cast_prod, Rat.coe_toNNRat _ (Finset.prod_nonneg hf)]
exact Finset.prod_congr rfl fun x hxs ↦ by rw [Rat.coe_toNNRat _ (hf x hxs)] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.NNRat.BigOperators | {
"line": 66,
"column": 2
} | {
"line": 67,
"column": 78
} | {
"line": 69,
"column": 0
} | [
{
"pp": "α : Type u_1\ns : Finset α\nf : α → ℚ\nhf : ∀ a ∈ s, 0 ≤ f a\n⊢ (∏ a ∈ s, f a).toNNRat = ∏ a ∈ s, (f a).toNNRat",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"CommMonoidWithZero.toCommMonoid",
"Eq.mpr",
"congrArg",
"Finset",
"Rat",
"Rat.instZe... | [] | rw [← coe_inj, cast_prod, Rat.coe_toNNRat _ (Finset.prod_nonneg hf)]
exact Finset.prod_congr rfl fun x hxs ↦ by rw [Rat.coe_toNNRat _ (hf x hxs)] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Factorization.Divisors | {
"line": 61,
"column": 6
} | {
"line": 61,
"column": 51
} | {
"line": 62,
"column": 4
} | [
{
"pp": "n : ℕ\nhn : ¬n = 0\nk : ℕ\nx✝ : k ∈ {x | ∃ f < n.factorization, (f.prod fun x1 x2 ↦ x1 ^ x2) = x}\nf : ℕ →₀ ℕ\nhlt : f < n.factorization\nh : (f.prod fun x1 x2 ↦ x1 ^ x2) = k\n⊢ ∀ a ∈ f.support, a ^ f a ∣ a ^ n.factorization a",
"ppTerm": "?m.150",
"assigned": true,
"usedConstants": [
... | [] | exact fun p _ ↦ Nat.pow_dvd_pow p <| hlt.le p | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.Nat.Choose.Lucas | {
"line": 147,
"column": 4
} | {
"line": 148,
"column": 96
} | {
"line": 149,
"column": 2
} | [
{
"pp": "n p : ℕ\nhp : Fact (Nat.Prime p)\nhn : 0 < n\nhn₀ : n ≠ p ^ multiplicity p n\nm : ℕ\nh : ↑m ≡ 0 [ZMOD ↑p]\nhm : n = p ^ multiplicity p n * m\n⊢ p ^ (multiplicity p n + 1) ∣ n",
"ppTerm": "?m.150",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Semigroup.toMul",... | [] | nth_rw 2 [hm]
simpa [pow_add] using Nat.mul_dvd_mul_left _ (dvd_iff_mod_eq_zero.mpr (by exact_mod_cast h)) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.Choose.Lucas | {
"line": 147,
"column": 4
} | {
"line": 148,
"column": 96
} | {
"line": 149,
"column": 2
} | [
{
"pp": "n p : ℕ\nhp : Fact (Nat.Prime p)\nhn : 0 < n\nhn₀ : n ≠ p ^ multiplicity p n\nm : ℕ\nh : ↑m ≡ 0 [ZMOD ↑p]\nhm : n = p ^ multiplicity p n * m\n⊢ p ^ (multiplicity p n + 1) ∣ n",
"ppTerm": "?m.150",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Semigroup.toMul",... | [] | nth_rw 2 [hm]
simpa [pow_add] using Nat.mul_dvd_mul_left _ (dvd_iff_mod_eq_zero.mpr (by exact_mod_cast h)) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Nat.Choose.Lucas | {
"line": 161,
"column": 47
} | {
"line": 165,
"column": 84
} | {
"line": 167,
"column": 0
} | [
{
"pp": "n : ℕ\nh : IsPrimePow n\n⊢ n.minFac ∣ (Icc 1 (n - 1)).gcd n.choose",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Eq.mpr",
"Nat.Prime",
"Dvd.dvd",
"Nat.choose",
"congrArg",
"Nat.Prime.dvd_choose_pow",
"Finset",
"Na... | [] | by
obtain ⟨k, _, _, hn₁⟩ := (isPrimePow_nat_iff_bounded_log_minFac _).mp h
exact dvd_gcd_iff.mpr fun i hi => by
nth_rw 2 [hn₁]
exact Prime.dvd_choose_pow (minFac_prime_iff.mpr h.ne_one) (by grind) (by grind) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Num.ZNum | {
"line": 474,
"column": 12
} | {
"line": 474,
"column": 29
} | {
"line": 475,
"column": 2
} | [
{
"pp": "⊢ ↑(-0) = -↑0",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Int.cast_neg",
"Int.cast",
"Eq.mpr",
"NegZeroClass.toNeg",
"AddGroupWithOne.toAddGroup",
"congrArg",
"id",
"Int.instNegInt",
"... | [] | rw [Int.cast_neg] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Num.ZNum | {
"line": 474,
"column": 12
} | {
"line": 474,
"column": 29
} | {
"line": 475,
"column": 2
} | [
{
"pp": "⊢ ↑(-0) = -↑0",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Int.cast_neg",
"Int.cast",
"Eq.mpr",
"NegZeroClass.toNeg",
"AddGroupWithOne.toAddGroup",
"congrArg",
"id",
"Int.instNegInt",
"... | [] | rw [Int.cast_neg] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Num.ZNum | {
"line": 474,
"column": 12
} | {
"line": 474,
"column": 29
} | {
"line": 475,
"column": 2
} | [
{
"pp": "⊢ ↑(-0) = -↑0",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Int.cast_neg",
"Int.cast",
"Eq.mpr",
"NegZeroClass.toNeg",
"AddGroupWithOne.toAddGroup",
"congrArg",
"id",
"Int.instNegInt",
"... | [] | rw [Int.cast_neg] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Ordmap.Invariants | {
"line": 278,
"column": 2
} | {
"line": 278,
"column": 70
} | {
"line": 280,
"column": 0
} | [
{
"pp": "α : Type u_1\nl : Ordnode α\nx : α\nr : Ordnode α\n⊢ (l.rotateR x r).dual = r.dual.rotateL x l.dual",
"ppTerm": "?m.7",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Ordnode",
"congrArg",
"id",
"Ordnode.dual",
"Ordnode.dual_rotateL",
"Ordnode.rota... | [] | rw [← dual_dual (rotateL _ _ _), dual_rotateL, dual_dual, dual_dual] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Ordmap.Invariants | {
"line": 278,
"column": 2
} | {
"line": 278,
"column": 70
} | {
"line": 280,
"column": 0
} | [
{
"pp": "α : Type u_1\nl : Ordnode α\nx : α\nr : Ordnode α\n⊢ (l.rotateR x r).dual = r.dual.rotateL x l.dual",
"ppTerm": "?m.7",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Ordnode",
"congrArg",
"id",
"Ordnode.dual",
"Ordnode.dual_rotateL",
"Ordnode.rota... | [] | rw [← dual_dual (rotateL _ _ _), dual_rotateL, dual_dual, dual_dual] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Ordmap.Invariants | {
"line": 278,
"column": 2
} | {
"line": 278,
"column": 70
} | {
"line": 280,
"column": 0
} | [
{
"pp": "α : Type u_1\nl : Ordnode α\nx : α\nr : Ordnode α\n⊢ (l.rotateR x r).dual = r.dual.rotateL x l.dual",
"ppTerm": "?m.7",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Ordnode",
"congrArg",
"id",
"Ordnode.dual",
"Ordnode.dual_rotateL",
"Ordnode.rota... | [] | rw [← dual_dual (rotateL _ _ _), dual_rotateL, dual_dual, dual_dual] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Num.ZNum | {
"line": 619,
"column": 9
} | {
"line": 619,
"column": 20
} | {
"line": 619,
"column": 21
} | [
{
"pp": "case h₂\nn : ℕ\na : PosNum\nb : Num\nab : pos a ≤ b\nh : ↑(pos a) * (↑b % ↑(pos a) + ↑(pos a) * (↑b / ↑(pos a))) < 2 ^ n * 2\n⊢ ↑b % ↑(pos a) ≤ ↑(pos a) * (↑b / ↑(pos a))",
"ppTerm": "?h₂",
"assigned": true,
"usedConstants": [
"le_refl",
"Nat.instMulZeroClass",
"instHDiv",... | [
"case h₂\nn : ℕ\na : PosNum\nb : Num\nab : pos a ≤ b\nh : ↑(pos a) * (↑b % ↑(pos a) + ↑(pos a) * (↑b / ↑(pos a))) < 2 ^ n * 2\n⊢ ↑(pos a) ≤ ↑(pos a) * (↑b / ↑(pos a))",
"case hy\nn : ℕ\na : PosNum\nb : Num\nab : pos a ≤ b\nh : ↑(pos a) * (↑b % ↑(pos a) + ↑(pos a) * (↑b / ↑(pos a))) < 2 ^ n * 2\n⊢ 0 < ↑(pos a)"
] | Nat.mod_lt, | Mathlib.Tactic.GRewrite.evalGRewriteSeq | null |
Mathlib.Data.PFunctor.Multivariate.M | {
"line": 269,
"column": 29
} | {
"line": 269,
"column": 35
} | {
"line": 269,
"column": 36
} | [
{
"pp": "n : ℕ\nP : MvPFunctor.{u} (n + 1)\nα : TypeVec.{u} n\nR : P.M α → P.M α → Prop\nh₀ : Equivalence R\nx y : P.M α\nax : P.A\nfx fy : P.B ax ⟹ α ::: P.M α\nh₁ : (TypeVec.id ::: Quot.mk R) ⊚ fx = (TypeVec.id ::: Quot.mk R) ⊚ fy\nHdrop : dropFun fx = dropFun fy\n⊢ ⟨ax, fx⟩ = ⟨ax, fx⟩ ∧\n ⟨ax, fy⟩ = ⟨ax, ... | [
"n : ℕ\nP : MvPFunctor.{u} (n + 1)\nα : TypeVec.{u} n\nR : P.M α → P.M α → Prop\nh₀ : Equivalence R\nx y : P.M α\nax : P.A\nfx fy : P.B ax ⟹ α ::: P.M α\nh₁ : (TypeVec.id ::: Quot.mk R) ⊚ fx = (TypeVec.id ::: Quot.mk R) ⊚ fy\nHdrop : dropFun fx = dropFun fy\n⊢ ⟨ax, fx⟩ = ⟨ax, fx⟩ ∧\n ⟨ax, fy⟩ = ⟨ax, splitFun (dr... | Hdrop, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PNat.Factors | {
"line": 119,
"column": 79
} | {
"line": 122,
"column": 35
} | {
"line": 124,
"column": 0
} | [
{
"pp": "v : PrimeMultiset\n⊢ ↑v.prod = v.toNatMultiset.prod",
"ppTerm": "?m.4",
"assigned": true,
"usedConstants": [
"PNat.val",
"Nat.Primes.toPNat",
"Multiset.map",
"congrArg",
"Multiset.prod",
"PrimeMultiset.toPNatMultiset",
"Function.comp",
"Member... | [] | by
have h : (v.prod : ℕ) = ((v.map (↑) : Multiset ℕ+).map (↑)).prod :=
PNat.coeMonoidHom.map_multiset_prod v.toPNatMultiset
simpa [Multiset.map_map] using! h | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.PNat.Factors | {
"line": 355,
"column": 6
} | {
"line": 355,
"column": 23
} | {
"line": 356,
"column": 4
} | [
{
"pp": "case a.hm\nm n : ℕ+\n⊢ m.factorMultiset ⊓ n.factorMultiset ≤ m.factorMultiset",
"ppTerm": "?a.hm✝",
"assigned": true,
"usedConstants": [
"instDistribLatticePrimeMultiset",
"DistribLattice.toLattice",
"PNat.factorMultiset",
"inf_le_left",
"PrimeMultiset",
... | [] | exact inf_le_left | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.PNat.Factors | {
"line": 355,
"column": 6
} | {
"line": 355,
"column": 23
} | {
"line": 356,
"column": 4
} | [
{
"pp": "case a.hm\nm n : ℕ+\n⊢ m.factorMultiset ⊓ n.factorMultiset ≤ m.factorMultiset",
"ppTerm": "?a.hm✝",
"assigned": true,
"usedConstants": [
"instDistribLatticePrimeMultiset",
"DistribLattice.toLattice",
"PNat.factorMultiset",
"inf_le_left",
"PrimeMultiset",
... | [] | exact inf_le_left | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.PNat.Factors | {
"line": 355,
"column": 6
} | {
"line": 355,
"column": 23
} | {
"line": 356,
"column": 4
} | [
{
"pp": "case a.hm\nm n : ℕ+\n⊢ m.factorMultiset ⊓ n.factorMultiset ≤ m.factorMultiset",
"ppTerm": "?a.hm✝",
"assigned": true,
"usedConstants": [
"instDistribLatticePrimeMultiset",
"DistribLattice.toLattice",
"PNat.factorMultiset",
"inf_le_left",
"PrimeMultiset",
... | [] | exact inf_le_left | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Ordmap.Invariants | {
"line": 581,
"column": 36
} | {
"line": 581,
"column": 43
} | {
"line": 581,
"column": 43
} | [
{
"pp": "case nil.node.node.node\nα : Type u_1\nx : α\nhl : nil.Balanced\nsl : nil.Sized\nrs : ℕ\nrx : α\nrls : ℕ\nrll : Ordnode α\nrlx : α\nrlr : Ordnode α\nrrs : ℕ\nrrl : Ordnode α\nrrx : α\nrrr : Ordnode α\nhr : ((node rls rll rlx rlr).node' rx (node rrs rrl rrx rrr)).Balanced\nsr : (node rs (node rls rll rl... | [
"case nil.node.node.node\nα : Type u_1\nx : α\nhl : nil.Balanced\nsl : nil.Sized\nrs : ℕ\nrx : α\nrls : ℕ\nrll : Ordnode α\nrlx : α\nrlr : Ordnode α\nrrs : ℕ\nrrl : Ordnode α\nrrx : α\nrrr : Ordnode α\nhr : ((node rls rll rlx rlr).node' rx (node rrs rrl rrx rrr)).Balanced\nsr : (node rs (node rls rll rlx rlr) rx (n... | rotateL | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PFunctor.Univariate.M | {
"line": 616,
"column": 2
} | {
"line": 616,
"column": 76
} | {
"line": 617,
"column": 2
} | [
{
"pp": "P : PFunctor.{uA, uB}\nα : Type u_2\ng : α → ↑P α\nf : α → P.M\nhyp : ∀ (x : α), (f x).dest = P.map f (g x)\nx : α\na✝ : True\na : P.A\nf' : P.B a → α\ngxeq : g x = ⟨a, f'⟩\n⊢ ∃ a f_1 f',\n (f x).dest = ⟨a, f_1⟩ ∧\n (M.corec g x).dest = ⟨a, f'⟩ ∧ ∀ (i : P.B a), ∃ x', True ∧ f_1 i = f x' ∧ f' i ... | [
"P : PFunctor.{uA, uB}\nα : Type u_2\ng : α → ↑P α\nf : α → P.M\nhyp : ∀ (x : α), (f x).dest = P.map f (g x)\nx : α\na✝ : True\na : P.A\nf' : P.B a → α\ngxeq : g x = ⟨a, f'⟩\nh₀ : (f x).dest = ⟨a, f ∘ f'⟩\n⊢ ∃ a f_1 f',\n (f x).dest = ⟨a, f_1⟩ ∧\n (M.corec g x).dest = ⟨a, f'⟩ ∧ ∀ (i : P.B a), ∃ x', True ∧ f... | have h₀ : M.dest (f x) = ⟨a, f ∘ f'⟩ := by rw [hyp, gxeq, PFunctor.map_eq] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.PSigma.Order | {
"line": 77,
"column": 6
} | {
"line": 77,
"column": 83
} | {
"line": 78,
"column": 6
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\ninst✝¹ : Preorder ι\ninst✝ : (i : ι) → Preorder (α i)\n⊢ ∀ (a b : Σₗ' (i : ι), α i), a < b ↔ a ≤ b ∧ ¬b ≤ a",
"ppTerm": "?m.634",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
"Lex",
"le_of_lt",
"Preorder.toLE",
"PSigma.L... | [
"case refine_1\nι : Type u_1\nα : ι → Type u_2\ninst✝¹ : Preorder ι\ninst✝ : (i : ι) → Preorder (α i)\na b : Σₗ' (i : ι), α i\nhab : a < b\n⊢ ¬b ≤ a",
"case refine_2\nι : Type u_1\nα : ι → Type u_2\ninst✝¹ : Preorder ι\ninst✝ : (i : ι) → Preorder (α i)\na b : Σₗ' (i : ι), α i\n⊢ a ≤ b ∧ ¬b ≤ a → a < b"
] | refine fun a b => ⟨fun hab => ⟨hab.mono_right fun i a b => le_of_lt, ?_⟩, ?_⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.Ordmap.Ordset | {
"line": 365,
"column": 6
} | {
"line": 365,
"column": 22
} | {
"line": 365,
"column": 23
} | [
{
"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₂\nH₁ : r.size = 0 → l.size ≤ 1\nH₂ : 1 ≤ r.size → 1 ≤ l.size → l.size ≤ delta * r.size\nH₃ : 2 * r.size ≤ 9 * l.size + 5 ∨ r.size ≤ 3\n⊢ Valid' o₁ (l.balanceR... | [
"α : Type u_1\ninst✝ : Preorder α\nl : Ordnode α\nx : α\nr : Ordnode α\no₁ : WithBot α\no₂ : WithTop α\nhl : Valid' o₁ l ↑x\nhr : Valid' (↑x) r o₂\nH₁ : r.size = 0 → l.size ≤ 1\nH₂ : 1 ≤ r.size → 1 ≤ l.size → l.size ≤ delta * r.size\nH₃ : 2 * r.size ≤ 9 * l.size + 5 ∨ r.size ≤ 3\n⊢ Valid' o₂ (l.balanceR x r).dual o... | Valid'.dual_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Ordmap.Ordset | {
"line": 375,
"column": 6
} | {
"line": 375,
"column": 22
} | {
"line": 375,
"column": 23
} | [
{
"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₂\nH : (∃ l', Raised l.size l' ∧ BalancedSz l' r.size) ∨ ∃ r', Raised r' r.size ∧ BalancedSz l.size r'\n⊢ Valid' o₁ (l.balanceR x r) o₂",
"ppTerm": "?m.24"... | [
"α : Type u_1\ninst✝ : Preorder α\nl : Ordnode α\nx : α\nr : Ordnode α\no₁ : WithBot α\no₂ : WithTop α\nhl : Valid' o₁ l ↑x\nhr : Valid' (↑x) r o₂\nH : (∃ l', Raised l.size l' ∧ BalancedSz l' r.size) ∨ ∃ r', Raised r' r.size ∧ BalancedSz l.size r'\n⊢ Valid' o₂ (l.balanceR x r).dual o₁"
] | Valid'.dual_iff, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.PSigma.Order | {
"line": 166,
"column": 4
} | {
"line": 166,
"column": 32
} | {
"line": 167,
"column": 4
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\ninst✝³ : Preorder ι\ninst✝² : (i : ι) → Preorder (α i)\ninst✝¹ : NoMaxOrder ι\ninst✝ : ∀ (i : ι), Nonempty (α i)\ni : ι\na : α i\n⊢ ∃ b, ⟨i, a⟩ < b",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
"Lex",
"Exists",
... | [
"ι : Type u_1\nα : ι → Type u_2\ninst✝³ : Preorder ι\ninst✝² : (i : ι) → Preorder (α i)\ninst✝¹ : NoMaxOrder ι\ninst✝ : ∀ (i : ι), Nonempty (α i)\ni : ι\na : α i\nj : ι\nh : i < j\n⊢ ∃ b, ⟨i, a⟩ < b"
] | obtain ⟨j, h⟩ := exists_gt i | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.Pi.Interval | {
"line": 47,
"column": 63
} | {
"line": 48,
"column": 45
} | {
"line": 50,
"column": 0
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\ninst✝⁴ : Fintype ι\ninst✝³ : DecidableEq ι\ninst✝² : (i : ι) → DecidableEq (α i)\ninst✝¹ : (i : ι) → PartialOrder (α i)\ninst✝ : (i : ι) → LocallyFiniteOrder (α i)\na b : (i : ι) → α i\n⊢ #(Ioc a b) = ∏ i, #(Icc (a i) (b i)) - 1",
"ppTerm": "?m.28",
"assigned": t... | [] | by
rw [card_Ioc_eq_card_Icc_sub_one, card_Icc] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.QPF.Univariate.Basic | {
"line": 541,
"column": 4
} | {
"line": 545,
"column": 16
} | {
"line": 546,
"column": 2
} | [
{
"pp": "case mp\nF : Type u → Type u\nq : QPF F\nα : Type u\nx : F α\nu : α\n⊢ (∀ ⦃p : α → Prop⦄, Liftp p x → p u) → ∀ (a : (P F).A) (f : (P F).B a → α), abs ⟨a, f⟩ = x → u ∈ f '' univ",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"PFunctor.A",
"congrArg",
... | [] | intro h a f haf
have : Liftp (fun u => u ∈ f '' univ) x := by
rw [liftp_iff]
exact ⟨a, f, haf.symm, fun i => mem_image_of_mem _ (mem_univ _)⟩
exact h this | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.QPF.Univariate.Basic | {
"line": 541,
"column": 4
} | {
"line": 545,
"column": 16
} | {
"line": 546,
"column": 2
} | [
{
"pp": "case mp\nF : Type u → Type u\nq : QPF F\nα : Type u\nx : F α\nu : α\n⊢ (∀ ⦃p : α → Prop⦄, Liftp p x → p u) → ∀ (a : (P F).A) (f : (P F).B a → α), abs ⟨a, f⟩ = x → u ∈ f '' univ",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"PFunctor.A",
"congrArg",
... | [] | intro h a f haf
have : Liftp (fun u => u ∈ f '' univ) x := by
rw [liftp_iff]
exact ⟨a, f, haf.symm, fun i => mem_image_of_mem _ (mem_univ _)⟩
exact h this | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.WSeq.Relation | {
"line": 117,
"column": 4
} | {
"line": 119,
"column": 44
} | {
"line": 121,
"column": 0
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\nR : α → α → Prop\ninst✝ : Std.Refl R\ns : WSeq α\n⊢ LiftRel R s s",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Stream'.WSeq.LiftRelO.refl",
"congrArg",
"Stream'.WSeq.destruct",
"Std.Refl.refl",
"i... | [] | refine ⟨(· = ·), rfl, fun {s t} (h : s = t) => ?_⟩
rw [← h]
apply Computation.LiftRel.refl _ |>.refl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.WSeq.Relation | {
"line": 117,
"column": 4
} | {
"line": 119,
"column": 44
} | {
"line": 121,
"column": 0
} | [
{
"pp": "α : Type u\nβ : Type v\nγ : Type w\nR : α → α → Prop\ninst✝ : Std.Refl R\ns : WSeq α\n⊢ LiftRel R s s",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Stream'.WSeq.LiftRelO.refl",
"congrArg",
"Stream'.WSeq.destruct",
"Std.Refl.refl",
"i... | [] | refine ⟨(· = ·), rfl, fun {s t} (h : s = t) => ?_⟩
rw [← h]
apply Computation.LiftRel.refl _ |>.refl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.WSeq.Basic | {
"line": 333,
"column": 19
} | {
"line": 333,
"column": 36
} | {
"line": 333,
"column": 37
} | [
{
"pp": "α : Type u\ns : WSeq α\n⊢ (fun x ↦ Pure.pure (Option.rec nil Prod.snd x) >>= destruct) = tail.aux",
"ppTerm": "?m.35",
"assigned": true,
"usedConstants": [
"Pure.pure",
"Stream'.WSeq.tail.aux",
"Monad.toApplicative",
"Stream'.WSeq.destruct",
"Option.casesOn",
... | [
"case none\nα : Type u\ns : WSeq α\n⊢ Pure.pure (Option.rec nil Prod.snd none) >>= destruct = tail.aux none",
"case some\nα : Type u\ns✝ : WSeq α\na : α\ns : WSeq α\n⊢ Pure.pure (Option.rec nil Prod.snd (some (a, s))) >>= destruct = tail.aux (some (a, s))"
] | ext1 (_ | ⟨a, s⟩) | Lean.Elab.Tactic.Ext._aux_Init_Ext___macroRules_Lean_Elab_Tactic_Ext_tacticExt1____1 | Lean.Elab.Tactic.Ext.tacticExt1___ |
Mathlib.Data.WSeq.Basic | {
"line": 425,
"column": 62
} | {
"line": 446,
"column": 39
} | {
"line": 448,
"column": 0
} | [
{
"pp": "α : Type u\ns : WSeq α\na a' : α\ns' : WSeq α\n⊢ some (a', s') ∈ s.destruct → (a ∈ s ↔ a = a' ∨ a ∈ s')",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Computation.think",
"False",
"Computation.memRecOn",
"Sum.ctorIdx",
"Stream'.mem_c... | [] | by
generalize e : destruct s = c
intro h
revert s
apply Computation.memRecOn h <;> [skip; intro c IH] <;> intro s m <;>
induction s using WSeq.recOn <;>
have := congr_arg Computation.destruct m
case h1.nil | h1.think | h2.nil | h2.cons => simp at this
case h2.think => simp at this; simp [IH this]
... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Sigma.Order | {
"line": 150,
"column": 6
} | {
"line": 150,
"column": 83
} | {
"line": 151,
"column": 6
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\ninst✝¹ : Preorder ι\ninst✝ : (i : ι) → Preorder (α i)\n⊢ ∀ (a b : Σₗ (i : ι), α i), a < b ↔ a ≤ b ∧ ¬b ≤ a",
"ppTerm": "?m.68",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
"Lex",
"Sigma.Lex.LE",
"le_of_lt",
"Preorder.to... | [
"case refine_1\nι : Type u_1\nα : ι → Type u_2\ninst✝¹ : Preorder ι\ninst✝ : (i : ι) → Preorder (α i)\na b : Σₗ (i : ι), α i\nhab : a < b\n⊢ ¬b ≤ a",
"case refine_2\nι : Type u_1\nα : ι → Type u_2\ninst✝¹ : Preorder ι\ninst✝ : (i : ι) → Preorder (α i)\na b : Σₗ (i : ι), α i\n⊢ a ≤ b ∧ ¬b ≤ a → a < b"
] | refine fun a b => ⟨fun hab => ⟨hab.mono_right fun i a b => le_of_lt, ?_⟩, ?_⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Data.WSeq.Basic | {
"line": 465,
"column": 2
} | {
"line": 470,
"column": 7
} | {
"line": 472,
"column": 0
} | [
{
"pp": "case succ.think\nα : Type u\na : α\nn✝ : ℕ\na✝ : ∀ {s : WSeq α}, a ∈ s.tail → some (some a) = (↑s.tail).get n✝ → a ∈ s\ns✝ : WSeq α\nm : a ∈ s✝.think.tail\ne : some (some a) = (↑s✝.think.tail).get (n✝ + 1)\n⊢ a ∈ s✝.think",
"ppTerm": "?succ.think",
"assigned": true,
"usedConstants": [
... | [] | case succ.think n IH s =>
simp only [tail_think, mem_think] at m e ⊢
apply IH m
rw [e]
cases tail s
rfl | Lean.Elab.Tactic.evalCase | Lean.Parser.Tactic.case |
Mathlib.Data.Sigma.Order | {
"line": 234,
"column": 4
} | {
"line": 234,
"column": 32
} | {
"line": 235,
"column": 4
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\ninst✝³ : Preorder ι\ninst✝² : (i : ι) → Preorder (α i)\ninst✝¹ : NoMaxOrder ι\ninst✝ : ∀ (i : ι), Nonempty (α i)\ni : ι\na : α i\n⊢ ∃ b, ⟨i, a⟩ < b",
"ppTerm": "?m.17",
"assigned": true,
"usedConstants": [
"Preorder.toLT",
"Lex",
"Exists",
... | [
"ι : Type u_1\nα : ι → Type u_2\ninst✝³ : Preorder ι\ninst✝² : (i : ι) → Preorder (α i)\ninst✝¹ : NoMaxOrder ι\ninst✝ : ∀ (i : ι), Nonempty (α i)\ni : ι\na : α i\nj : ι\nh : i < j\n⊢ ∃ b, ⟨i, a⟩ < b"
] | obtain ⟨j, h⟩ := exists_gt i | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Data.Sigma.Interval | {
"line": 103,
"column": 41
} | {
"line": 106,
"column": 34
} | {
"line": 107,
"column": 2
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\ninst✝¹ : (i : ι) → Preorder (α i)\ninst✝ : (i : ι) → LocallyFiniteOrderBot (α i)\nx✝¹ x✝ : (i : ι) × α i\ni : ι\na : α i\nj : ι\nb : α j\n⊢ (⟨j, b⟩ ∈\n match ⟨i, a⟩ with\n | ⟨i, a⟩ => Finset.map (Embedding.sigmaMk i) (Iic a)) ↔\n ⟨j, b⟩ ≤ ⟨i, a⟩",
"ppTer... | [] | by
obtain rfl | hij := eq_or_ne i j
· simp
· simp [hij, le_def, hij.symm] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.WSeq.Relation | {
"line": 449,
"column": 16
} | {
"line": 449,
"column": 33
} | {
"line": 449,
"column": 34
} | [
{
"pp": "case right.ST\nα : Type u\nβ : Type v\nR : α → β → Prop\nS✝ : WSeq (WSeq α)\nT✝ : WSeq (WSeq β)\nh✝ : LiftRel (LiftRel R) S✝ T✝\ns1 : WSeq α\ns2 : WSeq β\nx✝¹ :\n (fun s1 s2 ↦ ∃ s t S T, s1 = s.append S.join ∧ s2 = t.append T.join ∧ LiftRel R s t ∧ LiftRel (LiftRel R) S T) s1 s2\ns : WSeq α\nt : WSeq ... | [
"case right.ST\nα : Type u\nβ : Type v\nR : α → β → Prop\nS✝ : WSeq (WSeq α)\nT✝ : WSeq (WSeq β)\nh✝ : LiftRel (LiftRel R) S✝ T✝\ns1 : WSeq α\ns2 : WSeq β\nx✝¹ :\n (fun s1 s2 ↦ ∃ s t S T, s1 = s.append S.join ∧ s2 = t.append T.join ∧ LiftRel R s t ∧ LiftRel (LiftRel R) S T) s1 s2\ns : WSeq α\nt : WSeq β\nS : WSeq ... | ← LiftRel.swap R, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.WSeq.Relation | {
"line": 451,
"column": 16
} | {
"line": 451,
"column": 33
} | {
"line": 451,
"column": 34
} | [
{
"pp": "case right.HU\nα : Type u\nβ : Type v\nR : α → β → Prop\nS✝ : WSeq (WSeq α)\nT✝ : WSeq (WSeq β)\nh✝ : LiftRel (LiftRel R) S✝ T✝\ns1 : WSeq α\ns2 : WSeq β\nx✝¹ :\n (fun s1 s2 ↦ ∃ s t S T, s1 = s.append S.join ∧ s2 = t.append T.join ∧ LiftRel R s t ∧ LiftRel (LiftRel R) S T) s1 s2\ns : WSeq α\nt : WSeq ... | [
"case right.HU\nα : Type u\nβ : Type v\nR : α → β → Prop\nS✝ : WSeq (WSeq α)\nT✝ : WSeq (WSeq β)\nh✝ : LiftRel (LiftRel R) S✝ T✝\ns1 : WSeq α\ns2 : WSeq β\nx✝¹ :\n (fun s1 s2 ↦ ∃ s t S T, s1 = s.append S.join ∧ s2 = t.append T.join ∧ LiftRel R s t ∧ LiftRel (LiftRel R) S T) s1 s2\ns : WSeq α\nt : WSeq β\nS : WSeq ... | ← LiftRel.swap R, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Vector3 | {
"line": 159,
"column": 51
} | {
"line": 159,
"column": 73
} | {
"line": 161,
"column": 0
} | [
{
"pp": "α : Type u_1\nm : ℕ\nv : Vector3 α (m + 1)\nn : ℕ\nw : Vector3 α n\ni : Fin2 n\n_a : α\nt : Vector3 α m\n⊢ ((_a :: t) +-+ w) (i.add (m + 1)) = w i",
"ppTerm": "?m.39",
"assigned": true,
"usedConstants": [
"congrArg",
"instOfNatNat",
"Vector3.cons",
"instHAdd",
... | [] | simp [append_add, add] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.Vector3 | {
"line": 159,
"column": 51
} | {
"line": 159,
"column": 73
} | {
"line": 161,
"column": 0
} | [
{
"pp": "α : Type u_1\nm : ℕ\nv : Vector3 α (m + 1)\nn : ℕ\nw : Vector3 α n\ni : Fin2 n\n_a : α\nt : Vector3 α m\n⊢ ((_a :: t) +-+ w) (i.add (m + 1)) = w i",
"ppTerm": "?m.39",
"assigned": true,
"usedConstants": [
"congrArg",
"instOfNatNat",
"Vector3.cons",
"instHAdd",
... | [] | simp [append_add, add] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Vector3 | {
"line": 159,
"column": 51
} | {
"line": 159,
"column": 73
} | {
"line": 161,
"column": 0
} | [
{
"pp": "α : Type u_1\nm : ℕ\nv : Vector3 α (m + 1)\nn : ℕ\nw : Vector3 α n\ni : Fin2 n\n_a : α\nt : Vector3 α m\n⊢ ((_a :: t) +-+ w) (i.add (m + 1)) = w i",
"ppTerm": "?m.39",
"assigned": true,
"usedConstants": [
"congrArg",
"instOfNatNat",
"Vector3.cons",
"instHAdd",
... | [] | simp [append_add, add] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.WSeq.Productive | {
"line": 70,
"column": 57
} | {
"line": 73,
"column": 32
} | {
"line": 75,
"column": 0
} | [
{
"pp": "α : Type u\ns : Seq α\n⊢ (↑s).toSeq = s",
"ppTerm": "?m.5",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Membership.mem",
"Stream'.WSeq.get?",
"id",
"Stream'.WSeq.ofSeq",
"Stream'.WSeq.toSeq",
"Computation",
"Stream'.WSeq.... | [] | by
apply Subtype.ext; funext n
dsimp [toSeq]; apply get_eq_of_mem
rw [get?_ofSeq]; apply ret_mem | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.SemiconjSup | {
"line": 74,
"column": 6
} | {
"line": 74,
"column": 23
} | {
"line": 74,
"column": 24
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\ninst✝² : Preorder α\ninst✝¹ : Preorder β\ninst✝ : Preorder γ\nf : α → β\ng : β → α\nh : IsOrderRightAdjoint f g\ne : γ ≃o α\ny : β\n⊢ IsLUB (⇑e ⁻¹' {x | f x ≤ y}) (e.symm (g y))",
"ppTerm": "?m.40",
"assigned": true,
"usedConstants": [
"Eq.mpr... | [
"α : Type u_1\nβ : Type u_2\nγ : Type u_3\ninst✝² : Preorder α\ninst✝¹ : Preorder β\ninst✝ : Preorder γ\nf : α → β\ng : β → α\nh : IsOrderRightAdjoint f g\ne : γ ≃o α\ny : β\n⊢ IsLUB {x | f x ≤ y} (e (e.symm (g y)))"
] | e.isLUB_preimage, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | {
"line": 877,
"column": 83
} | {
"line": 879,
"column": 48
} | {
"line": 881,
"column": 0
} | [
{
"pp": "f₁ f₂ : CircleDeg1Lift\nh₁ : IsUnit f₁\nh₂ : IsUnit f₂\nh : τ f₁ = τ f₂\n⊢ ∃ F, Semiconj ⇑F ⇑f₁ ⇑f₂",
"ppTerm": "?m.12",
"assigned": true,
"usedConstants": [
"Units.val",
"Real",
"IsUnit",
"CircleDeg1Lift.instFunLikeReal",
"Exists",
"Units",
"Circle... | [] | by
rcases h₁, h₂ with ⟨⟨f₁, rfl⟩, ⟨f₂, rfl⟩⟩
exact units_semiconj_of_translationNumber_eq h | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.MeasureTheory.Group.AddCircle | {
"line": 65,
"column": 4
} | {
"line": 78,
"column": 89
} | {
"line": 79,
"column": 2
} | [
{
"pp": "case refine_2\nT : ℝ\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))\nhI : I =ᵐ[volume] B\nhn : 1 ≤ ↑n\n⊢ ∀ (g : ↥G), g ≠ 0 → AEDisjoint... | [] | rintro ⟨g, hg⟩ hg'
replace hg' : g ≠ 0 := by simpa only [Ne, AddSubgroup.mk_eq_zero] using hg'
change AEDisjoint volume (g +ᵥ I) I
refine AEDisjoint.congr (Disjoint.aedisjoint ?_)
((quasiMeasurePreserving_add_left volume (-g)).vadd_ae_eq_of_ae_eq g hI) hI
have hBg : g +ᵥ B = ball (g + x) (T / (2 *... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.MeasureTheory.Group.AddCircle | {
"line": 65,
"column": 4
} | {
"line": 78,
"column": 89
} | {
"line": 79,
"column": 2
} | [
{
"pp": "case refine_2\nT : ℝ\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))\nhI : I =ᵐ[volume] B\nhn : 1 ≤ ↑n\n⊢ ∀ (g : ↥G), g ≠ 0 → AEDisjoint... | [] | rintro ⟨g, hg⟩ hg'
replace hg' : g ≠ 0 := by simpa only [Ne, AddSubgroup.mk_eq_zero] using hg'
change AEDisjoint volume (g +ᵥ I) I
refine AEDisjoint.congr (Disjoint.aedisjoint ?_)
((quasiMeasurePreserving_add_left volume (-g)).vadd_ae_eq_of_ae_eq g hI) hI
have hBg : g +ᵥ B = ball (g + x) (T / (2 *... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Dynamics.Ergodic.RadonNikodym | {
"line": 56,
"column": 4
} | {
"line": 56,
"column": 42
} | {
"line": 58,
"column": 0
} | [
{
"pp": "case e'_7\nX : Type u_1\nm : MeasurableSpace X\nμ ν : Measure X\ninst✝¹ : IsFiniteMeasure μ\ninst✝ : SigmaFinite ν\nf : X → X\nhfμ : MeasurePreserving f μ μ\nhfν : MeasurePreserving f ν ν\ns : Set X\nhsm : MeasurableSet s\nhνs : ν s = 0\nhμs : (μ.singularPart ν) sᶜ = 0\n⊢ μ.singularPart ν = μ.restrict ... | [] | exact singularPart_eq_restrict hμs hνs | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Dynamics.Ergodic.RadonNikodym | {
"line": 56,
"column": 4
} | {
"line": 56,
"column": 42
} | {
"line": 58,
"column": 0
} | [
{
"pp": "case e'_7\nX : Type u_1\nm : MeasurableSpace X\nμ ν : Measure X\ninst✝¹ : IsFiniteMeasure μ\ninst✝ : SigmaFinite ν\nf : X → X\nhfμ : MeasurePreserving f μ μ\nhfν : MeasurePreserving f ν ν\ns : Set X\nhsm : MeasurableSet s\nhνs : ν s = 0\nhμs : (μ.singularPart ν) sᶜ = 0\n⊢ μ.singularPart ν = μ.restrict ... | [] | exact singularPart_eq_restrict hμs hνs | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Dynamics.Ergodic.RadonNikodym | {
"line": 56,
"column": 4
} | {
"line": 56,
"column": 42
} | {
"line": 58,
"column": 0
} | [
{
"pp": "case e'_7\nX : Type u_1\nm : MeasurableSpace X\nμ ν : Measure X\ninst✝¹ : IsFiniteMeasure μ\ninst✝ : SigmaFinite ν\nf : X → X\nhfμ : MeasurePreserving f μ μ\nhfν : MeasurePreserving f ν ν\ns : Set X\nhsm : MeasurableSet s\nhνs : ν s = 0\nhμs : (μ.singularPart ν) sᶜ = 0\n⊢ μ.singularPart ν = μ.restrict ... | [] | exact singularPart_eq_restrict hμs hνs | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 143,
"column": 6
} | {
"line": 143,
"column": 12
} | {
"line": 143,
"column": 13
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\nf : α → ℝ≥0∞\nμ ν : Measure α\ninst✝¹ : SigmaFinite μ\ninst✝ : SigmaFinite ν\nhfν : AEMeasurable f ν\nhf_ne_top : ∀ᵐ (x : α) ∂μ, f x ≠ ∞\nμ' : Measure α := ν.withDensity (μ.rnDeriv ν)\nhμ'ν : μ' ≪ ν\nh : (μ'.withDensity f).rnDeriv ν =ᵐ[ν] fun x ↦ f x * μ'.rnDeriv ν ... | [
"α : Type u_1\nm : MeasurableSpace α\nf : α → ℝ≥0∞\nμ ν : Measure α\ninst✝¹ : SigmaFinite μ\ninst✝ : SigmaFinite ν\nhfν : AEMeasurable f ν\nhf_ne_top : ∀ᵐ (x : α) ∂μ, f x ≠ ∞\nμ' : Measure α := ν.withDensity (μ.rnDeriv ν)\nhμ'ν : μ' ≪ ν\nh : (μ'.withDensity f).rnDeriv ν =ᵐ[ν] fun x ↦ f x * μ'.rnDeriv ν x\nh1 : μ'.r... | ← hx2, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 143,
"column": 13
} | {
"line": 143,
"column": 16
} | {
"line": 143,
"column": 17
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\nf : α → ℝ≥0∞\nμ ν : Measure α\ninst✝¹ : SigmaFinite μ\ninst✝ : SigmaFinite ν\nhfν : AEMeasurable f ν\nhf_ne_top : ∀ᵐ (x : α) ∂μ, f x ≠ ∞\nμ' : Measure α := ν.withDensity (μ.rnDeriv ν)\nhμ'ν : μ' ≪ ν\nh : (μ'.withDensity f).rnDeriv ν =ᵐ[ν] fun x ↦ f x * μ'.rnDeriv ν ... | [
"α : Type u_1\nm : MeasurableSpace α\nf : α → ℝ≥0∞\nμ ν : Measure α\ninst✝¹ : SigmaFinite μ\ninst✝ : SigmaFinite ν\nhfν : AEMeasurable f ν\nhf_ne_top : ∀ᵐ (x : α) ∂μ, f x ≠ ∞\nμ' : Measure α := ν.withDensity (μ.rnDeriv ν)\nhμ'ν : μ' ≪ ν\nh : (μ'.withDensity f).rnDeriv ν =ᵐ[ν] fun x ↦ f x * μ'.rnDeriv ν x\nh1 : μ'.r... | hx, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Dynamics.Ergodic.Extreme | {
"line": 42,
"column": 4
} | {
"line": 42,
"column": 55
} | {
"line": 43,
"column": 4
} | [
{
"pp": "case inr\nX : 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 μ μ\nhc₀ : c ≠ 0\nthis : IsFiniteMeasure μ\n⊢ ∀ ⦃s : Set X⦄, MeasurableSet s → f ⁻¹' s = s → EventuallyConst s (... | [
"case inr\nX : Type u_1\nm : MeasurableSpace X\nμ : Measure X\nf : X → X\nc : ℝ≥0∞\nhc : c ≠ ∞\nhf : MeasurePreserving f μ μ\nhc₀ : c ≠ 0\nthis : IsFiniteMeasure μ\nS : Set (Measure X) := {ν | MeasurePreserving f ν ν ∧ ν univ = c}\nh : μ ∈ extremePoints ℝ≥0∞ S\n⊢ ∀ ⦃s : Set X⦄, MeasurableSet s → f ⁻¹' s = s → Event... | set S := {ν | MeasurePreserving f ν ν ∧ ν univ = c} | Mathlib.Tactic._aux_Mathlib_Tactic_Set___elabRules_Mathlib_Tactic_setTactic_1 | Mathlib.Tactic.setTactic |
Mathlib.Dynamics.OmegaLimit | {
"line": 71,
"column": 2
} | {
"line": 71,
"column": 71
} | {
"line": 72,
"column": 2
} | [
{
"pp": "τ : Type u_1\nα : Type u_2\nβ : Type u_3\ninst✝ : TopologicalSpace β\nϕ : τ → α → β\ns : Set α\nm : τ → τ\nf₁ f₂ : Filter τ\nhf : Tendsto m f₁ f₂\n⊢ ω f₁ (fun t x ↦ ϕ (m t) x) s ⊆ ω f₂ ϕ s",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"Filter.instMembership",
"Set.iI... | [
"τ : Type u_1\nα : Type u_2\nβ : Type u_3\ninst✝ : TopologicalSpace β\nϕ : τ → α → β\ns : Set α\nm : τ → τ\nf₁ f₂ : Filter τ\nhf : Tendsto m f₁ f₂\nu : Set τ\nhu : u ∈ f₂\n⊢ closure[inst✝] (image2 (fun t x ↦ ϕ (m t) x) (m ⁻¹' u) s) ⊆ closure[inst✝] (image2 ϕ u s)"
] | refine iInter₂_mono' fun u hu ↦ ⟨m ⁻¹' u, tendsto_def.mp hf _ hu, ?_⟩ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | {
"line": 195,
"column": 8
} | {
"line": 195,
"column": 11
} | {
"line": 195,
"column": 12
} | [
{
"pp": "α : Type u_1\nm : MeasurableSpace α\nμ ν ν' : Measure α\ninst✝¹ : μ.HaveLebesgueDecomposition ν'\ninst✝ : SigmaFinite ν'\nh✝ : μ ⟂ₘ ν\nhνν' : ν ≪ ν'\nt : Set α := h✝.nullSet\nht : MeasurableSet t\nh : (μ.restrict t).rnDeriv ν' =ᵐ[ν] t.indicator (μ.rnDeriv ν')\nx : α\nhx : (μ.restrict t).rnDeriv ν' x = ... | [
"α : Type u_1\nm : MeasurableSpace α\nμ ν ν' : Measure α\ninst✝¹ : μ.HaveLebesgueDecomposition ν'\ninst✝ : SigmaFinite ν'\nh✝ : μ ⟂ₘ ν\nhνν' : ν ≪ ν'\nt : Set α := h✝.nullSet\nht : MeasurableSet t\nh : (μ.restrict t).rnDeriv ν' =ᵐ[ν] t.indicator (μ.rnDeriv ν')\nx : α\nhx : (μ.restrict t).rnDeriv ν' x = t.indicator ... | hx, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Dynamics.OmegaLimit | {
"line": 121,
"column": 4
} | {
"line": 123,
"column": 47
} | {
"line": 124,
"column": 2
} | [
{
"pp": "case mp\nτ : Type u_1\nα : Type u_2\nβ : Type u_3\ninst✝ : TopologicalSpace β\nf : Filter τ\nϕ : τ → α → β\ns : Set α\ny : β\n⊢ (∀ i ∈ f, ∀ t ∈ 𝓝 y, (t ∩ image2 ϕ i s).Nonempty) →\n ∀ n ∈ 𝓝 y, ∀ {U : Set τ}, U ∈ f → ∃ x ∈ U, (s ∩ ϕ x ⁻¹' n).Nonempty",
"ppTerm": "?mp",
"assigned": true,
... | [] | intro h _ hn _ hu
rcases h _ hu _ hn with ⟨_, _, _, ht, _, hx, rfl⟩
exact ⟨_, ht, _, hx, by rwa [mem_preimage]⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.