module string | startPos dict | endPos dict | nextStartPos dict | goals list | goalsAfter list | ppTac string | elaborator string | kind string |
|---|---|---|---|---|---|---|---|---|
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 708,
"column": 17
} | {
"line": 708,
"column": 23
} | {
"line": 708,
"column": 23
} | [
{
"pp": "q : Λ'\ns : Option Γ'\nL : List ℕ\nc d : List Γ'\no : Option Γ' := List.casesOn L none fun x x_1 ↦ some Γ'.cons\n⊢ main ≠ rev",
"ppTerm": "?m.47",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Turing.PartrecToTM2.K'.rev",
"of_decide_eq_true",
"Turing.Part... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 727,
"column": 21
} | {
"line": 727,
"column": 27
} | {
"line": 727,
"column": 27
} | [
{
"pp": "q : Λ'\ns : Option Γ'\nL₁ : List ℕ\nL₃ : List Γ'\n⊢ stack ≠ rev",
"ppTerm": "?m.60",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Turing.PartrecToTM2.K'.rev",
"of_decide_eq_true",
"Turing.PartrecToTM2.instDecidableEqK'",
"Turing.PartrecToTM2.K'.sta... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 727,
"column": 21
} | {
"line": 727,
"column": 27
} | {
"line": 727,
"column": 27
} | [
{
"pp": "q : Λ'\ns : Option Γ'\nL₁ : List ℕ\nL₃ : List Γ'\n⊢ stack ≠ rev",
"ppTerm": "?m.60",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Turing.PartrecToTM2.K'.rev",
"of_decide_eq_true",
"Turing.PartrecToTM2.instDecidableEqK'",
"Turing.PartrecToTM2.K'.sta... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 727,
"column": 21
} | {
"line": 727,
"column": 27
} | {
"line": 727,
"column": 27
} | [
{
"pp": "q : Λ'\ns : Option Γ'\nL₁ : List ℕ\nL₃ : List Γ'\n⊢ stack ≠ rev",
"ppTerm": "?m.60",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Turing.PartrecToTM2.K'.rev",
"of_decide_eq_true",
"Turing.PartrecToTM2.instDecidableEqK'",
"Turing.PartrecToTM2.K'.sta... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 738,
"column": 21
} | {
"line": 738,
"column": 27
} | {
"line": 738,
"column": 27
} | [
{
"pp": "q : Λ'\ns : Option Γ'\nL₁ : List ℕ\nL₃ : List Γ'\na : ℕ\nL₂ : List ℕ\n⊢ stack ≠ rev",
"ppTerm": "?m.320",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Turing.PartrecToTM2.K'.rev",
"of_decide_eq_true",
"Turing.PartrecToTM2.instDecidableEqK'",
"Turin... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 738,
"column": 21
} | {
"line": 738,
"column": 27
} | {
"line": 738,
"column": 27
} | [
{
"pp": "q : Λ'\ns : Option Γ'\nL₁ : List ℕ\nL₃ : List Γ'\na : ℕ\nL₂ : List ℕ\n⊢ stack ≠ rev",
"ppTerm": "?m.320",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Turing.PartrecToTM2.K'.rev",
"of_decide_eq_true",
"Turing.PartrecToTM2.instDecidableEqK'",
"Turin... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 738,
"column": 21
} | {
"line": 738,
"column": 27
} | {
"line": 738,
"column": 27
} | [
{
"pp": "q : Λ'\ns : Option Γ'\nL₁ : List ℕ\nL₃ : List Γ'\na : ℕ\nL₂ : List ℕ\n⊢ stack ≠ rev",
"ppTerm": "?m.320",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"Turing.PartrecToTM2.K'.rev",
"of_decide_eq_true",
"Turing.PartrecToTM2.instDecidableEqK'",
"Turin... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.DiscreteQuotient | {
"line": 197,
"column": 2
} | {
"line": 198,
"column": 5
} | {
"line": 200,
"column": 0
} | [
{
"pp": "X : Type u_2\ninst✝ : TopologicalSpace X\nA : DiscreteQuotient X\n⊢ ofLE ⋯ = id",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"le_refl",
"DiscreteQuotient.ofLE",
"DiscreteQuotient.toSetoid",
"PartialOrder.toPreorder",
"Quot.ind",
"id",
"... | [] | ext ⟨⟩
rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.DiscreteQuotient | {
"line": 197,
"column": 2
} | {
"line": 198,
"column": 5
} | {
"line": 200,
"column": 0
} | [
{
"pp": "X : Type u_2\ninst✝ : TopologicalSpace X\nA : DiscreteQuotient X\n⊢ ofLE ⋯ = id",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"le_refl",
"DiscreteQuotient.ofLE",
"DiscreteQuotient.toSetoid",
"PartialOrder.toPreorder",
"Quot.ind",
"id",
"... | [] | ext ⟨⟩
rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.DiscreteQuotient | {
"line": 294,
"column": 2
} | {
"line": 295,
"column": 5
} | {
"line": 297,
"column": 0
} | [
{
"pp": "X : Type u_2\nY : Type u_3\nZ : Type u_4\ninst✝² : TopologicalSpace X\ninst✝¹ : TopologicalSpace Y\ninst✝ : TopologicalSpace Z\nf : C(X, Y)\nA : DiscreteQuotient X\nB : DiscreteQuotient Y\ng : C(Y, Z)\nC : DiscreteQuotient Z\nh1 : LEComap g B C\nh2 : LEComap f A B\n⊢ map (g.comp f) ⋯ = map g h1 ∘ map f... | [] | ext ⟨⟩
rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Topology.DiscreteQuotient | {
"line": 294,
"column": 2
} | {
"line": 295,
"column": 5
} | {
"line": 297,
"column": 0
} | [
{
"pp": "X : Type u_2\nY : Type u_3\nZ : Type u_4\ninst✝² : TopologicalSpace X\ninst✝¹ : TopologicalSpace Y\ninst✝ : TopologicalSpace Z\nf : C(X, Y)\nA : DiscreteQuotient X\nB : DiscreteQuotient Y\ng : C(Y, Z)\nC : DiscreteQuotient Z\nh1 : LEComap g B C\nh2 : LEComap f A B\n⊢ map (g.comp f) ⋯ = map g h1 ∘ map f... | [] | ext ⟨⟩
rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 832,
"column": 75
} | {
"line": 832,
"column": 81
} | {
"line": 832,
"column": 81
} | [
{
"pp": "q₁ q₂ : Λ'\nc d : List Γ'\nv : List ℕ\nn : ℕ\nm : PosNum\nIH :\n ∀ (s : Option Γ') (l₁ : List Γ'),\n ∃ l₁' l₂' s',\n l₁.reverseAux (trPosNum m) = l₁'.reverseAux l₂' ∧\n Reaches₁ (TM2.step tr)\n { l := some (q₁.pred q₂), var := s, stk := elim (trPosNum m.succ ++ Γ'.cons :: trLis... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 832,
"column": 75
} | {
"line": 832,
"column": 81
} | {
"line": 832,
"column": 81
} | [
{
"pp": "q₁ q₂ : Λ'\nc d : List Γ'\nv : List ℕ\nn : ℕ\nm : PosNum\nIH :\n ∀ (s : Option Γ') (l₁ : List Γ'),\n ∃ l₁' l₂' s',\n l₁.reverseAux (trPosNum m) = l₁'.reverseAux l₂' ∧\n Reaches₁ (TM2.step tr)\n { l := some (q₁.pred q₂), var := s, stk := elim (trPosNum m.succ ++ Γ'.cons :: trLis... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 832,
"column": 75
} | {
"line": 832,
"column": 81
} | {
"line": 832,
"column": 81
} | [
{
"pp": "q₁ q₂ : Λ'\nc d : List Γ'\nv : List ℕ\nn : ℕ\nm : PosNum\nIH :\n ∀ (s : Option Γ') (l₁ : List Γ'),\n ∃ l₁' l₂' s',\n l₁.reverseAux (trPosNum m) = l₁'.reverseAux l₂' ∧\n Reaches₁ (TM2.step tr)\n { l := some (q₁.pred q₂), var := s, stk := elim (trPosNum m.succ ++ Γ'.cons :: trLis... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 853,
"column": 53
} | {
"line": 853,
"column": 59
} | {
"line": 853,
"column": 59
} | [
{
"pp": "f fs : Code\nIHf :\n ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),\n ∃ b₂,\n TrCfg (stepNormal f k v) b₂ ∧\n Reaches₁ (TM2.step tr)\n { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂\na_ih✝ :\n ∀ (k : Cont) (v : List ℕ) (s : Option ... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 853,
"column": 53
} | {
"line": 853,
"column": 59
} | {
"line": 853,
"column": 59
} | [
{
"pp": "f fs : Code\nIHf :\n ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),\n ∃ b₂,\n TrCfg (stepNormal f k v) b₂ ∧\n Reaches₁ (TM2.step tr)\n { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂\na_ih✝ :\n ∀ (k : Cont) (v : List ℕ) (s : Option ... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 853,
"column": 53
} | {
"line": 853,
"column": 59
} | {
"line": 853,
"column": 59
} | [
{
"pp": "f fs : Code\nIHf :\n ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),\n ∃ b₂,\n TrCfg (stepNormal f k v) b₂ ∧\n Reaches₁ (TM2.step tr)\n { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂\na_ih✝ :\n ∀ (k : Cont) (v : List ℕ) (s : Option ... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 867,
"column": 4
} | {
"line": 868,
"column": 31
} | {
"line": 869,
"column": 2
} | [
{
"pp": "case case.succ\nf g : Code\nIHf :\n ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),\n ∃ b₂,\n TrCfg (stepNormal f k v) b₂ ∧\n Reaches₁ (TM2.step tr)\n { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂\nIHg :\n ∀ (k : Cont) (v : List ℕ)... | [] | · obtain ⟨c, h₁, h₂⟩ := IHg k _ s'
exact ⟨_, h₁, h.trans h₂⟩ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 881,
"column": 25
} | {
"line": 881,
"column": 31
} | {
"line": 881,
"column": 31
} | [
{
"pp": "fs : Code\nas : List ℕ\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₁ : TrC... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 881,
"column": 25
} | {
"line": 881,
"column": 31
} | {
"line": 881,
"column": 31
} | [
{
"pp": "fs : Code\nas : List ℕ\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₁ : TrC... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 881,
"column": 25
} | {
"line": 881,
"column": 31
} | {
"line": 881,
"column": 31
} | [
{
"pp": "fs : Code\nas : List ℕ\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₁ : TrC... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 884,
"column": 57
} | {
"line": 884,
"column": 63
} | {
"line": 884,
"column": 63
} | [
{
"pp": "fs : Code\nas : List ℕ\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₁ : TrC... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 884,
"column": 57
} | {
"line": 884,
"column": 63
} | {
"line": 884,
"column": 63
} | [
{
"pp": "fs : Code\nas : List ℕ\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₁ : TrC... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 884,
"column": 57
} | {
"line": 884,
"column": 63
} | {
"line": 884,
"column": 63
} | [
{
"pp": "fs : Code\nas : List ℕ\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₁ : TrC... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 888,
"column": 25
} | {
"line": 888,
"column": 31
} | {
"line": 888,
"column": 31
} | [
{
"pp": "fs : Code\nas : List ℕ\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₁ : TrC... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 888,
"column": 25
} | {
"line": 888,
"column": 31
} | {
"line": 888,
"column": 31
} | [
{
"pp": "fs : Code\nas : List ℕ\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₁ : TrC... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Computability.TuringMachine.ToPartrec | {
"line": 888,
"column": 25
} | {
"line": 888,
"column": 31
} | {
"line": 888,
"column": 31
} | [
{
"pp": "fs : Code\nas : List ℕ\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₁ : TrC... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Topology.Category.LightProfinite.Basic | {
"line": 139,
"column": 10
} | {
"line": 139,
"column": 61
} | {
"line": 139,
"column": 62
} | [
{
"pp": "case right\nJ : Type v\ninst✝¹ : SmallCategory J\ninst✝ : CountableCategory J\nF : J ⥤ LightProfinite\n⊢ SecondCountableTopology\n ↑{u |\n ∀ {i j : J} (f : i ⟶ j),\n (ConcreteCategory.hom (((F ⋙ lightProfiniteToCompHaus) ⋙ compHausToTop).map f)) (u i) = u j}",
"ppTerm": "?right",... | [] | apply IsInducing.subtypeVal.secondCountableTopology | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Logic.Function.FiberPartition | {
"line": 71,
"column": 37
} | {
"line": 71,
"column": 77
} | {
"line": 73,
"column": 0
} | [
{
"pp": "Y : Type u_2\nZ : Type u_3\nW : Type u_4\nf : Y → Z\ng : Z → W\na : Fiber (g ∘ f)\n⊢ g (f (preimage (g ∘ f) a)) = image (g ∘ f) a",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Function.Fiber.preimage",
"Function.comp",
"id",
... | [] | rw [← map_preimage_eq_image, comp_apply] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Logic.Function.FiberPartition | {
"line": 71,
"column": 37
} | {
"line": 71,
"column": 77
} | {
"line": 73,
"column": 0
} | [
{
"pp": "Y : Type u_2\nZ : Type u_3\nW : Type u_4\nf : Y → Z\ng : Z → W\na : Fiber (g ∘ f)\n⊢ g (f (preimage (g ∘ f) a)) = image (g ∘ f) a",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Function.Fiber.preimage",
"Function.comp",
"id",
... | [] | rw [← map_preimage_eq_image, comp_apply] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Logic.Function.FiberPartition | {
"line": 71,
"column": 37
} | {
"line": 71,
"column": 77
} | {
"line": 73,
"column": 0
} | [
{
"pp": "Y : Type u_2\nZ : Type u_3\nW : Type u_4\nf : Y → Z\ng : Z → W\na : Fiber (g ∘ f)\n⊢ g (f (preimage (g ∘ f) a)) = image (g ∘ f) a",
"ppTerm": "?m.13",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"Function.Fiber.preimage",
"Function.comp",
"id",
... | [] | rw [← map_preimage_eq_image, comp_apply] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Condensed.TopComparison | {
"line": 82,
"column": 4
} | {
"line": 83,
"column": 100
} | {
"line": 84,
"column": 4
} | [
{
"pp": "case refine_2\nC : Type u\ninst✝⁴ : Category.{v, u} C\nG : C ⥤ TopCat\nX : Type w'\ninst✝³ : TopologicalSpace X\ninst✝² : ∀ (Z B : C) (π : Z ⟶ B) [EffectiveEpi π], PreservesLimit (cospan π π) G\nhq : ∀ (Z B : C) (π : Z ⟶ B) [EffectiveEpi π], IsQuotientMap ⇑(ConcreteCategory.hom (G.map π))\nZ B : C\nπ :... | [
"case refine_2\nC : Type u\ninst✝⁴ : Category.{v, u} C\nG : C ⥤ TopCat\nX : Type w'\ninst✝³ : TopologicalSpace X\ninst✝² : ∀ (Z B : C) (π : Z ⟶ B) [EffectiveEpi π], PreservesLimit (cospan π π) G\nhq : ∀ (Z B : C) (π : Z ⟶ B) [EffectiveEpi π], IsQuotientMap ⇑(ConcreteCategory.hom (G.map π))\nZ B : C\nπ : Z ⟶ B\ninst... | simp only [yonedaPresheaf, comp, Quiver.Hom.unop_op, TypeCat.Fun.coe_mk,
Set.coe_setOf, mapToEqualizer, Set.mem_setOf_eq, ConcreteCategory.hom_ofHom, Subtype.mk.injEq] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Condensed.Discrete.LocallyConstant | {
"line": 125,
"column": 51
} | {
"line": 130,
"column": 5
} | {
"line": 132,
"column": 0
} | [
{
"pp": "P : TopCat → Prop\ninst✝¹ : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)\nQ : CompHausLike P\nZ : Type (max u w)\nr : LocallyConstant (↑Q.toTop) Z\na : Fiber ⇑r\ninst✝ : HasExplicitFiniteCoproducts P\nX : (CompHausLike P)ᵒᵖ ⥤ Type (max u w)\n⊢ ((X.mapIso (sigmaIso r).op).hom ≫ (s... | [] | by
ext
simp only [Functor.mapIso_hom, Iso.op_hom, sigmaComparison, TypeCat.Fun.toFun_apply,
CategoryTheory.comp_apply, ConcreteCategory.hom_ofHom, TypeCat.Fun.coe_mk,
← X.map_comp_apply]
rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Condensed.Discrete.LocallyConstant | {
"line": 297,
"column": 4
} | {
"line": 297,
"column": 8
} | {
"line": 298,
"column": 4
} | [
{
"pp": "P : TopCat → Prop\ninst✝⁴ : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)\nS✝ : CompHausLike P\nY✝ : (CompHausLike P)ᵒᵖ ⥤ Type (max u w)\ninst✝³ : HasProp P PUnit.{u + 1}\nf✝ : LocallyConstant (↑S✝.toTop) (Y✝.obj (op (of P PUnit.{u + 1})))\nT : CompHausLike P\ng✝ : T ⟶ S✝\nX✝ : To... | [
"P : TopCat → Prop\ninst✝⁴ : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)\nS✝ : CompHausLike P\nY✝ : (CompHausLike P)ᵒᵖ ⥤ Type (max u w)\ninst✝³ : HasProp P PUnit.{u + 1}\nf✝ : LocallyConstant (↑S✝.toTop) (Y✝.obj (op (of P PUnit.{u + 1})))\nT : CompHausLike P\ng✝ : T ⟶ S✝\nX✝ : TopCat\ninst✝²... | symm | Lean.Elab.Tactic.evalSymm | Lean.Parser.Tactic.symm |
Mathlib.Condensed.Discrete.LocallyConstant | {
"line": 358,
"column": 4
} | {
"line": 358,
"column": 33
} | {
"line": 359,
"column": 4
} | [
{
"pp": "P : TopCat → Prop\ninst✝⁴ : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)\nS : CompHausLike P\nY : (CompHausLike P)ᵒᵖ ⥤ Type (max u w)\ninst✝³ : HasProp P PUnit.{u + 1}\nf : LocallyConstant (↑S.toTop) (Y.obj (op (of P PUnit.{u + 1})))\nT : CompHausLike P\ng : T ⟶ S\nX✝ : TopCat\ni... | [
"P : TopCat → Prop\ninst✝⁴ : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), HasProp P (Subtype p)\nS : CompHausLike P\nY : (CompHausLike P)ᵒᵖ ⥤ Type (max u w)\ninst✝³ : HasProp P PUnit.{u + 1}\nf : LocallyConstant (↑S.toTop) (Y.obj (op (of P PUnit.{u + 1})))\nT : CompHausLike P\ng : T ⟶ S\nX✝ : TopCat\ninst✝² : HasE... | simp only [counitAppAppImage] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Condensed.Explicit | {
"line": 52,
"column": 6
} | {
"line": 53,
"column": 35
} | {
"line": 53,
"column": 36
} | [
{
"pp": "A : Type u_1\ninst✝² : Category.{v_1, u_1} A\ninst✝¹ : ∀ (X : CompHausᵒᵖ), HasLimitsOfShape (StructuredArrow X Stonean.toCompHaus.op) A\nF : Stoneanᵒᵖ ⥤ A\ninst✝ : PreservesFiniteProducts F\n⊢ IsSheaf (coherentTopology Stonean) F",
"ppTerm": "?m.33",
"assigned": true,
"usedConstants": [
... | [] | rw [isSheaf_iff_preservesFiniteProducts_of_projective F]
exact ⟨fun _ ↦ inferInstance⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Condensed.Explicit | {
"line": 52,
"column": 6
} | {
"line": 53,
"column": 35
} | {
"line": 53,
"column": 36
} | [
{
"pp": "A : Type u_1\ninst✝² : Category.{v_1, u_1} A\ninst✝¹ : ∀ (X : CompHausᵒᵖ), HasLimitsOfShape (StructuredArrow X Stonean.toCompHaus.op) A\nF : Stoneanᵒᵖ ⥤ A\ninst✝ : PreservesFiniteProducts F\n⊢ IsSheaf (coherentTopology Stonean) F",
"ppTerm": "?m.33",
"assigned": true,
"usedConstants": [
... | [] | rw [isSheaf_iff_preservesFiniteProducts_of_projective F]
exact ⟨fun _ ↦ inferInstance⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Condensed.Discrete.Module | {
"line": 59,
"column": 4
} | {
"line": 59,
"column": 70
} | {
"line": 59,
"column": 70
} | [
{
"pp": "P : TopCat → Prop\nR : Type (max u w)\ninst✝² : Ring R\ninst✝¹ : HasExplicitFiniteCoproducts P\ninst✝ : HasExplicitPullbacks P\nhs : ∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y), EffectiveEpi f → Function.Surjective ⇑(ConcreteCategory.hom f)\nX : ModuleCat R\nthis : Preregular (CompHausLike P)\n⊢ Presheaf.IsSh... | [] | exact ((CompHausLike.LocallyConstant.functor P hs).obj _).property | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Condensed.Discrete.Characterization | {
"line": 204,
"column": 9
} | {
"line": 218,
"column": 13
} | {
"line": 220,
"column": 0
} | [
{
"pp": "X : LightCondSet\n⊢ [LightCondensed.IsDiscrete X, IsIso ((LightCondensed.discreteUnderlyingAdj (Type u)).counit.app X),\n (LightCondensed.discrete (Type u)).essImage X, functor.essImage X,\n IsIso (LocallyConstant.adjunction.counit.app X),\n ∀ (S : LightProfinite), Nonempty (IsColimit (X... | [] | by
tfae_have 1 ↔ 2 := Sheaf.isConstant_iff_isIso_counit_app _ _ _
tfae_have 1 ↔ 3 := ⟨fun ⟨h⟩ ↦ h, fun h ↦ ⟨h⟩⟩
tfae_have 1 ↔ 4 := Sheaf.isConstant_iff_mem_essImage _ LightProfinite.isTerminalPUnit adjunction X
tfae_have 1 ↔ 5 :=
have : functor.Faithful := inferInstance
have : functor.Full := inferInsta... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Condensed.Light.Epi | {
"line": 109,
"column": 51
} | {
"line": 117,
"column": 38
} | {
"line": 119,
"column": 0
} | [
{
"pp": "R : Type u_1\ninst✝ : Ring R\nF : ℕᵒᵖ ⥤ LightCondMod R\nc : Cone F\nhc : IsLimit c\nhF : ∀ (n : ℕ), Epi (F.map (homOfLE ⋯).op)\n⊢ Epi (c.π.app (Opposite.op 0))",
"ppTerm": "?m.50",
"assigned": true,
"usedConstants": [
"CategoryTheory.Limits.Types.hasColimitsOfSize",
"CategoryThe... | [] | by
apply Functor.epi_of_epi_map (forget R)
change Epi (((forget R).mapCone c).π.app ⟨0⟩)
apply coherentTopology.epi_π_app_zero_of_epi
· simp only [LightProfinite.effectiveEpi_iff_surjective]
exact fun x h ↦ Concrete.surjective_π_app_zero_of_surjective_map (limit.isLimit x) h
· have := (freeForgetAdjunctio... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Condensed.Discrete.Colimit | {
"line": 302,
"column": 2
} | {
"line": 302,
"column": 31
} | {
"line": 303,
"column": 2
} | [
{
"pp": "case e_a\nX : Profiniteᵒᵖ ⥤ Type (u + 1)\ninst✝ : PreservesFiniteProducts X\nhX : (S : Profinite) → IsColimit (X.mapCocone S.asLimitCone.op)\nS : Profiniteᵒᵖ\nY : FintypeCatᵒᵖ\nright✝ : Discrete PUnit.{1}\ng : toProfinite.op.obj Y ⟶ (fromPUnit S).obj right✝\nf :\n LocallyConstant (↑(toProfinite.obj (O... | [
"case e_a\nX : Profiniteᵒᵖ ⥤ Type (u + 1)\ninst✝ : PreservesFiniteProducts X\nhX : (S : Profinite) → IsColimit (X.mapCocone S.asLimitCone.op)\nS : Profiniteᵒᵖ\nY : FintypeCatᵒᵖ\nright✝ : Discrete PUnit.{1}\ng : toProfinite.op.obj Y ⟶ (fromPUnit S).obj right✝\nf :\n LocallyConstant (↑(toProfinite.obj (Opposite.unop... | simp only [counitAppAppImage] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Condensed.Discrete.Colimit | {
"line": 593,
"column": 2
} | {
"line": 593,
"column": 31
} | {
"line": 594,
"column": 2
} | [
{
"pp": "case e_a\nX : LightProfiniteᵒᵖ ⥤ Type u\ninst✝ : PreservesFiniteProducts X\nhX : (S : LightProfinite) → IsColimit (X.mapCocone (coconeRightOpOfCone S.asLimitCone))\nS : LightProfiniteᵒᵖ\nY : FintypeCatᵒᵖ\nright✝ : Discrete PUnit.{1}\ng : toLightProfinite.op.obj Y ⟶ (fromPUnit S).obj right✝\nf :\n Loca... | [
"case e_a\nX : LightProfiniteᵒᵖ ⥤ Type u\ninst✝ : PreservesFiniteProducts X\nhX : (S : LightProfinite) → IsColimit (X.mapCocone (coconeRightOpOfCone S.asLimitCone))\nS : LightProfiniteᵒᵖ\nY : FintypeCatᵒᵖ\nright✝ : Discrete PUnit.{1}\ng : toLightProfinite.op.obj Y ⟶ (fromPUnit S).obj right✝\nf :\n LocallyConstant ... | simp only [counitAppAppImage] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Control.Fold | {
"line": 352,
"column": 2
} | {
"line": 355,
"column": 47
} | {
"line": 357,
"column": 0
} | [
{
"pp": "α : Type u\nxs : List α\n⊢ toList xs = xs",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"List.instLawfulTraversable",
"Eq.mpr",
"MulOne.toOne",
"CancelMonoid.toRightCancelMonoid",
"FreeMonoid",
"Equiv.instEquivLike",
"Monoid.toMulOneClass... | [] | simp only [toList_spec, foldMap, traverse]
induction xs with
| nil => rfl
| cons _ _ ih => (conv_rhs => rw [← ih]); rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Control.Fold | {
"line": 352,
"column": 2
} | {
"line": 355,
"column": 47
} | {
"line": 357,
"column": 0
} | [
{
"pp": "α : Type u\nxs : List α\n⊢ toList xs = xs",
"ppTerm": "?m.6",
"assigned": true,
"usedConstants": [
"List.instLawfulTraversable",
"Eq.mpr",
"MulOne.toOne",
"CancelMonoid.toRightCancelMonoid",
"FreeMonoid",
"Equiv.instEquivLike",
"Monoid.toMulOneClass... | [] | simp only [toList_spec, foldMap, traverse]
induction xs with
| nil => rfl
| cons _ _ ih => (conv_rhs => rw [← ih]); rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Condensed.Light.Sequence | {
"line": 80,
"column": 2
} | {
"line": 80,
"column": 49
} | {
"line": 81,
"column": 2
} | [
{
"pp": "S : Type u_1\nT : Type u_2\nX : Type u_3\ninst✝⁵ : TopologicalSpace S\ninst✝⁴ : TopologicalSpace T\ninst✝³ : TopologicalSpace X\ninst✝² : DiscreteTopology X\ninst✝¹ : T2Space T\ninst✝ : CompactSpace S\nπ : T → S × OnePoint X\nhπ : Continuous π\nσ : Option X → S → T\nhσ : ∀ (x : Option X), Continuous (σ... | [
"case refine_1\nS : Type u_1\nT : Type u_2\nX : Type u_3\ninst✝⁵ : TopologicalSpace S\ninst✝⁴ : TopologicalSpace T\ninst✝³ : TopologicalSpace X\ninst✝² : DiscreteTopology X\ninst✝¹ : T2Space T\ninst✝ : CompactSpace S\nπ : T → S × OnePoint X\nhπ : Continuous π\nσ : Option X → S → T\nhσ : ∀ (x : Option X), Continuous... | refine isOpen_iUnion fun i ↦ IsOpen.inter ?_ ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Control.LawfulFix | {
"line": 77,
"column": 48
} | {
"line": 77,
"column": 52
} | {
"line": 77,
"column": 52
} | [
{
"pp": "case pos.mpr.inr.inr\nα : Type u_1\nβ : α → Type u_2\nf : ((a : α) → Part (β a)) →o (a : α) → Part (β a)\na : α\nb : β a\nh₀ : ∃ i, (approx (⇑f) i a).Dom\ny : β a\ni : ℕ\nhh : b ∈ approx (⇑f) i a\nj : ℕ\nh₁ : y ∈ approx (⇑f) j a\nthis :\n ∀ {α : Type u_1} {β : α → Type u_2} (f : ((a : α) → Part (β a))... | [
"case pos.mpr.inr.inr\nα : Type u_1\nβ : α → Type u_2\nf : ((a : α) → Part (β a)) →o (a : α) → Part (β a)\na : α\nb : β a\nh₀ : ∃ i, (approx (⇑f) i a).Dom\ny : β a\ni : ℕ\nhh : b ∈ approx (⇑f) i a\nj : ℕ\nh₁ : y ∈ approx (⇑f) j a\nthis :\n ∀ {α : Type u_1} {β : α → Type u_2} (f : ((a : α) → Part (β a)) →o (a : α) ... | symm | Lean.Elab.Tactic.evalSymm | Lean.Parser.Tactic.symm |
Mathlib.Condensed.Light.Sequence | {
"line": 131,
"column": 4
} | {
"line": 131,
"column": 53
} | {
"line": 133,
"column": 0
} | [
{
"pp": "case neg\nS : Type u_1\nT : Type u_2\nX : Type u_3\nπ : T → S × Option X\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\nt : T\nht : t ∈ fibres π σ\nt' : T\nht' : t' ∈ fibres π σ\nproperty✝ : π_r π σ (⟨t, ht⟩, ⟨t', ht'⟩).1 = π_... | [] | exact ⟨Sum.inl ⟨σ n (π t).1, by grind⟩, by grind⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.DFinsupp.Interval | {
"line": 40,
"column": 6
} | {
"line": 40,
"column": 34
} | {
"line": 40,
"column": 34
} | [
{
"pp": "ι : Type u_1\nα : ι → Type u_2\ninst✝¹ : DecidableEq ι\ninst✝ : (i : ι) → Zero (α i)\ns✝ : Finset ι\nf✝ : Π₀ (i : ι), α i\nt✝ : (i : ι) → Finset (α i)\ns : Finset ι\nt : (i : ι) → Finset (α i)\nf g : (a : ι) → a ∈ s → α a\nh : (fun i ↦ f ↑i ⋯) = fun i ↦ g ↑i ⋯\ni : ι\nhi : i ∈ s\n⊢ f i hi = g i hi",
... | [] | convert! congr_fun h ⟨i, hi⟩ | Mathlib.Tactic._aux_Mathlib_Tactic_Convert___macroRules_Mathlib_Tactic_convert!_1 | Mathlib.Tactic.convert! |
Mathlib.Data.Fin.FlagRange | {
"line": 47,
"column": 4
} | {
"line": 48,
"column": 79
} | {
"line": 50,
"column": 0
} | [
{
"pp": "case succ\nα : 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 ... | [] | rw [range_subset_iff] at hbt
exact (htc.lt_of_le (hbt k.succ) hx (h _)).resolve_right ((hcovBy k).2 ihk) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Fin.FlagRange | {
"line": 47,
"column": 4
} | {
"line": 48,
"column": 79
} | {
"line": 50,
"column": 0
} | [
{
"pp": "case succ\nα : 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 ... | [] | rw [range_subset_iff] at hbt
exact (htc.lt_of_le (hbt k.succ) hx (h _)).resolve_right ((hcovBy k).2 ihk) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Condensed.Light.Sequence | {
"line": 307,
"column": 2
} | {
"line": 307,
"column": 70
} | {
"line": 308,
"column": 2
} | [
{
"pp": "R : Type\ninst✝ : CommRing R\nX Y : LightCondMod R\np : X ⟶ Y\nhp : Epi p\nS : LightProfinite\nf : (free R).obj (S ⊗ ℕ∪{∞}).toCondensed ⟶ Y\nT : LightProfinite\nπ : T ⟶ S ⊗ ℕ∪{∞}\ng : (free R).obj T.toCondensed ⟶ X\nhπ : Epi π\ncomm : (lightProfiniteToLightCondSet ⋙ free R).map π ≫ f = g ≫ p\n⊢ ∃ S' π,... | [
"R : Type\ninst✝ : CommRing R\nX Y : LightCondMod R\np : X ⟶ Y\nhp : Epi p\nS : LightProfinite\nf : (free R).obj (S ⊗ ℕ∪{∞}).toCondensed ⟶ Y\nT : LightProfinite\nπ : T ⟶ S ⊗ ℕ∪{∞}\ng : (free R).obj T.toCondensed ⟶ X\nhπ : Epi π\ncomm : (lightProfiniteToLightCondSet ⋙ free R).map π ≫ f = g ≫ p\nS' T' : LightProfinit... | obtain ⟨S', T', y', π', g', hπ', hy', comp, ⟨⟨split⟩⟩, epi⟩ := aux π | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Condensed.Light.Sequence | {
"line": 352,
"column": 4
} | {
"line": 352,
"column": 8
} | {
"line": 353,
"column": 4
} | [
{
"pp": "case pos\nR : Type\ninst✝ : CommRing R\nX Y : LightCondMod R\np : X ⟶ Y\nhp : Epi p\nS : LightProfinite\nf : (free R).obj (S ⊗ ℕ∪{∞}).toCondensed ⟶ Y\nT : LightProfinite\nπ : T ⟶ S ⊗ ℕ∪{∞}\ng : (free R).obj T.toCondensed ⟶ X\nhπ : Epi π\ncomm : (lightProfiniteToLightCondSet ⋙ free R).map π ≫ f = g ≫ p\... | [
"case pos\nR : Type\ninst✝ : CommRing R\nX Y : LightCondMod R\np : X ⟶ Y\nhp : Epi p\nS : LightProfinite\nf : (free R).obj (S ⊗ ℕ∪{∞}).toCondensed ⟶ Y\nT : LightProfinite\nπ : T ⟶ S ⊗ ℕ∪{∞}\ng : (free R).obj T.toCondensed ⟶ X\nhπ : Epi π\ncomm : (lightProfiniteToLightCondSet ⋙ free R).map π ≫ f = g ≫ p\nS' T' : Lig... | symm | Lean.Elab.Tactic.evalSymm | Lean.Parser.Tactic.symm |
Mathlib.Data.List.Sigma | {
"line": 307,
"column": 6
} | {
"line": 307,
"column": 32
} | {
"line": 309,
"column": 0
} | [
{
"pp": "case neg\nα : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na a' : α\nb : β a'\nl : List (Sigma β)\nh : ¬a = a'\n⊢ lookupAll a (⟨a', b⟩ :: l) = [] ↔ ∀ (b_1 : β a), ¬⟨a, b_1⟩ ∈ ⟨a', b⟩ :: l",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstants": [
"False",
"eq_false",
"con... | [] | simp [h, lookupAll_eq_nil] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.List.Sigma | {
"line": 307,
"column": 6
} | {
"line": 307,
"column": 32
} | {
"line": 309,
"column": 0
} | [
{
"pp": "case neg\nα : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na a' : α\nb : β a'\nl : List (Sigma β)\nh : ¬a = a'\n⊢ lookupAll a (⟨a', b⟩ :: l) = [] ↔ ∀ (b_1 : β a), ¬⟨a, b_1⟩ ∈ ⟨a', b⟩ :: l",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstants": [
"False",
"eq_false",
"con... | [] | simp [h, lookupAll_eq_nil] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.Sigma | {
"line": 307,
"column": 6
} | {
"line": 307,
"column": 32
} | {
"line": 309,
"column": 0
} | [
{
"pp": "case neg\nα : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na a' : α\nb : β a'\nl : List (Sigma β)\nh : ¬a = a'\n⊢ lookupAll a (⟨a', b⟩ :: l) = [] ↔ ∀ (b_1 : β a), ¬⟨a, b_1⟩ ∈ ⟨a', b⟩ :: l",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstants": [
"False",
"eq_false",
"con... | [] | simp [h, lookupAll_eq_nil] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Finset.Lattice.Pi | {
"line": 34,
"column": 37
} | {
"line": 34,
"column": 48
} | {
"line": 34,
"column": 48
} | [
{
"pp": "case insert\nα : Type u_1\nι : Type u_2\ninst✝² : DistribLattice α\ninst✝¹ : BoundedOrder α\ninst✝ : DecidableEq ι\nκ : ι → Type u_3\nt : (i : ι) → Finset (κ i)\nf : (i : ι) → κ i → α\ni : ι\ns : Finset ι\nhi : i ∉ s\nih : (s.inf fun i ↦ (t i).sup (f i)) = (s.pi t).sup fun g ↦ s.attach.inf fun i ↦ f (↑... | [
"case insert\nα : Type u_1\nι : Type u_2\ninst✝² : DistribLattice α\ninst✝¹ : BoundedOrder α\ninst✝ : DecidableEq ι\nκ : ι → Type u_3\nt : (i : ι) → Finset (κ i)\nf : (i : ι) → κ i → α\ni : ι\ns : Finset ι\nhi : i ∉ s\nih : (s.inf fun i ↦ (t i).sup (f i)) = (s.pi t).sup fun g ↦ s.attach.inf fun i ↦ f (↑i) (g ↑i ⋯)\... | sup_inf_sup | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Finset.NatDivisors | {
"line": 70,
"column": 51
} | {
"line": 70,
"column": 67
} | {
"line": 70,
"column": 67
} | [
{
"pp": "m n : ℕ\nhmn : m.Coprime n\n⊢ (m * n).divisors = m.divisors * n.divisors",
"ppTerm": "?m.113",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"HMul.hMul",
"congrArg",
"Finset",
"Nat.divisors_mul",
"id",
"instMulNat",
"Nat.divisors",
"Fin... | [
"m n : ℕ\nhmn : m.Coprime n\n⊢ m.divisors * n.divisors = m.divisors * n.divisors"
] | Nat.divisors_mul | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Finsupp.AList | {
"line": 81,
"column": 85
} | {
"line": 83,
"column": 8
} | {
"line": 85,
"column": 0
} | [
{
"pp": "α : Type u_1\nM : Type u_2\ninst✝² : Zero M\ninst✝¹ : DecidableEq α\ninst✝ : DecidableEq M\nl : AList fun _x ↦ M\n⊢ l.lookupFinsupp.support = (filter (fun x ↦ decide (x.snd ≠ 0)) l.entries).keys.toFinset",
"ppTerm": "?m.27",
"assigned": true,
"usedConstants": [
"instDecidableNot",
... | [] | by
dsimp only [lookupFinsupp]
congr! | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.List.Sigma | {
"line": 644,
"column": 6
} | {
"line": 644,
"column": 70
} | {
"line": 645,
"column": 6
} | [
{
"pp": "case neg\nα : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\ntail✝ : List (Sigma β)\nl_ih : dlookup a tail✝.dedupKeys = dlookup a tail✝\na' : α\nb : β a'\nh : ¬a = a'\n⊢ dlookup a (⟨a', b⟩ :: tail✝).dedupKeys = dlookup a (⟨a', b⟩ :: tail✝)",
"ppTerm": "?neg✝",
"assigned": true,
"used... | [
"case neg.a\nα : Type u\nβ : α → Type v\ninst✝ : DecidableEq α\na : α\ntail✝ : List (Sigma β)\nl_ih : dlookup a tail✝.dedupKeys = dlookup a tail✝\na' : α\nb : β a'\nh : ¬a = a'\n⊢ a ≠ ⟨a', b⟩.fst"
] | rw [dedupKeys_cons, dlookup_kinsert_ne h, l_ih, dlookup_cons_ne] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Holor | {
"line": 276,
"column": 4
} | {
"line": 277,
"column": 48
} | {
"line": 278,
"column": 2
} | [
{
"pp": "α : Type\nds : List ℕ\ninst✝¹ : Mul α\ninst✝ : AddMonoid α\nn : ℕ\nx y : Holor α ds\nhx : CPRankMax 0 x\nhy : CPRankMax n y\n⊢ CPRankMax (0 + n) (x + y)",
"ppTerm": "?m.34",
"assigned": true,
"usedConstants": [
"AddMonoid.toAddSemigroup",
"congrArg",
"AddMonoid.toAddZeroCl... | [] | match hx with
| CPRankMax.zero => simp only [zero_add, hy] | Lean.Elab.Tactic.evalMatch | Lean.Parser.Tactic.match |
Mathlib.Data.Holor | {
"line": 276,
"column": 4
} | {
"line": 277,
"column": 48
} | {
"line": 278,
"column": 2
} | [
{
"pp": "α : Type\nds : List ℕ\ninst✝¹ : Mul α\ninst✝ : AddMonoid α\nn : ℕ\nx y : Holor α ds\nhx : CPRankMax 0 x\nhy : CPRankMax n y\n⊢ CPRankMax (0 + n) (x + y)",
"ppTerm": "?m.34",
"assigned": true,
"usedConstants": [
"AddMonoid.toAddSemigroup",
"congrArg",
"AddMonoid.toAddZeroCl... | [] | match hx with
| CPRankMax.zero => simp only [zero_add, hy] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Holor | {
"line": 276,
"column": 4
} | {
"line": 277,
"column": 48
} | {
"line": 278,
"column": 2
} | [
{
"pp": "α : Type\nds : List ℕ\ninst✝¹ : Mul α\ninst✝ : AddMonoid α\nn : ℕ\nx y : Holor α ds\nhx : CPRankMax 0 x\nhy : CPRankMax n y\n⊢ CPRankMax (0 + n) (x + y)",
"ppTerm": "?m.34",
"assigned": true,
"usedConstants": [
"AddMonoid.toAddSemigroup",
"congrArg",
"AddMonoid.toAddZeroCl... | [] | match hx with
| CPRankMax.zero => simp only [zero_add, hy] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Int.Lemmas | {
"line": 111,
"column": 4
} | {
"line": 111,
"column": 10
} | {
"line": 112,
"column": 2
} | [
{
"pp": "case false\nn : ℤ\n⊢ (bif false then 1 else 0) / 2 = 0",
"ppTerm": "?false",
"assigned": true,
"usedConstants": [
"cond",
"Int.instDiv",
"instHDiv",
"of_decide_eq_true",
"Int.instDecidableEq",
"id",
"HDiv.hDiv",
"Int",
"Bool.true",
... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Data.Int.Lemmas | {
"line": 111,
"column": 4
} | {
"line": 111,
"column": 10
} | {
"line": 112,
"column": 2
} | [
{
"pp": "case false\nn : ℤ\n⊢ (bif false then 1 else 0) / 2 = 0",
"ppTerm": "?false",
"assigned": true,
"usedConstants": [
"cond",
"Int.instDiv",
"instHDiv",
"of_decide_eq_true",
"Int.instDecidableEq",
"id",
"HDiv.hDiv",
"Int",
"Bool.true",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Int.Lemmas | {
"line": 111,
"column": 4
} | {
"line": 111,
"column": 10
} | {
"line": 112,
"column": 2
} | [
{
"pp": "case false\nn : ℤ\n⊢ (bif false then 1 else 0) / 2 = 0",
"ppTerm": "?false",
"assigned": true,
"usedConstants": [
"cond",
"Int.instDiv",
"instHDiv",
"of_decide_eq_true",
"Int.instDecidableEq",
"id",
"HDiv.hDiv",
"Int",
"Bool.true",
... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Int.Lemmas | {
"line": 114,
"column": 4
} | {
"line": 114,
"column": 10
} | {
"line": 116,
"column": 0
} | [
{
"pp": "case H\nb : Bool\nn : ℤ\n⊢ 2 ≠ 0",
"ppTerm": "?H",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"Int.instDecidableEq",
"id",
"Ne",
"Int",
"Bool.true",
"instOfNat",
"Bool",
"Eq.refl",
"OfNat.of... | [] | decide | Lean.Elab.Tactic.evalDecide | Lean.Parser.Tactic.decide |
Mathlib.Data.Int.Lemmas | {
"line": 114,
"column": 4
} | {
"line": 114,
"column": 10
} | {
"line": 116,
"column": 0
} | [
{
"pp": "case H\nb : Bool\nn : ℤ\n⊢ 2 ≠ 0",
"ppTerm": "?H",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"Int.instDecidableEq",
"id",
"Ne",
"Int",
"Bool.true",
"instOfNat",
"Bool",
"Eq.refl",
"OfNat.of... | [] | decide | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Int.Lemmas | {
"line": 114,
"column": 4
} | {
"line": 114,
"column": 10
} | {
"line": 116,
"column": 0
} | [
{
"pp": "case H\nb : Bool\nn : ℤ\n⊢ 2 ≠ 0",
"ppTerm": "?H",
"assigned": true,
"usedConstants": [
"instDecidableNot",
"of_decide_eq_true",
"Int.instDecidableEq",
"id",
"Ne",
"Int",
"Bool.true",
"instOfNat",
"Bool",
"Eq.refl",
"OfNat.of... | [] | decide | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Int.CardIntervalMod | {
"line": 129,
"column": 2
} | {
"line": 129,
"column": 41
} | {
"line": 130,
"column": 2
} | [
{
"pp": "b r : ℕ\nhr : 0 < r\nv : ℕ\n⊢ ↑(count (fun x ↦ x ≡ v [MOD r]) b) = ⌈(↑b - ↑(v % r)) / ↑r⌉",
"ppTerm": "?m.24",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Rat.instOfNat",
"Preorder.toLT",
"NeZero.charZero_one",
"AddMonoid.toAddZeroClass",
"Rat",
... | [
"b r : ℕ\nhr : 0 < r\nv : ℕ\nhr' : 0 < ↑r\n⊢ ↑(count (fun x ↦ x ≡ v [MOD r]) b) = ⌈(↑b - ↑(v % r)) / ↑r⌉"
] | have hr' : 0 < (r : ℚ) := by positivity | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.Int.CardIntervalMod | {
"line": 136,
"column": 45
} | {
"line": 136,
"column": 53
} | {
"line": 136,
"column": 53
} | [
{
"pp": "b r : ℕ\nhr : 0 < r\nv : ℕ\nhr' : 0 < ↑r\n| ⌈(↑b - ↑(v % r)) / ↑r⌉ - ⌈(0 - ↑(v % r)) / ↑r⌉",
"ppTerm": "?m.123",
"assigned": true,
"usedConstants": [
"instHDiv",
"congrArg",
"AddMonoid.toAddZeroClass",
"Rat",
"Rat.instFloorRing",
"AddGroupWithOne.toAddMon... | [
"b r : ℕ\nhr : 0 < r\nv : ℕ\nhr' : 0 < ↑r\n| ⌈(↑b - ↑(v % r)) / ↑r⌉ - ⌈-↑(v % r) / ↑r⌉"
] | zero_sub | Lean.Elab.Tactic.Conv.evalRewrite | null |
Mathlib.Data.Int.CardIntervalMod | {
"line": 145,
"column": 2
} | {
"line": 145,
"column": 41
} | {
"line": 146,
"column": 2
} | [
{
"pp": "b r : ℕ\nhr : 0 < r\nv : ℕ\n⊢ count (fun x ↦ x ≡ v [MOD r]) b = b / r + if v % r < b % r then 1 else 0",
"ppTerm": "?m.33",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"Rat.instOfNat",
"Preorder.toLT",
"NeZero.charZero_one",
"AddMonoid.toAddZeroClass",
... | [
"b r : ℕ\nhr : 0 < r\nv : ℕ\nhr' : 0 < ↑r\n⊢ count (fun x ↦ x ≡ v [MOD r]) b = b / r + if v % r < b % r then 1 else 0"
] | have hr' : 0 < (r : ℚ) := by positivity | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Data.Int.CardIntervalMod | {
"line": 155,
"column": 6
} | {
"line": 155,
"column": 18
} | {
"line": 155,
"column": 19
} | [
{
"pp": "case neg\nb r : ℕ\nhr : 0 < r\nv : ℕ\nhr' : 0 < ↑r\nh : ¬v % r < b % r\n⊢ -1 * ↑r < ↑(b % r) - ↑(v % r) ∧ ↑(b % r) - ↑(v % r) ≤ 0",
"ppTerm": "?neg✝",
"assigned": true,
"usedConstants": [
"Rat.addCommMonoid",
"Eq.mpr",
"GroupWithZero.toMonoidWithZero",
"NegZeroClass.... | [
"case neg\nb r : ℕ\nhr : 0 < r\nv : ℕ\nhr' : 0 < ↑r\nh : ¬v % r < b % r\n⊢ -1 * ↑r < ↑(b % r) - ↑(v % r) ∧ ↑(b % r) ≤ ↑(v % r)"
] | tsub_nonpos, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.DropRight | {
"line": 98,
"column": 63
} | {
"line": 98,
"column": 80
} | {
"line": 100,
"column": 0
} | [
{
"pp": "α : Type u_1\np : α → Bool\n⊢ rdropWhile p [] = []",
"ppTerm": "?m.5",
"assigned": true,
"usedConstants": [
"List",
"eq_self",
"of_eq_true",
"Eq",
"List.nil"
],
"usedFVars": [
"α"
],
"usedGoals": []
}
] | [] | simp [rdropWhile] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.List.DropRight | {
"line": 98,
"column": 63
} | {
"line": 98,
"column": 80
} | {
"line": 100,
"column": 0
} | [
{
"pp": "α : Type u_1\np : α → Bool\n⊢ rdropWhile p [] = []",
"ppTerm": "?m.5",
"assigned": true,
"usedConstants": [
"List",
"eq_self",
"of_eq_true",
"Eq",
"List.nil"
],
"usedFVars": [
"α"
],
"usedGoals": []
}
] | [] | simp [rdropWhile] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.DropRight | {
"line": 98,
"column": 63
} | {
"line": 98,
"column": 80
} | {
"line": 100,
"column": 0
} | [
{
"pp": "α : Type u_1\np : α → Bool\n⊢ rdropWhile p [] = []",
"ppTerm": "?m.5",
"assigned": true,
"usedConstants": [
"List",
"eq_self",
"of_eq_true",
"Eq",
"List.nil"
],
"usedFVars": [
"α"
],
"usedGoals": []
}
] | [] | simp [rdropWhile] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Intervals | {
"line": 145,
"column": 8
} | {
"line": 145,
"column": 37
} | {
"line": 145,
"column": 38
} | [
{
"pp": "case inl\nn m l : ℕ\nhlm : l ≤ m\nhnl : n ≤ l\n⊢ filter (fun x ↦ decide (x < l)) (Ico n m) = Ico n l",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"instHAppendOfAppend",
"List",
"Nat",
"List.filter",
"LT.... | [
"case inl\nn m l : ℕ\nhlm : l ≤ m\nhnl : n ≤ l\n⊢ filter (fun x ↦ decide (x < l)) (Ico n l ++ Ico l m) = Ico n l"
] | ← append_consecutive hnl hlm, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Intervals | {
"line": 170,
"column": 8
} | {
"line": 170,
"column": 37
} | {
"line": 170,
"column": 38
} | [
{
"pp": "case inl\nn m l : ℕ\nhnl : n ≤ l\nhlm : l ≤ m\n⊢ filter (fun x ↦ decide (l ≤ x)) (Ico n m) = Ico l m",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"congrArg",
"id",
"LE.le",
"instLENat",
"instHAppendOfAppend",
"List",
"Nat... | [
"case inl\nn m l : ℕ\nhnl : n ≤ l\nhlm : l ≤ m\n⊢ filter (fun x ↦ decide (l ≤ x)) (Ico n l ++ Ico l m) = Ico l m"
] | ← append_consecutive hnl hlm, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.DropRight | {
"line": 128,
"column": 73
} | {
"line": 128,
"column": 90
} | {
"line": 130,
"column": 0
} | [
{
"pp": "α : Type u_1\np : α → Bool\nl : List α\n⊢ rdropWhile p l = [] ↔ ∀ (x : α), x ∈ l → p x = true",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"List.mem_reverse._simp_1",
"List.dropWhile_eq_nil_iff._simp_1",
"congrArg",
"Membership.mem",
"iff_self",
... | [] | simp [rdropWhile] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Data.List.DropRight | {
"line": 128,
"column": 73
} | {
"line": 128,
"column": 90
} | {
"line": 130,
"column": 0
} | [
{
"pp": "α : Type u_1\np : α → Bool\nl : List α\n⊢ rdropWhile p l = [] ↔ ∀ (x : α), x ∈ l → p x = true",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"List.mem_reverse._simp_1",
"List.dropWhile_eq_nil_iff._simp_1",
"congrArg",
"Membership.mem",
"iff_self",
... | [] | simp [rdropWhile] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.List.DropRight | {
"line": 128,
"column": 73
} | {
"line": 128,
"column": 90
} | {
"line": 130,
"column": 0
} | [
{
"pp": "α : Type u_1\np : α → Bool\nl : List α\n⊢ rdropWhile p l = [] ↔ ∀ (x : α), x ∈ l → p x = true",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"List.mem_reverse._simp_1",
"List.dropWhile_eq_nil_iff._simp_1",
"congrArg",
"Membership.mem",
"iff_self",
... | [] | simp [rdropWhile] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.Shortlex | {
"line": 115,
"column": 2
} | {
"line": 124,
"column": 52
} | {
"line": 126,
"column": 0
} | [
{
"pp": "case inr\nα : Type u_1\nr : α → α → Prop\nt₁ t₂ : List α\nh : Shortlex r t₁ t₂\ns : List α\nh2 : t₁.length = t₂.length ∧ Lex r t₁ t₂\n⊢ Shortlex r (s ++ t₁) (s ++ t₂)",
"ppTerm": "?inr",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.instIsOrderedAddMonoid",
"AddLeftC... | [] | cases s with
| nil =>
rw [List.nil_append, List.nil_append]
exact h
| cons head tail =>
apply of_lex
· simp only [List.cons_append, List.length_cons, List.length_append,
add_left_inj, add_right_inj]
exact h2.1
exact List.Lex.append_left r h2.2 (head :: tail) | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalCases | Lean.Parser.Tactic.cases |
Mathlib.Data.List.Shortlex | {
"line": 159,
"column": 4
} | {
"line": 159,
"column": 41
} | {
"line": 160,
"column": 4
} | [
{
"pp": "case zero\nα : Type u_1\nr : α → α → Prop\nh : WellFounded r\na : List α\nlen_a : a.length = 0\n⊢ Acc (Shortlex r) a",
"ppTerm": "?zero",
"assigned": true,
"usedConstants": [
"congrArg",
"Eq.mp",
"instOfNatNat",
"List",
"Nat",
"propext",
"OfNat.ofNa... | [
"case zero\nα : Type u_1\nr : α → α → Prop\nh : WellFounded r\na : List α\nlen_a : a = []\n⊢ Acc (Shortlex r) a"
] | rw [List.length_eq_zero_iff] at len_a | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.List.SplitBy | {
"line": 105,
"column": 6
} | {
"line": 105,
"column": 34
} | {
"line": 106,
"column": 6
} | [
{
"pp": "case nil.inr\nα : Type u_1\nr : α → α → Bool\na : α\ng : List α\nhga : ∀ (b : α), b ∈ g.head? → r b a = true\nhg : IsChain (fun y x ↦ r x y = true) g\n⊢ IsChain (fun x y ↦ r x y = true) (a :: g).reverse",
"ppTerm": "?nil.inr",
"assigned": true,
"usedConstants": [
"List.IsChain",
... | [
"case nil.inr\nα : Type u_1\nr : α → α → Bool\na : α\ng : List α\nhga : ∀ (b : α), b ∈ g.head? → r b a = true\nhg : IsChain (fun y x ↦ r x y = true) g\n⊢ IsChain (fun b a ↦ r a b = true) (a :: g).reverse.reverse"
] | apply List.isChain_reverse.1 | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Data.List.SplitBy | {
"line": 115,
"column": 8
} | {
"line": 115,
"column": 36
} | {
"line": 116,
"column": 8
} | [
{
"pp": "case h_2.inl\nα : Type u_1\nr : α → α → Bool\nb : α\nl : List α\na : α\ng : List α\nhga : ∀ (b : α), b ∈ g.head? → r b a = true\nhg : IsChain (fun y x ↦ r x y = true) g\nx✝ : Bool\nheq✝ : r a b = false\nIH :\n ∀ {a_1 : α} {g_1 : List α},\n (∀ (b : α), b ∈ g_1.head? → r b a_1 = true) →\n IsChai... | [
"case h_2.inl\nα : Type u_1\nr : α → α → Bool\nb : α\nl : List α\na : α\ng : List α\nhga : ∀ (b : α), b ∈ g.head? → r b a = true\nhg : IsChain (fun y x ↦ r x y = true) g\nx✝ : Bool\nheq✝ : r a b = false\nIH :\n ∀ {a_1 : α} {g_1 : List α},\n (∀ (b : α), b ∈ g_1.head? → r b a_1 = true) →\n IsChain (fun y x ↦... | apply List.isChain_reverse.1 | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Data.List.SplitBy | {
"line": 133,
"column": 4
} | {
"line": 133,
"column": 32
} | {
"line": 134,
"column": 4
} | [
{
"pp": "case nil\nα : Type u_1\nr : α → α → Bool\na : α\ng : List α\ngs : List (List α)\nhgs' : ¬[] ∈ gs\nhgs : IsChain (fun b a ↦ ∃ ha hb, r (a.getLast ha) (b.head hb) = false) gs\nhga : ∀ (m : List α), m ∈ gs.head? → ∃ ha hb, r (m.getLast ha) ((g.reverse ++ [a]).head hb) = false\n⊢ IsChain (fun a b ↦ ∃ ha hb... | [
"case nil\nα : Type u_1\nr : α → α → Bool\na : α\ng : List α\ngs : List (List α)\nhgs' : ¬[] ∈ gs\nhgs : IsChain (fun b a ↦ ∃ ha hb, r (a.getLast ha) (b.head hb) = false) gs\nhga : ∀ (m : List α), m ∈ gs.head? → ∃ ha hb, r (m.getLast ha) ((g.reverse ++ [a]).head hb) = false\n⊢ IsChain (fun b a ↦ ∃ ha hb, r (a.getLa... | apply List.isChain_reverse.1 | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Data.Matrix.ColumnRowPartitioned | {
"line": 109,
"column": 2
} | {
"line": 109,
"column": 24
} | {
"line": 111,
"column": 0
} | [
{
"pp": "R : Type u_1\nm₁ : Type u_3\nm₂ : Type u_4\nn : Type u_5\nA : Matrix (m₁ ⊕ m₂) n R\n⊢ A.toRows₁.fromRows A.toRows₂ = A",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"Sum.casesOn",
"Sum",
"Sum.inl",
"Sum.inr",
"Matrix.toRows₂",
"eq_self",
... | [] | ext (i | i) j <;> simp | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.Matrix.ColumnRowPartitioned | {
"line": 109,
"column": 2
} | {
"line": 109,
"column": 24
} | {
"line": 111,
"column": 0
} | [
{
"pp": "R : Type u_1\nm₁ : Type u_3\nm₂ : Type u_4\nn : Type u_5\nA : Matrix (m₁ ⊕ m₂) n R\n⊢ A.toRows₁.fromRows A.toRows₂ = A",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"Sum.casesOn",
"Sum",
"Sum.inl",
"Sum.inr",
"Matrix.toRows₂",
"eq_self",
... | [] | ext (i | i) j <;> simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Matrix.ColumnRowPartitioned | {
"line": 109,
"column": 2
} | {
"line": 109,
"column": 24
} | {
"line": 111,
"column": 0
} | [
{
"pp": "R : Type u_1\nm₁ : Type u_3\nm₂ : Type u_4\nn : Type u_5\nA : Matrix (m₁ ⊕ m₂) n R\n⊢ A.toRows₁.fromRows A.toRows₂ = A",
"ppTerm": "?m.14",
"assigned": true,
"usedConstants": [
"Sum.casesOn",
"Sum",
"Sum.inl",
"Sum.inr",
"Matrix.toRows₂",
"eq_self",
... | [] | ext (i | i) j <;> simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.List.SplitBy | {
"line": 176,
"column": 45
} | {
"line": 179,
"column": 72
} | {
"line": 181,
"column": 0
} | [
{
"pp": "α : Type u_1\nm : List α\nr : α → α → Bool\nl : List α\nhn : l ≠ []\nh : IsChain (fun x y ↦ r x y = true) l\nha : ∀ (x : α), x ∈ m.head? → r (l.getLast hn) x = false\n⊢ splitBy r (l ++ m) = l :: splitBy r m",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"List.head?",
... | [] | by
cases l with
| nil => contradiction
| cons a l => rw [cons_append, splitBy, splitByLoop_append h ha]; simp | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Matrix.ColumnRowPartitioned | {
"line": 132,
"column": 2
} | {
"line": 132,
"column": 24
} | {
"line": 134,
"column": 0
} | [
{
"pp": "R : Type u_1\nm : Type u_2\nn₁ : Type u_6\nn₂ : Type u_7\nA₁ : Matrix m n₁ R\nA₂ : Matrix m n₂ R\n⊢ (A₁.fromCols A₂)ᵀ = A₁ᵀ.fromRows A₂ᵀ",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"Matrix.fromCols",
"Sum.casesOn",
"Sum",
"Matrix.transpose",
"eq_s... | [] | ext (i | i) j <;> simp | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.Matrix.ColumnRowPartitioned | {
"line": 132,
"column": 2
} | {
"line": 132,
"column": 24
} | {
"line": 134,
"column": 0
} | [
{
"pp": "R : Type u_1\nm : Type u_2\nn₁ : Type u_6\nn₂ : Type u_7\nA₁ : Matrix m n₁ R\nA₂ : Matrix m n₂ R\n⊢ (A₁.fromCols A₂)ᵀ = A₁ᵀ.fromRows A₂ᵀ",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"Matrix.fromCols",
"Sum.casesOn",
"Sum",
"Matrix.transpose",
"eq_s... | [] | ext (i | i) j <;> simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Matrix.ColumnRowPartitioned | {
"line": 132,
"column": 2
} | {
"line": 132,
"column": 24
} | {
"line": 134,
"column": 0
} | [
{
"pp": "R : Type u_1\nm : Type u_2\nn₁ : Type u_6\nn₂ : Type u_7\nA₁ : Matrix m n₁ R\nA₂ : Matrix m n₂ R\n⊢ (A₁.fromCols A₂)ᵀ = A₁ᵀ.fromRows A₂ᵀ",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"Matrix.fromCols",
"Sum.casesOn",
"Sum",
"Matrix.transpose",
"eq_s... | [] | ext (i | i) j <;> simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Matrix.ColumnRowPartitioned | {
"line": 156,
"column": 2
} | {
"line": 156,
"column": 24
} | {
"line": 158,
"column": 0
} | [
{
"pp": "R : Type u_1\nm₁ : Type u_3\nm₂ : Type u_4\nn : Type u_5\ninst✝ : Neg R\nA₁ : Matrix m₁ n R\nA₂ : Matrix m₂ n R\n⊢ -A₁.fromRows A₂ = (-A₁).fromRows (-A₂)",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Matrix",
"Sum.casesOn",
"Sum",
"eq_self",
"Matri... | [] | ext (i | i) j <;> simp | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.Data.Matrix.ColumnRowPartitioned | {
"line": 156,
"column": 2
} | {
"line": 156,
"column": 24
} | {
"line": 158,
"column": 0
} | [
{
"pp": "R : Type u_1\nm₁ : Type u_3\nm₂ : Type u_4\nn : Type u_5\ninst✝ : Neg R\nA₁ : Matrix m₁ n R\nA₂ : Matrix m₂ n R\n⊢ -A₁.fromRows A₂ = (-A₁).fromRows (-A₂)",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Matrix",
"Sum.casesOn",
"Sum",
"eq_self",
"Matri... | [] | ext (i | i) j <;> simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Matrix.ColumnRowPartitioned | {
"line": 156,
"column": 2
} | {
"line": 156,
"column": 24
} | {
"line": 158,
"column": 0
} | [
{
"pp": "R : Type u_1\nm₁ : Type u_3\nm₂ : Type u_4\nn : Type u_5\ninst✝ : Neg R\nA₁ : Matrix m₁ n R\nA₂ : Matrix m₂ n R\n⊢ -A₁.fromRows A₂ = (-A₁).fromRows (-A₂)",
"ppTerm": "?m.16",
"assigned": true,
"usedConstants": [
"Matrix",
"Sum.casesOn",
"Sum",
"eq_self",
"Matri... | [] | ext (i | i) j <;> simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Multiset.DershowitzManna | {
"line": 58,
"column": 2
} | {
"line": 58,
"column": 40
} | {
"line": 59,
"column": 2
} | [
{
"pp": "α : Type u_1\ninst✝ : Preorder α\nX₁ Y₁ Z₁ : Multiset α\nhYZ₁ : ∀ (y : α), y ∈ Y₁ → ∃ z, z ∈ Z₁ ∧ y < z\nX₂ Y₂ Z₂ : Multiset α\nhZ₂ : Z₂ ≠ ∅\nhXZXY : X₁ + Z₁ = X₂ + Y₂\nhYZ₂ : ∀ (y : α), y ∈ Y₂ → ∃ z, z ∈ Z₂ ∧ y < z\n⊢ (X₁ + Y₁).IsDershowitzMannaLT (X₂ + Z₂)",
"ppTerm": "?m.116",
"assigned": tr... | [
"α : Type u_1\ninst✝ : Preorder α\nX₁ Y₁ Z₁ : Multiset α\nhYZ₁ : ∀ (y : α), y ∈ Y₁ → ∃ z, z ∈ Z₁ ∧ y < z\nX₂ Y₂ Z₂ : Multiset α\nhZ₂ : Z₂ ≠ ∅\nhXZXY : Z₁ + X₁ = Y₂ + X₂\nhYZ₂ : ∀ (y : α), y ∈ Y₂ → ∃ z, z ∈ Z₂ ∧ y < z\n⊢ (X₁ + Y₁).IsDershowitzMannaLT (X₂ + Z₂)"
] | rw [add_comm X₁, add_comm X₂] at hXZXY | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 126,
"column": 7
} | {
"line": 128,
"column": 59
} | {
"line": 128,
"column": 59
} | [
{
"pp": "ι : Type u_1\na s : ι → ℕ\nl l' : List ι\nhl : l.Perm l'\nhs : ∀ i ∈ l, s i ≠ 0\nco : List.Pairwise (Coprime on s) l\nz : { k // ∀ i ∈ l', k ≡ a i [MOD s i] } := chineseRemainderOfList a s l' ⋯\nhlp : (List.map s l).prod = (List.map s l').prod\n⊢ ↑z < (List.map s l).prod",
"ppTerm": "?m.83",
"a... | [] | by rw [hlp]
exact chineseRemainderOfList_lt_prod _ _ _ _
(by simpa [List.Perm.mem_iff hl.symm] using hs) | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 142,
"column": 39
} | {
"line": 142,
"column": 77
} | {
"line": 143,
"column": 6
} | [
{
"pp": "ι : Type u_1\na s : ι → ℕ\nm : Multiset ι\nl l' : List ι\npp : l.Perm l'\nnod' : l'.Nodup\nnod : l.Nodup\nhs' : ∀ i ∈ l', s i ≠ 0\n⊢ ∀ i ∈ l, s i ≠ 0",
"ppTerm": "?m.170",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Membership.mem",
"id",
"Ne",
"instOfNatNa... | [] | simpa [List.Perm.mem_iff pp] using hs' | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 142,
"column": 39
} | {
"line": 142,
"column": 77
} | {
"line": 143,
"column": 6
} | [
{
"pp": "ι : Type u_1\na s : ι → ℕ\nm : Multiset ι\nl l' : List ι\npp : l.Perm l'\nnod' : l'.Nodup\nnod : l.Nodup\nhs' : ∀ i ∈ l', s i ≠ 0\n⊢ ∀ i ∈ l, s i ≠ 0",
"ppTerm": "?m.170",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Membership.mem",
"id",
"Ne",
"instOfNatNa... | [] | simpa [List.Perm.mem_iff pp] using hs' | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Nat.ChineseRemainder | {
"line": 142,
"column": 39
} | {
"line": 142,
"column": 77
} | {
"line": 143,
"column": 6
} | [
{
"pp": "ι : Type u_1\na s : ι → ℕ\nm : Multiset ι\nl l' : List ι\npp : l.Perm l'\nnod' : l'.Nodup\nnod : l.Nodup\nhs' : ∀ i ∈ l', s i ≠ 0\n⊢ ∀ i ∈ l, s i ≠ 0",
"ppTerm": "?m.170",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Membership.mem",
"id",
"Ne",
"instOfNatNa... | [] | simpa [List.Perm.mem_iff pp] using hs' | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.