module stringlengths 16 90 | startPos dict | endPos dict | nextStartPos dict | goals listlengths 0 96 | goalsAfter listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 375
values | kind stringclasses 379
values |
|---|---|---|---|---|---|---|---|---|
Mathlib.RingTheory.Polynomial.Content | {
"line": 256,
"column": 4
} | {
"line": 256,
"column": 44
} | {
"line": 257,
"column": 4
} | [
{
"pp": "case pos\nR : Type u_1\ninst✝¹ : CommRing R\ninst✝ : NormalizedGCDMonoid R\np : R[X]\na✝ : Nontrivial R\nh : C p.content = 0\n⊢ p.primPart.natDegree = p.natDegree",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"Polynomial.C",
"Polynomial.content_eq_zero_iff",
"c... | [
"case pos\nR : Type u_1\ninst✝¹ : CommRing R\ninst✝ : NormalizedGCDMonoid R\np : R[X]\na✝ : Nontrivial R\nh : p = 0\n⊢ p.primPart.natDegree = p.natDegree"
] | rw [C_eq_zero, content_eq_zero_iff] at h | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Algebra.Polynomial.FieldDivision | {
"line": 76,
"column": 2
} | {
"line": 76,
"column": 69
} | {
"line": 77,
"column": 2
} | [
{
"pp": "R : Type u\ninst✝ : CommRing R\np : R[X]\nt : R\nm : ℕ := rootMultiplicity t p\nhm : m = rootMultiplicity t p\n⊢ eval t ((⇑derivative)^[m] p) = m ! • eval t (p /ₘ (X - C t) ^ m)",
"ppTerm": "?m.55",
"assigned": true,
"usedConstants": [
"Polynomial.derivative",
"Eq.mpr",
"P... | [
"R : Type u\ninst✝ : CommRing R\np : R[X]\nt : R\nm : ℕ := rootMultiplicity t p\nhm : m = rootMultiplicity t p\n⊢ eval t ((⇑derivative)^[m] ((X - C t) ^ m * (p /ₘ (X - C t) ^ m))) = m ! • eval t (p /ₘ (X - C t) ^ m)"
] | conv_lhs => rw [← p.pow_mul_divByMonic_rootMultiplicity_eq t, ← hm] | Mathlib.Tactic.Conv._aux_Mathlib_Tactic_Conv___macroRules_Mathlib_Tactic_Conv_convLHS_1 | Mathlib.Tactic.Conv.convLHS |
Mathlib.Algebra.Polynomial.FieldDivision | {
"line": 210,
"column": 26
} | {
"line": 210,
"column": 31
} | {
"line": 210,
"column": 32
} | [
{
"pp": "R : Type u\nS : Type v\nk : Type y\nA : Type z\na b : R\nn : ℕ\ninst✝² : CommRing R\ninst✝¹ : NoZeroDivisors R\ninst✝ : NormalizationMonoid R\na✝ : R[X]\nu : R[X]ˣ\nh : a✝ ≠ 0\nw : Rˣ\nh2 : C ↑w = ↑u\n⊢ C ↑(normUnit (a✝.leadingCoeff * (↑u).leadingCoeff)) = ↑u⁻¹ * C ↑(normUnit a✝.leadingCoeff)",
"pp... | [
"R : Type u\nS : Type v\nk : Type y\nA : Type z\na b : R\nn : ℕ\ninst✝² : CommRing R\ninst✝¹ : NoZeroDivisors R\ninst✝ : NormalizationMonoid R\na✝ : R[X]\nu : R[X]ˣ\nh : a✝ ≠ 0\nw : Rˣ\nh2 : C ↑w = ↑u\n⊢ C ↑(normUnit (a✝.leadingCoeff * (C ↑w).leadingCoeff)) = ↑u⁻¹ * C ↑(normUnit a✝.leadingCoeff)"
] | ← h2, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.FieldDivision | {
"line": 211,
"column": 70
} | {
"line": 211,
"column": 75
} | {
"line": 211,
"column": 76
} | [
{
"pp": "R : Type u\nS : Type v\nk : Type y\nA : Type z\na b : R\nn : ℕ\ninst✝² : CommRing R\ninst✝¹ : NoZeroDivisors R\ninst✝ : NormalizationMonoid R\na✝ : R[X]\nu : R[X]ˣ\nh : a✝ ≠ 0\nw : Rˣ\nh2 : C ↑w = ↑u\n⊢ ↑u * C ↑w⁻¹ * C ↑(normUnit a✝.leadingCoeff) = C ↑(normUnit a✝.leadingCoeff)",
"ppTerm": "?m.179"... | [
"R : Type u\nS : Type v\nk : Type y\nA : Type z\na b : R\nn : ℕ\ninst✝² : CommRing R\ninst✝¹ : NoZeroDivisors R\ninst✝ : NormalizationMonoid R\na✝ : R[X]\nu : R[X]ˣ\nh : a✝ ≠ 0\nw : Rˣ\nh2 : C ↑w = ↑u\n⊢ C ↑w * C ↑w⁻¹ * C ↑(normUnit a✝.leadingCoeff) = C ↑(normUnit a✝.leadingCoeff)"
] | ← h2, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | {
"line": 199,
"column": 8
} | {
"line": 199,
"column": 35
} | {
"line": 199,
"column": 35
} | [
{
"pp": "case inl\nα : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : UniqueFactorizationMonoid α\na : α\nh : a ~ᵤ 0\n⊢ factors' a = factors' 0",
"ppTerm": "?inl",
"assigned": true,
"usedConstants": [
"congrArg",
"associated_zero_iff_eq_zero",
"Eq.mp",
"CommMonoidWithZero.t... | [
"case inl\nα : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : UniqueFactorizationMonoid α\na : α\nh : a = 0\n⊢ factors' a = factors' 0"
] | associated_zero_iff_eq_zero | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Polynomial.Content | {
"line": 355,
"column": 83
} | {
"line": 356,
"column": 52
} | {
"line": 356,
"column": 53
} | [
{
"pp": "case neg.inr\nR : Type u_1\ninst✝¹ : CommRing R\ninst✝ : NormalizedGCDMonoid R\np✝ q✝ : R[X]\na✝ : Nontrivial R\nn : ℕ\nih : ∀ (p q : R[X]), (p * q).degree < ↑n → Associated (p * q).content (p.content * q.content)\np q : R[X]\np0 : ¬p = 0\nq0 : ¬q = 0\nheq : p.primPart.degree + q.primPart.degree = ↑n\n... | [
"case neg.inr\nR : Type u_1\ninst✝¹ : CommRing R\ninst✝ : NormalizedGCDMonoid R\np✝ q✝ : R[X]\na✝ : Nontrivial R\nn : ℕ\nih : ∀ (p q : R[X]), (p * q).degree < ↑n → Associated (p * q).content (p.content * q.content)\np q : R[X]\np0 : ¬p = 0\nq0 : ¬q = 0\nheq : p.primPart.degree + q.primPart.degree = ↑n\n⊢ q.primPart... | ←
content_eq_gcd_leadingCoeff_content_eraseLead, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | {
"line": 274,
"column": 2
} | {
"line": 274,
"column": 55
} | {
"line": 275,
"column": 2
} | [
{
"pp": "α : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : UniqueFactorizationMonoid α\na b : Associates α\nh : a.factors ≤ b.factors\n⊢ a ≤ b",
"ppTerm": "?m.18",
"assigned": true,
"usedConstants": [
"CommMonoidWithZero.toCommMonoid",
"Preorder.toLE",
"CommMonoidWithZero.toMono... | [
"α : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : UniqueFactorizationMonoid α\na b : Associates α\nh : a.factors ≤ b.factors\nthis : a.factors.prod ≤ b.factors.prod\n⊢ a ≤ b"
] | have : a.factors.prod ≤ b.factors.prod := prod_mono h | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Algebra.Polynomial.FieldDivision | {
"line": 398,
"column": 2
} | {
"line": 400,
"column": 92
} | {
"line": 402,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝ : Field R\np q : R[X]\n⊢ (p / q).degree ≤ p.degree",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"NonUnitalNonAssocCommRing.toNonUnitalNonAssocCommSemiring",
"WithBot.instPreorder",
"Eq.mpr",
"Polynomial.C",
"Polynomial.div_def",
... | [] | by_cases hq : q = 0
· simp [hq]
· rw [div_def, mul_comm, degree_mul_leadingCoeff_inv _ hq]; exact degree_divByMonic_le _ _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.FieldDivision | {
"line": 398,
"column": 2
} | {
"line": 400,
"column": 92
} | {
"line": 402,
"column": 0
} | [
{
"pp": "R : Type u\ninst✝ : Field R\np q : R[X]\n⊢ (p / q).degree ≤ p.degree",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"NonUnitalNonAssocCommRing.toNonUnitalNonAssocCommSemiring",
"WithBot.instPreorder",
"Eq.mpr",
"Polynomial.C",
"Polynomial.div_def",
... | [] | by_cases hq : q = 0
· simp [hq]
· rw [div_def, mul_comm, degree_mul_leadingCoeff_inv _ hq]; exact degree_divByMonic_le _ _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.FieldDivision | {
"line": 406,
"column": 8
} | {
"line": 406,
"column": 46
} | {
"line": 406,
"column": 46
} | [
{
"pp": "R : Type u\ninst✝ : Field R\np q : R[X]\nhp : p ≠ 0\nhq : 0 < q.degree\nhq0 : q ≠ 0\n⊢ 0 < (q * C q.leadingCoeff⁻¹).degree",
"ppTerm": "?m.60",
"assigned": true,
"usedConstants": [
"WithBot.instPreorder",
"Eq.mpr",
"Polynomial.C",
"Nat.instMulZeroClass",
"WithB... | [
"R : Type u\ninst✝ : Field R\np q : R[X]\nhp : p ≠ 0\nhq : 0 < q.degree\nhq0 : q ≠ 0\n⊢ 0 < q.degree"
] | rw [degree_mul_leadingCoeff_inv _ hq0] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.RingTheory.Polynomial.UniqueFactorization | {
"line": 142,
"column": 29
} | {
"line": 142,
"column": 43
} | {
"line": 142,
"column": 44
} | [
{
"pp": "σ : Type v\nD : Type u\ninst✝¹ : CommRing D\ninst✝ : UniqueFactorizationMonoid D\nd : ℕ\ns : Finset σ\na' : MvPolynomial (↥s) D\nha : (rename Subtype.val) a' ≠ 0\nw : Multiset (MvPolynomial (↥s) D)\nh : ∀ b ∈ w, Prime b\nu : (MvPolynomial (↥s) D)ˣ\nhw : w.prod * ↑u = a'\n⊢ (rename Subtype.val) w.prod *... | [
"σ : Type v\nD : Type u\ninst✝¹ : CommRing D\ninst✝ : UniqueFactorizationMonoid D\nd : ℕ\ns : Finset σ\na' : MvPolynomial (↥s) D\nha : (rename Subtype.val) a' ≠ 0\nw : Multiset (MvPolynomial (↥s) D)\nh : ∀ b ∈ w, Prime b\nu : (MvPolynomial (↥s) D)ˣ\nhw : w.prod * ↑u = a'\n⊢ (rename Subtype.val) w.prod * ↑(rename Su... | Units.coe_map, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | {
"line": 505,
"column": 2
} | {
"line": 505,
"column": 11
} | {
"line": 506,
"column": 2
} | [
{
"pp": "α : Type u_1\ninst✝³ : CommMonoidWithZero α\ninst✝² : UniqueFactorizationMonoid α\ninst✝¹ : DecidableEq (Associates α)\ninst✝ : (p : Associates α) → Decidable (Irreducible p)\na : Associates α\nha : a ≠ 0\nb : Associates α\nhb : b ≠ 0\nhab : ∀ (d : Associates α), d ∣ a → d ∣ b → ¬Prime d\np : Associate... | [
"α : Type u_1\ninst✝³ : CommMonoidWithZero α\ninst✝² : UniqueFactorizationMonoid α\ninst✝¹ : DecidableEq (Associates α)\ninst✝ : (p : Associates α) → Decidable (Irreducible p)\na : Associates α\nha : a ≠ 0\nb : Associates α\nhb : b ≠ 0\nhab : ∀ (d : Associates α), d ∣ a → d ∣ b → ¬Prime d\np : Associates α\nhp : Ir... | intro hca | Lean.Elab.Tactic.evalIntro | null |
Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | {
"line": 505,
"column": 2
} | {
"line": 505,
"column": 11
} | {
"line": 506,
"column": 2
} | [
{
"pp": "α : Type u_1\ninst✝³ : CommMonoidWithZero α\ninst✝² : UniqueFactorizationMonoid α\ninst✝¹ : DecidableEq (Associates α)\ninst✝ : (p : Associates α) → Decidable (Irreducible p)\na : Associates α\nha : a ≠ 0\nb : Associates α\nhb : b ≠ 0\nhab : ∀ (d : Associates α), d ∣ a → d ∣ b → ¬Prime d\np : Associate... | [
"α : Type u_1\ninst✝³ : CommMonoidWithZero α\ninst✝² : UniqueFactorizationMonoid α\ninst✝¹ : DecidableEq (Associates α)\ninst✝ : (p : Associates α) → Decidable (Irreducible p)\na : Associates α\nha : a ≠ 0\nb : Associates α\nhb : b ≠ 0\nhab : ∀ (d : Associates α), d ∣ a → d ∣ b → ¬Prime d\np : Associates α\nhp : Ir... | intro hca | Lean.Elab.Tactic.evalIntro | Lean.Parser.Tactic.intro |
Mathlib.RingTheory.Algebraic.Basic | {
"line": 345,
"column": 23
} | {
"line": 345,
"column": 41
} | {
"line": 345,
"column": 41
} | [
{
"pp": "R : Type u\nS : Type u_1\ninst✝² : CommRing R\ninst✝¹ : CommRing S\ninst✝ : Algebra R S\nx : S\nhalg : IsAlgebraic (↥⊥) x\n⊢ Function.Surjective ⇑(algebraMap R ↥⊥)",
"ppTerm": "?m.49",
"assigned": true,
"usedConstants": [
"Subalgebra.instSetLike",
"Lattice.toSemilatticeSup",
... | [
"R : Type u\nS : Type u_1\ninst✝² : CommRing R\ninst✝¹ : CommRing S\ninst✝ : Algebra R S\nx : S\nhalg : IsAlgebraic (↥⊥) x\nr : R\n⊢ ∃ a, (algebraMap R ↥⊥) a = ⟨(Algebra.ofId R S).toRingHom r, ⋯⟩"
] | rintro ⟨_, r, rfl⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.RingTheory.Algebraic.Basic | {
"line": 356,
"column": 23
} | {
"line": 356,
"column": 41
} | {
"line": 356,
"column": 41
} | [
{
"pp": "R : Type u\nS : Type u_1\ninst✝³ : CommRing R\ninst✝² : CommRing S\ninst✝¹ : Algebra R S\ninst✝ : Algebra.IsAlgebraic (↥⊥) S\n⊢ Function.Surjective ⇑(algebraMap R ↥⊥)",
"ppTerm": "?m.47",
"assigned": true,
"usedConstants": [
"Subalgebra.instSetLike",
"Lattice.toSemilatticeSup",
... | [
"R : Type u\nS : Type u_1\ninst✝³ : CommRing R\ninst✝² : CommRing S\ninst✝¹ : Algebra R S\ninst✝ : Algebra.IsAlgebraic (↥⊥) S\nr : R\n⊢ ∃ a, (algebraMap R ↥⊥) a = ⟨(Algebra.ofId R S).toRingHom r, ⋯⟩"
] | rintro ⟨_, r, rfl⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.Algebra.Colimit.Module | {
"line": 273,
"column": 40
} | {
"line": 275,
"column": 15
} | {
"line": 277,
"column": 0
} | [
{
"pp": "R : Type u_1\ninst✝⁶ : Semiring R\nι : Type u_2\ninst✝⁵ : Preorder ι\nG : ι → Type u_3\ninst✝⁴ : (i : ι) → AddCommMonoid (G i)\ninst✝³ : (i : ι) → Module R (G i)\nf : (i j : ι) → i ≤ j → G i →ₗ[R] G j\ninst✝² : DecidableEq ι\ninst✝¹ : DirectedSystem G fun x1 x2 x3 ↦ ⇑(f x1 x2 x3)\ninst✝ : IsDirectedOrd... | [] | by
convert! exists_eq_of_of_eq (H.trans (map_zero <| _).symm)
rw [map_zero] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Order.DirectedInverseSystem | {
"line": 474,
"column": 49
} | {
"line": 474,
"column": 100
} | {
"line": 475,
"column": 2
} | [
{
"pp": "ι✝ : Type u_1\ninst✝³ : Preorder ι✝\nF₁ : ι✝ → Type u_2\nF₂ : ι✝ → Type u_3\nF✝ : ι✝ → Type u_4\nX✝ : ι✝ → Type u_5\nf✝ : ⦃i j : ι✝⦄ → i ≤ j → F✝ j → F✝ i\ni✝ j✝ : ι✝\nh✝ : i✝ ≤ j✝\nι : Type u_6\nF : ι → Type u_7\nX : ι → Type u_8\ni : ι\ninst✝² : LinearOrder ι\nf : ⦃i j : ι⦄ → i ≤ j → F j → F i\ninst✝... | [] | exacts [(e _).nat _ _ _, h.trans_lt (hi.mid _).2.1] | Batteries.Tactic._aux_Batteries_Tactic_Init___elabRules_Batteries_Tactic_exacts_1 | Batteries.Tactic.exacts |
Mathlib.RingTheory.MvPolynomial.Basic | {
"line": 66,
"column": 28
} | {
"line": 66,
"column": 95
} | {
"line": 68,
"column": 0
} | [
{
"pp": "σ : Type u\nR : Type v\ninst✝¹ : CommSemiring R\np m : ℕ\ninst✝ : CharZero R\nx y : ℕ\nhxy : ↑x = ↑y\n⊢ x = y",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"Finsupp.instAddZeroClass",
"NonAssocSemiring.toAddCommMonoidWithOne",
"Nat.instMulZeroClass",
"cong... | [] | by rwa [← C_eq_coe_nat, ← C_eq_coe_nat, C_inj, Nat.cast_inj] at hxy | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.BigOperators.Expect | {
"line": 305,
"column": 72
} | {
"line": 306,
"column": 41
} | {
"line": 308,
"column": 0
} | [
{
"pp": "ι : Type u_1\nM : Type u_4\ninst✝³ : AddCommMonoid M\ninst✝² : Module ℚ≥0 M\nG : Type u_6\ninst✝¹ : DistribSMul G M\ninst✝ : SMulCommClass G ℚ≥0 M\na : G\ns : Finset ι\nf : ι → M\n⊢ a • 𝔼 i ∈ s, f i = 𝔼 i ∈ s, a • f i",
"ppTerm": "?m.31",
"assigned": true,
"usedConstants": [
"NonAss... | [] | by
simp only [expect, smul_sum, smul_comm] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.BigOperators.ModEq | {
"line": 31,
"column": 18
} | {
"line": 31,
"column": 46
} | {
"line": 33,
"column": 0
} | [
{
"pp": "case nil\nα : Type u_1\nn : ℕ\nl : List α\nf g : α → ℕ\nh : ∀ x ∈ [], f x ≡ g x [MOD n]\n⊢ (List.map f []).prod ≡ (List.map g []).prod [MOD n]",
"ppTerm": "?nil",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.instOne",
"congrArg",
"List.map",
"id",
... | [] | aesop (add unsafe ModEq.mul) | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.Algebra.BigOperators.ModEq | {
"line": 31,
"column": 18
} | {
"line": 31,
"column": 46
} | {
"line": 33,
"column": 0
} | [
{
"pp": "case cons\nα : Type u_1\nn : ℕ\nl : List α\nf g : α → ℕ\nhead✝ : α\ntail✝ : List α\ntail_ih✝ : (∀ x ∈ tail✝, f x ≡ g x [MOD n]) → (List.map f tail✝).prod ≡ (List.map g tail✝).prod [MOD n]\nh : ∀ x ∈ head✝ :: tail✝, f x ≡ g x [MOD n]\n⊢ (List.map f (head✝ :: tail✝)).prod ≡ (List.map g (head✝ :: tail✝)).... | [] | aesop (add unsafe ModEq.mul) | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.Algebra.BigOperators.ModEq | {
"line": 124,
"column": 18
} | {
"line": 124,
"column": 46
} | {
"line": 126,
"column": 0
} | [
{
"pp": "case nil\nα : Type u_1\nn : ℤ\nl : List α\nf g : α → ℤ\nh : ∀ x ∈ [], f x ≡ g x [ZMOD n]\n⊢ (List.map f []).prod ≡ (List.map g []).prod [ZMOD n]",
"ppTerm": "?nil",
"assigned": true,
"usedConstants": [
"congrArg",
"List.map",
"AddGroupWithOne.toAddMonoidWithOne",
"In... | [] | aesop (add unsafe ModEq.mul) | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.Algebra.BigOperators.ModEq | {
"line": 124,
"column": 18
} | {
"line": 124,
"column": 46
} | {
"line": 126,
"column": 0
} | [
{
"pp": "case cons\nα : Type u_1\nn : ℤ\nl : List α\nf g : α → ℤ\nhead✝ : α\ntail✝ : List α\ntail_ih✝ : (∀ x ∈ tail✝, f x ≡ g x [ZMOD n]) → (List.map f tail✝).prod ≡ (List.map g tail✝).prod [ZMOD n]\nh : ∀ x ∈ head✝ :: tail✝, f x ≡ g x [ZMOD n]\n⊢ (List.map f (head✝ :: tail✝)).prod ≡ (List.map g (head✝ :: tail✝... | [] | aesop (add unsafe ModEq.mul) | Aesop.evalAesop | Aesop.Frontend.Parser.aesopTactic |
Mathlib.Data.Finset.Sym | {
"line": 118,
"column": 2
} | {
"line": 118,
"column": 13
} | {
"line": 118,
"column": 13
} | [
{
"pp": "α : Type u_1\ns : Finset α\n⊢ s.sym2.Nonempty ↔ s.Nonempty",
"ppTerm": "?m.4",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Mathlib.Tactic.Contrapose.contrapose_iff₁",
"congrArg",
"Finset",
"id",
"Finset.instEmptyCollection",
"Iff",
"congr"... | [
"α : Type u_1\ns : Finset α\n⊢ s.sym2 = ∅ ↔ s = ∅"
] | contrapose! | Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___macroRules_Mathlib_Tactic_Contrapose_contrapose!_1 | Mathlib.Tactic.Contrapose.contrapose! |
Mathlib.Data.Finset.Sym | {
"line": 188,
"column": 4
} | {
"line": 188,
"column": 27
} | {
"line": 189,
"column": 4
} | [
{
"pp": "case succ.refine_1\nα : Type u_1\ns : Finset α\ninst✝ : DecidableEq α\nn✝ n : ℕ\nih : ∀ {m : Sym α n}, m ∈ s.sym n ↔ ∀ a ∈ m, a ∈ s\na : α\nha : a ∈ s\nb : α\nm : Sym α n\nhe : m ∈ s.sym n\nhb : b ∈ a ::ₛ m\n⊢ b ∈ s",
"ppTerm": "?succ.refine_1",
"assigned": true,
"usedConstants": [
"c... | [
"case succ.refine_1\nα : Type u_1\ns : Finset α\ninst✝ : DecidableEq α\nn✝ n : ℕ\nih : ∀ {m : Sym α n}, m ∈ s.sym n ↔ ∀ a ∈ m, a ∈ s\na : α\nha : a ∈ s\nb : α\nm : Sym α n\nhe : m ∈ s.sym n\nhb : b = a ∨ b ∈ m\n⊢ b ∈ s"
] | rw [Sym.mem_cons] at hb | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.Data.Finset.Sym | {
"line": 245,
"column": 2
} | {
"line": 245,
"column": 13
} | {
"line": 245,
"column": 13
} | [
{
"pp": "α : Type u_1\ns : Finset α\ninst✝ : DecidableEq α\nn : ℕ\n⊢ (s.sym n).Nonempty ↔ n = 0 ∨ s.Nonempty",
"ppTerm": "?m.8",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Mathlib.Tactic.Contrapose.contrapose_iff₁",
"congrArg",
"Finset",
"id",
"Ne",
"in... | [
"α : Type u_1\ns : Finset α\ninst✝ : DecidableEq α\nn : ℕ\n⊢ s.sym n = ∅ ↔ n ≠ 0 ∧ s = ∅"
] | contrapose! | Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___macroRules_Mathlib_Tactic_Contrapose_contrapose!_1 | Mathlib.Tactic.Contrapose.contrapose! |
Mathlib.Data.Sym.Sym2 | {
"line": 698,
"column": 17
} | {
"line": 700,
"column": 7
} | {
"line": 702,
"column": 0
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nγ : Type u_3\nz✝ : Sym2 α\nf✝ : α → β\nr r₁ r₂ : α → α → Prop\nsym : Std.Symm r\nf : α → β\nhf : r ≤ ⇑(Setoid.ker f)\nz : (b : β) × ↑(fromRel ⋯)\n⊢ (fun z ↦ fromRelNdrec ↑z ⋯ (fun a₁ a₂ h ↦ ⟨f a₁, ⟨s(⟨a₁, ⋯⟩, ⟨a₂, ⋯⟩), h⟩⟩) ⋯)\n ((fun z ↦ ⟨map Subtype.val ↑z.snd, ⋯⟩) z)... | [] | by
rcases z with ⟨b, ⟨⟨a₁, rfl⟩, ⟨a₂, ha₂⟩⟩, h⟩
rfl | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.ObjectProperty.Basic | {
"line": 139,
"column": 4
} | {
"line": 139,
"column": 28
} | {
"line": 140,
"column": 2
} | [
{
"pp": "case mp\nC : Type u\ninst✝ : CategoryStruct.{v, u} C\nX Y Z : C\n⊢ pair X Y Z → X = Z ∨ Y = Z",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"CategoryTheory.ObjectProperty.ofObj.casesOn",
"CategoryTheory.ObjectProperty.ofObj",
"CategoryTheory.Obje... | [] | rintro ⟨_ | _⟩ <;> tauto | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.CategoryTheory.ObjectProperty.Basic | {
"line": 139,
"column": 4
} | {
"line": 139,
"column": 28
} | {
"line": 140,
"column": 2
} | [
{
"pp": "case mp\nC : Type u\ninst✝ : CategoryStruct.{v, u} C\nX Y Z : C\n⊢ pair X Y Z → X = Z ∨ Y = Z",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"CategoryTheory.ObjectProperty.ofObj.casesOn",
"CategoryTheory.ObjectProperty.ofObj",
"CategoryTheory.Obje... | [] | rintro ⟨_ | _⟩ <;> tauto | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.ObjectProperty.Basic | {
"line": 139,
"column": 4
} | {
"line": 139,
"column": 28
} | {
"line": 140,
"column": 2
} | [
{
"pp": "case mp\nC : Type u\ninst✝ : CategoryStruct.{v, u} C\nX Y Z : C\n⊢ pair X Y Z → X = Z ∨ Y = Z",
"ppTerm": "?mp",
"assigned": true,
"usedConstants": [
"Iff.mpr",
"CategoryTheory.ObjectProperty.ofObj.casesOn",
"CategoryTheory.ObjectProperty.ofObj",
"CategoryTheory.Obje... | [] | rintro ⟨_ | _⟩ <;> tauto | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.Quiver.Path | {
"line": 122,
"column": 2
} | {
"line": 122,
"column": 19
} | {
"line": 123,
"column": 2
} | [
{
"pp": "V : Type u\ninst✝ : Quiver V\na b c : V\np₁ p₂ : Path a b\nq₁ q₂ : Path b c\nhq : q₁.length = q₂.length\nh : p₁.comp q₁ = p₂.comp q₂\n⊢ p₁ = p₂ ∧ q₁ = q₂",
"ppTerm": "?m.35",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Quiver.Hom",
"Quiver.Path.nil",
"congrArg",
... | [] | induction q₁ with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Combinatorics.Quiver.Symmetric | {
"line": 148,
"column": 4
} | {
"line": 149,
"column": 7
} | {
"line": 151,
"column": 0
} | [
{
"pp": "case cons\nV : Type u_2\ninst✝ : Quiver V\nh✝ : HasInvolutiveReverse V\na b b✝ c✝ : V\na✝¹ : Path a b✝\na✝ : b✝ ⟶ c✝\nh : a✝¹.reverse.reverse = a✝¹\n⊢ (a✝¹.cons a✝).reverse.reverse = a✝¹.cons a✝",
"ppTerm": "?cons",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Quiver.Hom",
... | [] | rw [Path.reverse, Path.reverse_comp, h, Path.reverse_toPath, Quiver.reverse_reverse]
rfl | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Combinatorics.Quiver.Symmetric | {
"line": 148,
"column": 4
} | {
"line": 149,
"column": 7
} | {
"line": 151,
"column": 0
} | [
{
"pp": "case cons\nV : Type u_2\ninst✝ : Quiver V\nh✝ : HasInvolutiveReverse V\na b b✝ c✝ : V\na✝¹ : Path a b✝\na✝ : b✝ ⟶ c✝\nh : a✝¹.reverse.reverse = a✝¹\n⊢ (a✝¹.cons a✝).reverse.reverse = a✝¹.cons a✝",
"ppTerm": "?cons",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Quiver.Hom",
... | [] | rw [Path.reverse, Path.reverse_comp, h, Path.reverse_toPath, Quiver.reverse_reverse]
rfl | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Whiskering | {
"line": 103,
"column": 52
} | {
"line": 103,
"column": 73
} | {
"line": 103,
"column": 73
} | [
{
"pp": "C : Type u₁\ninst✝² : Category.{v₁, u₁} C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\nE : Type u₃\ninst✝ : Category.{v₃, u₃} E\nX✝ Y✝ : D ⥤ E\nτ : X✝ ⟶ Y✝\nX Y : C ⥤ D\nf : X ⟶ Y\nx✝ : C\n⊢ X✝.map (f.app x✝) ≫ τ.app (Y.obj x✝) = τ.app (X.obj x✝) ≫ Y✝.map (f.app x✝)",
"ppTerm": "?m.117",
"assign... | [
"C : Type u₁\ninst✝² : Category.{v₁, u₁} C\nD : Type u₂\ninst✝¹ : Category.{v₂, u₂} D\nE : Type u₃\ninst✝ : Category.{v₃, u₃} E\nX✝ Y✝ : D ⥤ E\nτ : X✝ ⟶ Y✝\nX Y : C ⥤ D\nf : X ⟶ Y\nx✝ : C\n⊢ X✝.map (f.app x✝) ≫ τ.app (Y.obj x✝) = X✝.map (f.app x✝) ≫ τ.app (Y.obj x✝)"
] | ← NatTrans.naturality | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Opposites | {
"line": 192,
"column": 35
} | {
"line": 192,
"column": 40
} | {
"line": 192,
"column": 40
} | [
{
"pp": "C : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\nX Y : C\nf : X ⟶ Y\ninst✝ : IsIso f\n⊢ (𝟙 Y).op = 𝟙 (op Y)",
"ppTerm": "?m.49",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Opposite",
"Quiver.opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
... | [
"C : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\nX Y : C\nf : X ⟶ Y\ninst✝ : IsIso f\n⊢ 𝟙 (op Y) = 𝟙 (op Y)"
] | op_id | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.EpiMono | {
"line": 161,
"column": 2
} | {
"line": 161,
"column": 52
} | {
"line": 162,
"column": 2
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nall_split_mono : ∀ {X Y : C} (f : X ⟶ Y), Trunc (IsSplitMono f)\nX Y : C\nf : X ⟶ Y\n⊢ IsIso f",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"Trunc.exists_rep",
"CategoryTheory.IsIso",
"Exists",
"Trunc.mk",
... | [
"C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nall_split_mono : ∀ {X Y : C} (f : X ⟶ Y), Trunc (IsSplitMono f)\nX Y : C\nf : X ⟶ Y\na : IsSplitMono f\nh✝ : ⋯ = ⋯\n⊢ IsIso f"
] | have ⟨a,_⟩ := Trunc.exists_rep <| all_split_mono f | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.CategoryTheory.Limits.IsLimit | {
"line": 764,
"column": 4
} | {
"line": 764,
"column": 24
} | {
"line": 765,
"column": 4
} | [
{
"pp": "case e_8\nJ : Type u₁\ninst✝² : Category.{v₁, u₁} J\nK : Type u₂\ninst✝¹ : Category.{v₂, u₂} K\nC : Type u₃\ninst✝ : Category.{v₃, u₃} C\nF : J ⥤ C\nt : Cocone F\nX : C\nh : F.cocones.CorepresentableBy X\ns : Cocone F\nm : (colimitCocone h).pt ⟶ s.pt\nw : ∀ (j : J), (colimitCocone h).ι.app j ≫ m = s.ι.... | [
"case e_8\nJ : Type u₁\ninst✝² : Category.{v₁, u₁} J\nK : Type u₂\ninst✝¹ : Category.{v₂, u₂} K\nC : Type u₃\ninst✝ : Category.{v₃, u₃} C\nF : J ⥤ C\nt : Cocone F\nX : C\nh : F.cocones.CorepresentableBy X\ns : Cocone F\nm : (colimitCocone h).pt ⟶ s.pt\nw : ∀ (j : J), (colimitCocone h).ι.app j ≫ m = s.ι.app j\n⊢ (co... | rw [coconeOfHom_fac] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Bicategory.Basic | {
"line": 189,
"column": 41
} | {
"line": 189,
"column": 95
} | {
"line": 191,
"column": 0
} | [
{
"pp": "B : Type u\ninst✝ : Bicategory B\na b c : B\nf : a ⟶ b\ng h : b ⟶ c\nη : g ≅ h\n⊢ f ◁ η.inv ≫ f ◁ η.hom = 𝟙 (f ≫ h)",
"ppTerm": "?m.44",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Iso.inv_hom_id",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver... | [] | by rw [← whiskerLeft_comp, inv_hom_id, whiskerLeft_id] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Yoneda | {
"line": 362,
"column": 2
} | {
"line": 362,
"column": 21
} | {
"line": 363,
"column": 2
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nF : Cᵒᵖ ⥤ Type v\nY : C\ne e' : F.RepresentableBy Y\nh : e.homEquiv (𝟙 Y) = e'.homEquiv (𝟙 Y)\nthis : ∀ {X : C} (f : X ⟶ Y), e.homEquiv f = e'.homEquiv f\n⊢ e = e'",
"ppTerm": "?m.45",
"assigned": true,
"usedConstants": [
"Opposite",
"... | [
"C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nF : Cᵒᵖ ⥤ Type v\nY : C\ne' : F.RepresentableBy Y\ne : {X : C} → (X ⟶ Y) ≃ F.obj (op X)\nhe : ∀ {X X' : C} (f : X ⟶ X') (g : X' ⟶ Y), e (f ≫ g) = (ConcreteCategory.hom (F.map f.op)) (e g)\nh : { homEquiv := e, homEquiv_comp := he }.homEquiv (𝟙 Y) = e'.homEquiv (𝟙 Y)\nthi... | obtain ⟨e, he⟩ := e | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.CategoryTheory.Yoneda | {
"line": 372,
"column": 2
} | {
"line": 372,
"column": 21
} | {
"line": 373,
"column": 2
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nF : C ⥤ Type v\nX : C\ne e' : F.CorepresentableBy X\nh : e.homEquiv (𝟙 X) = e'.homEquiv (𝟙 X)\nthis : ∀ {Y : C} (f : X ⟶ Y), e.homEquiv f = e'.homEquiv f\n⊢ e = e'",
"ppTerm": "?m.45",
"assigned": true,
"usedConstants": [
"Equiv.instEquivLik... | [
"C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nF : C ⥤ Type v\nX : C\ne' : F.CorepresentableBy X\ne : {Y : C} → (X ⟶ Y) ≃ F.obj Y\nhe : ∀ {Y Y' : C} (g : Y ⟶ Y') (f : X ⟶ Y), e (f ≫ g) = (ConcreteCategory.hom (F.map g)) (e f)\nh : { homEquiv := e, homEquiv_comp := he }.homEquiv (𝟙 X) = e'.homEquiv (𝟙 X)\nthis : ∀ {Y ... | obtain ⟨e, he⟩ := e | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.CategoryTheory.Yoneda | {
"line": 791,
"column": 2
} | {
"line": 791,
"column": 45
} | {
"line": 792,
"column": 2
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nX Y : Cᵒᵖ\nf : X ⟶ Y\nF : Cᵒᵖ ⥤ Type v₁\nt : F.obj X\n⊢ yonedaEquiv.symm ((ConcreteCategory.hom (F.map f)) t) = yoneda.map f.unop ≫ yonedaEquiv.symm t",
"ppTerm": "?m.48",
"assigned": true,
"usedConstants": [
"CategoryTheory.Functor",
"O... | [
"C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nX Y : Cᵒᵖ\nf : X ⟶ Y\nF : Cᵒᵖ ⥤ Type v₁\nu : yoneda.obj (unop X) ⟶ F\n⊢ yonedaEquiv.symm ((ConcreteCategory.hom (F.map f)) (yonedaEquiv u)) =\n yoneda.map f.unop ≫ yonedaEquiv.symm (yonedaEquiv u)"
] | obtain ⟨u, rfl⟩ := yonedaEquiv.surjective t | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.CategoryTheory.Yoneda | {
"line": 1149,
"column": 2
} | {
"line": 1152,
"column": 59
} | {
"line": 1154,
"column": 0
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nX Y : C\nf : X ⟶ Y\n⊢ IsIso f ↔ ∀ (T : C), Function.Bijective fun x ↦ f ≫ x",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"CategoryTheory.isIso_of_coyoneda_map_bijective",
"CategoryTheory.IsIso",
"Catego... | [] | refine ⟨fun _ ↦ ?_, fun hf ↦ isIso_of_coyoneda_map_bijective f hf⟩
intro T
rw [bijective_iff_isIso_ofHom]
exact inferInstanceAs (IsIso ((coyoneda.map f.op).app _)) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Yoneda | {
"line": 1149,
"column": 2
} | {
"line": 1152,
"column": 59
} | {
"line": 1154,
"column": 0
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nX Y : C\nf : X ⟶ Y\n⊢ IsIso f ↔ ∀ (T : C), Function.Bijective fun x ↦ f ≫ x",
"ppTerm": "?m.20",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"CategoryTheory.isIso_of_coyoneda_map_bijective",
"CategoryTheory.IsIso",
"Catego... | [] | refine ⟨fun _ ↦ ?_, fun hf ↦ isIso_of_coyoneda_map_bijective f hf⟩
intro T
rw [bijective_iff_isIso_ofHom]
exact inferInstanceAs (IsIso ((coyoneda.map f.op).app _)) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Cones | {
"line": 282,
"column": 90
} | {
"line": 283,
"column": 33
} | {
"line": 285,
"column": 0
} | [
{
"pp": "J : Type u₁\ninst✝¹ : Category.{v₁, u₁} J\nC : Type u₃\ninst✝ : Category.{v₃, u₃} C\nF : J ⥤ C\nc d : Cone F\nf : c ≅ d\n⊢ f.hom.hom ≫ f.inv.hom = 𝟙 c.pt",
"ppTerm": "?m.44",
"assigned": true,
"usedConstants": [
"CategoryTheory.Limits.Cone",
"CategoryTheory.CategoryStruct.toQui... | [] | by
simp [← Cone.category_comp_hom] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Cones | {
"line": 286,
"column": 90
} | {
"line": 287,
"column": 33
} | {
"line": 289,
"column": 0
} | [
{
"pp": "J : Type u₁\ninst✝¹ : Category.{v₁, u₁} J\nC : Type u₃\ninst✝ : Category.{v₃, u₃} C\nF : J ⥤ C\nc d : Cone F\nf : c ≅ d\n⊢ f.inv.hom ≫ f.hom.hom = 𝟙 d.pt",
"ppTerm": "?m.44",
"assigned": true,
"usedConstants": [
"CategoryTheory.Limits.Cone",
"CategoryTheory.Iso.inv_hom_id",
... | [] | by
simp [← Cone.category_comp_hom] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 226,
"column": 8
} | {
"line": 226,
"column": 21
} | {
"line": 226,
"column": 21
} | [
{
"pp": "case right\nC : Type u\ninst✝ : Category.{v, u} C\nX Y : C\ns : BinaryFan X Y\nlift : {T : C} → (T ⟶ X) → (T ⟶ Y) → (T ⟶ s.pt)\nhl₁ : ∀ {T : C} (f : T ⟶ X) (g : T ⟶ Y), lift f g ≫ s.fst = f\nhl₂ : ∀ {T : C} (f : T ⟶ X) (g : T ⟶ Y), lift f g ≫ s.snd = g\nuniq : ∀ {T : C} (f : T ⟶ X) (g : T ⟶ Y) (m : T ⟶... | [] | exact hl₂ _ _ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 226,
"column": 8
} | {
"line": 226,
"column": 21
} | {
"line": 226,
"column": 21
} | [
{
"pp": "case right\nC : Type u\ninst✝ : Category.{v, u} C\nX Y : C\ns : BinaryFan X Y\nlift : {T : C} → (T ⟶ X) → (T ⟶ Y) → (T ⟶ s.pt)\nhl₁ : ∀ {T : C} (f : T ⟶ X) (g : T ⟶ Y), lift f g ≫ s.fst = f\nhl₂ : ∀ {T : C} (f : T ⟶ X) (g : T ⟶ Y), lift f g ≫ s.snd = g\nuniq : ∀ {T : C} (f : T ⟶ X) (g : T ⟶ Y) (m : T ⟶... | [] | exact hl₂ _ _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {
"line": 226,
"column": 8
} | {
"line": 226,
"column": 21
} | {
"line": 226,
"column": 21
} | [
{
"pp": "case right\nC : Type u\ninst✝ : Category.{v, u} C\nX Y : C\ns : BinaryFan X Y\nlift : {T : C} → (T ⟶ X) → (T ⟶ Y) → (T ⟶ s.pt)\nhl₁ : ∀ {T : C} (f : T ⟶ X) (g : T ⟶ Y), lift f g ≫ s.fst = f\nhl₂ : ∀ {T : C} (f : T ⟶ X) (g : T ⟶ Y), lift f g ≫ s.snd = g\nuniq : ∀ {T : C} (f : T ⟶ X) (g : T ⟶ Y) (m : T ⟶... | [] | exact hl₂ _ _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | {
"line": 180,
"column": 8
} | {
"line": 180,
"column": 51
} | {
"line": 181,
"column": 8
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nW X Y Z : C\nf : X ⟶ Z\ng : Y ⟶ Z\nt : PullbackCone f g\nlift : (s : PullbackCone f g) → s.pt ⟶ t.pt\nfac_left : ∀ (s : PullbackCone f g), lift s ≫ t.fst = s.fst\nfac_right : ∀ (s : PullbackCone f g), lift s ≫ t.snd = s.snd\nuniq : ∀ (s : PullbackCone f g) (m : s.... | [
"C : Type u\ninst✝ : Category.{v, u} C\nW X Y Z : C\nf : X ⟶ Z\ng : Y ⟶ Z\nt : PullbackCone f g\nlift : (s : PullbackCone f g) → s.pt ⟶ t.pt\nfac_left : ∀ (s : PullbackCone f g), lift s ≫ t.fst = s.fst\nfac_right : ∀ (s : PullbackCone f g), lift s ≫ t.snd = s.snd\nuniq : ∀ (s : PullbackCone f g) (m : s.pt ⟶ t.pt), ... | rw [← s.w inl, ← t.w inl, ← Category.assoc] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {
"line": 121,
"column": 4
} | {
"line": 121,
"column": 35
} | {
"line": 122,
"column": 4
} | [
{
"pp": "X✝ Y✝ : WalkingParallelPair\nf : X✝ ⟶ Y✝\n⊢ op\n (match X✝ with\n | zero => one\n | one => zero) ⟶\n op\n (match Y✝ with\n | zero => one\n | one => zero)",
"ppTerm": "?m.19",
"assigned": true,
"usedConstants": [
"Opposite",
"CategoryTheory.Catego... | [
"case left\n⊢ (match one with\n | zero => one\n | one => zero) ⟶\n match zero with\n | zero => one\n | one => zero",
"case right\n⊢ (match one with\n | zero => one\n | one => zero) ⟶\n match zero with\n | zero => one\n | one => zero",
"case id\nX✝ : WalkingParallelPair\n⊢ (match X✝... | cases f <;> apply Quiver.Hom.op | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | {
"line": 636,
"column": 6
} | {
"line": 636,
"column": 54
} | {
"line": 638,
"column": 0
} | [
{
"pp": "case h₁\nC : Type u\ninst✝³ : Category.{v, u} C\nW X✝ Y✝ Z✝ X Y : C\nf : X ⟶ Y\nZ : C\ninst✝² : HasBinaryProduct Y Z\ninst✝¹ : HasBinaryProduct X Z\ninst✝ : HasPullback f prod.fst\n⊢ (prod.lift (pullback.fst f prod.fst) (pullback.snd f prod.fst ≫ prod.snd) ≫\n pullback.lift prod.fst (prod.map f ... | [] | apply prod.hom_ext <;> simp [pullback.condition] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | {
"line": 636,
"column": 6
} | {
"line": 636,
"column": 54
} | {
"line": 638,
"column": 0
} | [
{
"pp": "case h₁\nC : Type u\ninst✝³ : Category.{v, u} C\nW X✝ Y✝ Z✝ X Y : C\nf : X ⟶ Y\nZ : C\ninst✝² : HasBinaryProduct Y Z\ninst✝¹ : HasBinaryProduct X Z\ninst✝ : HasPullback f prod.fst\n⊢ (prod.lift (pullback.fst f prod.fst) (pullback.snd f prod.fst ≫ prod.snd) ≫\n pullback.lift prod.fst (prod.map f ... | [] | apply prod.hom_ext <;> simp [pullback.condition] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | {
"line": 636,
"column": 6
} | {
"line": 636,
"column": 54
} | {
"line": 638,
"column": 0
} | [
{
"pp": "case h₁\nC : Type u\ninst✝³ : Category.{v, u} C\nW X✝ Y✝ Z✝ X Y : C\nf : X ⟶ Y\nZ : C\ninst✝² : HasBinaryProduct Y Z\ninst✝¹ : HasBinaryProduct X Z\ninst✝ : HasPullback f prod.fst\n⊢ (prod.lift (pullback.fst f prod.fst) (pullback.snd f prod.fst ≫ prod.snd) ≫\n pullback.lift prod.fst (prod.map f ... | [] | apply prod.hom_ext <;> simp [pullback.condition] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | {
"line": 686,
"column": 6
} | {
"line": 686,
"column": 54
} | {
"line": 687,
"column": 4
} | [
{
"pp": "case h₀\nC : Type u\ninst✝³ : Category.{v, u} C\nW X✝ Y✝ Z✝ X Y : C\nf : X ⟶ Y\nZ : C\ninst✝² : HasBinaryProduct Z Y\ninst✝¹ : HasBinaryProduct Z X\ninst✝ : HasPullback prod.snd f\n⊢ (prod.lift (pullback.fst prod.snd f ≫ prod.fst) (pullback.snd prod.snd f) ≫\n pullback.lift (prod.map (𝟙 Z) f) p... | [] | apply prod.hom_ext <;> simp [pullback.condition] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | {
"line": 686,
"column": 6
} | {
"line": 686,
"column": 54
} | {
"line": 687,
"column": 4
} | [
{
"pp": "case h₀\nC : Type u\ninst✝³ : Category.{v, u} C\nW X✝ Y✝ Z✝ X Y : C\nf : X ⟶ Y\nZ : C\ninst✝² : HasBinaryProduct Z Y\ninst✝¹ : HasBinaryProduct Z X\ninst✝ : HasPullback prod.snd f\n⊢ (prod.lift (pullback.fst prod.snd f ≫ prod.fst) (pullback.snd prod.snd f) ≫\n pullback.lift (prod.map (𝟙 Z) f) p... | [] | apply prod.hom_ext <;> simp [pullback.condition] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | {
"line": 686,
"column": 6
} | {
"line": 686,
"column": 54
} | {
"line": 687,
"column": 4
} | [
{
"pp": "case h₀\nC : Type u\ninst✝³ : Category.{v, u} C\nW X✝ Y✝ Z✝ X Y : C\nf : X ⟶ Y\nZ : C\ninst✝² : HasBinaryProduct Z Y\ninst✝¹ : HasBinaryProduct Z X\ninst✝ : HasPullback prod.snd f\n⊢ (prod.lift (pullback.fst prod.snd f ≫ prod.fst) (pullback.snd prod.snd f) ≫\n pullback.lift (prod.map (𝟙 Z) f) p... | [] | apply prod.hom_ext <;> simp [pullback.condition] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | {
"line": 159,
"column": 49
} | {
"line": 159,
"column": 72
} | {
"line": 159,
"column": 72
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nX Y Z : C\nf : X ⟶ Y\ng : X ⟶ Z\ninst✝ : IsIso f\ns : PushoutCocone f g\n⊢ (pushoutCoconeOfLeftIso f g).inl ≫ s.inr = s.inl ∧\n (pushoutCoconeOfLeftIso f g).inr ≫ s.inr = s.inr ∧\n ∀ {m : (pushoutCoconeOfLeftIso f g).pt ⟶ s.pt},\n (pushoutCoconeOfL... | [] | by simp [← s.condition] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | {
"line": 211,
"column": 49
} | {
"line": 211,
"column": 72
} | {
"line": 211,
"column": 72
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nX Y Z : C\nf : X ⟶ Y\ng : X ⟶ Z\ninst✝ : IsIso g\ns : PushoutCocone f g\n⊢ (pushoutCoconeOfRightIso f g).inl ≫ s.inl = s.inl ∧\n (pushoutCoconeOfRightIso f g).inr ≫ s.inl = s.inr ∧\n ∀ {m : (pushoutCoconeOfRightIso f g).pt ⟶ s.pt},\n (pushoutCocone... | [] | by simp [← s.condition] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.Mono | {
"line": 272,
"column": 47
} | {
"line": 272,
"column": 56
} | {
"line": 272,
"column": 57
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nW X Y Z : C\nf✝ : X ⟶ Y\ng✝ : X ⟶ Z\nf : X ⟶ Y\ng : X ⟶ Z\nh : X ⟶ W\ninst✝ : Epi h\nx : W ⟶ Y\ny : W ⟶ Z\nhhx : h ≫ x = f\nhhy : h ≫ y = g\ns : PushoutCocone f g\nhs : IsColimit s\nreassoc₁ : h ≫ x ≫ s.inl = f ≫ s.inl\nreassoc₂ : h ≫ y ≫ s.inr = g ≫ s.inr\n⊢ f ≫... | [
"C : Type u\ninst✝¹ : Category.{v, u} C\nW X Y Z : C\nf✝ : X ⟶ Y\ng✝ : X ⟶ Z\nf : X ⟶ Y\ng : X ⟶ Z\nh : X ⟶ W\ninst✝ : Epi h\nx : W ⟶ Y\ny : W ⟶ Z\nhhx : h ≫ x = f\nhhy : h ≫ y = g\ns : PushoutCocone f g\nhs : IsColimit s\nreassoc₁ : h ≫ x ≫ s.inl = f ≫ s.inl\nreassoc₂ : h ≫ y ≫ s.inr = g ≫ s.inr\n⊢ f ≫ s.inl = g ≫... | reassoc₂, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Limits.Preserves.Basic | {
"line": 232,
"column": 4
} | {
"line": 232,
"column": 56
} | {
"line": 233,
"column": 4
} | [
{
"pp": "C : Type u₁\ninst✝³ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝² : Category.{v₂, u₂} D\nJ : Type w\ninst✝¹ : Category.{w', w} J\nK₁ K₂ : J ⥤ C\nF : C ⥤ D\nh : K₁ ≅ K₂\ninst✝ : PreservesLimit K₁ F\nc : Cone K₂\nt : IsLimit c\nthis : IsLimit ((Cone.postcompose h.inv).obj c)\n⊢ IsLimit ((Cone.postcompose (F... | [
"C : Type u₁\ninst✝³ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝² : Category.{v₂, u₂} D\nJ : Type w\ninst✝¹ : Category.{w', w} J\nK₁ K₂ : J ⥤ C\nF : C ⥤ D\nh : K₁ ≅ K₂\ninst✝ : PreservesLimit K₁ F\nc : Cone K₂\nt : IsLimit c\nthis : IsLimit ((Cone.postcompose h.inv).obj c)\n⊢ F.mapCone ((Cone.postcompose h.inv).obj c... | apply IsLimit.ofIsoLimit (isLimitOfPreserves F this) | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.CategoryTheory.Preadditive.Basic | {
"line": 322,
"column": 25
} | {
"line": 322,
"column": 39
} | {
"line": 322,
"column": 40
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : Preadditive C\nX Y : C\nf g : X ⟶ Y\nc : KernelFork (f - g)\n⊢ Fork.ι c ≫ f = Fork.ι c ≫ g",
"ppTerm": "?m.33",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"CategoryTheory.CategoryStruct.toQ... | [
"C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : Preadditive C\nX Y : C\nf g : X ⟶ Y\nc : KernelFork (f - g)\n⊢ Fork.ι c ≫ f - Fork.ι c ≫ g = 0"
] | ← sub_eq_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Preadditive.Basic | {
"line": 378,
"column": 27
} | {
"line": 378,
"column": 41
} | {
"line": 378,
"column": 42
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : Preadditive C\nX Y : C\nf g : X ⟶ Y\nc : CokernelCofork (f - g)\n⊢ f ≫ Cofork.π c = g ≫ Cofork.π c",
"ppTerm": "?m.33",
"assigned": true,
"usedConstants": [
"AddGroup.toSubtractionMonoid",
"Eq.mpr",
"CategoryTheory.CategorySt... | [
"C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : Preadditive C\nX Y : C\nf g : X ⟶ Y\nc : CokernelCofork (f - g)\n⊢ f ≫ Cofork.π c - g ≫ Cofork.π c = 0"
] | ← sub_eq_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits | {
"line": 179,
"column": 8
} | {
"line": 179,
"column": 24
} | {
"line": 180,
"column": 6
} | [
{
"pp": "case pos\nC : Type u\ninst✝ : Category.{v, u} C\nJ : Type v\nj : WidePullbackShape J\nj' : J\nh : some j' = j\n⊢ Finset (j ⟶ j)",
"ppTerm": "?pos✝",
"assigned": true,
"usedConstants": [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"Finset",
"CategoryTheory... | [] | exact {Hom.id j} | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.Group.Ext | {
"line": 102,
"column": 64
} | {
"line": 106,
"column": 46
} | {
"line": 108,
"column": 0
} | [
{
"pp": "M : Type u\n⊢ Injective (@toRightCancelMonoid M)",
"ppTerm": "?m.3",
"assigned": true,
"usedConstants": [
"Monoid",
"CancelMonoid.toRightCancelMonoid",
"HMul.hMul",
"Monoid.toMulOneClass",
"congrArg",
"MulOne.toMul",
"CancelMonoid.ext",
"Right... | [] | by
intro m₁ m₂ h
apply CancelMonoid.ext
exact congrArg (fun m : Monoid M => (letI := m; HMul.hMul : M → M → M)) <|
congrArg (@RightCancelMonoid.toMonoid M) h | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.Kernels | {
"line": 86,
"column": 2
} | {
"line": 86,
"column": 49
} | {
"line": 88,
"column": 0
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : HasZeroMorphisms C\nX Y : C\nf : X ⟶ Y\ns : KernelFork f\n⊢ Fork.ι s ≫ f = 0",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Li... | [] | rw [Fork.condition, HasZeroMorphisms.comp_zero] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Limits.Shapes.Kernels | {
"line": 86,
"column": 2
} | {
"line": 86,
"column": 49
} | {
"line": 88,
"column": 0
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : HasZeroMorphisms C\nX Y : C\nf : X ⟶ Y\ns : KernelFork f\n⊢ Fork.ι s ≫ f = 0",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Li... | [] | rw [Fork.condition, HasZeroMorphisms.comp_zero] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Kernels | {
"line": 86,
"column": 2
} | {
"line": 86,
"column": 49
} | {
"line": 88,
"column": 0
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\ninst✝ : HasZeroMorphisms C\nX Y : C\nf : X ⟶ Y\ns : KernelFork f\n⊢ Fork.ι s ≫ f = 0",
"ppTerm": "?m.23",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.Li... | [] | rw [Fork.condition, HasZeroMorphisms.comp_zero] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Preserves.Shapes.BinaryProducts | {
"line": 104,
"column": 2
} | {
"line": 105,
"column": 6
} | {
"line": 107,
"column": 0
} | [
{
"pp": "C : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝³ : Category.{v₂, u₂} D\nG : C ⥤ D\nX Y : C\ninst✝² : HasBinaryProduct X Y\ninst✝¹ : HasBinaryProduct (G.obj X) (G.obj Y)\ninst✝ : PreservesLimit (pair X Y) G\n⊢ (iso G X Y).inv ≫ G.map prod.fst = prod.fst",
"ppTerm": "?m.60",
"assign... | [] | rw [← Iso.cancel_iso_hom_left (PreservesLimitPair.iso G X Y), ← Category.assoc, Iso.hom_inv_id]
simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Preserves.Shapes.BinaryProducts | {
"line": 104,
"column": 2
} | {
"line": 105,
"column": 6
} | {
"line": 107,
"column": 0
} | [
{
"pp": "C : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝³ : Category.{v₂, u₂} D\nG : C ⥤ D\nX Y : C\ninst✝² : HasBinaryProduct X Y\ninst✝¹ : HasBinaryProduct (G.obj X) (G.obj Y)\ninst✝ : PreservesLimit (pair X Y) G\n⊢ (iso G X Y).inv ≫ G.map prod.fst = prod.fst",
"ppTerm": "?m.60",
"assign... | [] | rw [← Iso.cancel_iso_hom_left (PreservesLimitPair.iso G X Y), ← Category.assoc, Iso.hom_inv_id]
simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Preserves.Shapes.BinaryProducts | {
"line": 110,
"column": 2
} | {
"line": 111,
"column": 6
} | {
"line": 113,
"column": 0
} | [
{
"pp": "C : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝³ : Category.{v₂, u₂} D\nG : C ⥤ D\nX Y : C\ninst✝² : HasBinaryProduct X Y\ninst✝¹ : HasBinaryProduct (G.obj X) (G.obj Y)\ninst✝ : PreservesLimit (pair X Y) G\n⊢ (iso G X Y).inv ≫ G.map prod.snd = prod.snd",
"ppTerm": "?m.60",
"assign... | [] | rw [← Iso.cancel_iso_hom_left (PreservesLimitPair.iso G X Y), ← Category.assoc, Iso.hom_inv_id]
simp | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Preserves.Shapes.BinaryProducts | {
"line": 110,
"column": 2
} | {
"line": 111,
"column": 6
} | {
"line": 113,
"column": 0
} | [
{
"pp": "C : Type u₁\ninst✝⁴ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝³ : Category.{v₂, u₂} D\nG : C ⥤ D\nX Y : C\ninst✝² : HasBinaryProduct X Y\ninst✝¹ : HasBinaryProduct (G.obj X) (G.obj Y)\ninst✝ : PreservesLimit (pair X Y) G\n⊢ (iso G X Y).inv ≫ G.map prod.snd = prod.snd",
"ppTerm": "?m.60",
"assign... | [] | rw [← Iso.cancel_iso_hom_left (PreservesLimitPair.iso G X Y), ← Category.assoc, Iso.hom_inv_id]
simp | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Preserves.Shapes.Products | {
"line": 121,
"column": 82
} | {
"line": 124,
"column": 65
} | {
"line": 126,
"column": 0
} | [
{
"pp": "C : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝ : Category.{v₂, u₂} D\nG : C ⥤ D\nJ : Type w\nf : J → C\nP : C\ng : (j : J) → f j ⟶ P\n⊢ IsColimit (G.mapCocone (Cofan.mk P g)) ≃ IsColimit (Cofan.mk (G.obj P) fun j ↦ G.map (g j))",
"ppTerm": "?m.48",
"assigned": true,
"usedCons... | [] | by
refine (IsColimit.precomposeHomEquiv ?_ _).symm.trans (IsColimit.equivIsoColimit ?_)
· refine Discrete.natIso fun j => Iso.refl (G.obj (f j.as))
refine Cocone.ext (Iso.refl _) fun j => by dsimp; cases j; simp | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 78,
"column": 2
} | {
"line": 78,
"column": 28
} | {
"line": 80,
"column": 0
} | [
{
"pp": "J : Type w\nC : Type uC\ninst✝¹ : Category.{uC', uC} C\ninst✝ : HasZeroMorphisms C\nF : J → C\nB : Bicone F\nj j' : J\nh : j ≠ j'\n⊢ B.ι j ≫ B.π j' = 0",
"ppTerm": "?m.26",
"assigned": true,
"usedConstants": [
"eq_false",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.H... | [] | simpa [h] using B.ι_π j j' | Lean.Elab.Tactic.Simpa.evalSimpa | Lean.Parser.Tactic.simpa |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 78,
"column": 2
} | {
"line": 78,
"column": 28
} | {
"line": 80,
"column": 0
} | [
{
"pp": "J : Type w\nC : Type uC\ninst✝¹ : Category.{uC', uC} C\ninst✝ : HasZeroMorphisms C\nF : J → C\nB : Bicone F\nj j' : J\nh : j ≠ j'\n⊢ B.ι j ≫ B.π j' = 0",
"ppTerm": "?m.26",
"assigned": true,
"usedConstants": [
"eq_false",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.H... | [] | simpa [h] using B.ι_π j j' | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 78,
"column": 2
} | {
"line": 78,
"column": 28
} | {
"line": 80,
"column": 0
} | [
{
"pp": "J : Type w\nC : Type uC\ninst✝¹ : Category.{uC', uC} C\ninst✝ : HasZeroMorphisms C\nF : J → C\nB : Bicone F\nj j' : J\nh : j ≠ j'\n⊢ B.ι j ≫ B.π j' = 0",
"ppTerm": "?m.26",
"assigned": true,
"usedConstants": [
"eq_false",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.H... | [] | simpa [h] using B.ι_π j j' | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 139,
"column": 21
} | {
"line": 139,
"column": 59
} | {
"line": 140,
"column": 6
} | [
{
"pp": "J : Type w\nC : Type uC\ninst✝⁴ : Category.{uC', uC} C\ninst✝³ : HasZeroMorphisms C\nD : Type uD\ninst✝² : Category.{uD', uD} D\ninst✝¹ : HasZeroMorphisms D\nF : J → C\nG : C ⥤ D\ninst✝ : G.PreservesZeroMorphisms\nX✝ Y✝ : Bicone F\nf : X✝ ⟶ Y✝\nj : J\n⊢ G.map f.hom ≫ { pt := G.obj Y✝.pt, π := fun j ↦ G... | [] | by simp [-BiconeMorphism.wπ, ← f.wπ j] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 770,
"column": 2
} | {
"line": 774,
"column": 97
} | {
"line": 776,
"column": 0
} | [
{
"pp": "J : Type w\nC : Type u\ninst✝³ : Category.{v, u} C\ninst✝² : HasZeroMorphisms C\nf : J → C\ninst✝¹ : HasBiproduct f\np : J → Prop\ninst✝ : HasBiproduct (Subtype.restrict p f)\nj : Subtype p\n⊢ fromSubtype f p ≫ π f ↑j = π (Subtype.restrict p f) j",
"ppTerm": "?m.39",
"assigned": true,
"used... | [] | classical
ext
rw [biproduct.fromSubtype, biproduct.ι_desc_assoc, biproduct.ι_π, biproduct.ι_π]
split_ifs with h₁ h₂ h₂
exacts [rfl, False.elim (h₂ (Subtype.ext h₁)), False.elim (h₁ (congr_arg Subtype.val h₂)), rfl] | Lean.Elab.Tactic.evalClassical | Lean.Parser.Tactic.classical |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 770,
"column": 2
} | {
"line": 774,
"column": 97
} | {
"line": 776,
"column": 0
} | [
{
"pp": "J : Type w\nC : Type u\ninst✝³ : Category.{v, u} C\ninst✝² : HasZeroMorphisms C\nf : J → C\ninst✝¹ : HasBiproduct f\np : J → Prop\ninst✝ : HasBiproduct (Subtype.restrict p f)\nj : Subtype p\n⊢ fromSubtype f p ≫ π f ↑j = π (Subtype.restrict p f) j",
"ppTerm": "?m.39",
"assigned": true,
"used... | [] | classical
ext
rw [biproduct.fromSubtype, biproduct.ι_desc_assoc, biproduct.ι_π, biproduct.ι_π]
split_ifs with h₁ h₂ h₂
exacts [rfl, False.elim (h₂ (Subtype.ext h₁)), False.elim (h₁ (congr_arg Subtype.val h₂)), rfl] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 770,
"column": 2
} | {
"line": 774,
"column": 97
} | {
"line": 776,
"column": 0
} | [
{
"pp": "J : Type w\nC : Type u\ninst✝³ : Category.{v, u} C\ninst✝² : HasZeroMorphisms C\nf : J → C\ninst✝¹ : HasBiproduct f\np : J → Prop\ninst✝ : HasBiproduct (Subtype.restrict p f)\nj : Subtype p\n⊢ fromSubtype f p ≫ π f ↑j = π (Subtype.restrict p f) j",
"ppTerm": "?m.39",
"assigned": true,
"used... | [] | classical
ext
rw [biproduct.fromSubtype, biproduct.ι_desc_assoc, biproduct.ι_π, biproduct.ι_π]
split_ifs with h₁ h₂ h₂
exacts [rfl, False.elim (h₂ (Subtype.ext h₁)), False.elim (h₁ (congr_arg Subtype.val h₂)), rfl] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Preadditive.Biproducts | {
"line": 194,
"column": 2
} | {
"line": 197,
"column": 84
} | {
"line": 199,
"column": 0
} | [
{
"pp": "C : Type u\ninst✝³ : Category.{v, u} C\ninst✝² : Preadditive C\nJ : Type u_1\ninst✝¹ : Finite J\nf : J → C\ninst✝ : HasCoproduct f\n⊢ HasBiproduct f",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"CategoryTheory.Limits.HasBiproduct",
"CategoryTheory.Limits.colimit.isCo... | [] | cases nonempty_fintype J
exact HasBiproduct.mk
{ bicone := _
isBilimit := biconeIsBilimitOfColimitCoconeOfIsColimit (colimit.isColimit _) } | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Preadditive.Biproducts | {
"line": 194,
"column": 2
} | {
"line": 197,
"column": 84
} | {
"line": 199,
"column": 0
} | [
{
"pp": "C : Type u\ninst✝³ : Category.{v, u} C\ninst✝² : Preadditive C\nJ : Type u_1\ninst✝¹ : Finite J\nf : J → C\ninst✝ : HasCoproduct f\n⊢ HasBiproduct f",
"ppTerm": "?m.9",
"assigned": true,
"usedConstants": [
"CategoryTheory.Limits.HasBiproduct",
"CategoryTheory.Limits.colimit.isCo... | [] | cases nonempty_fintype J
exact HasBiproduct.mk
{ bicone := _
isBilimit := biconeIsBilimitOfColimitCoconeOfIsColimit (colimit.isColimit _) } | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {
"line": 776,
"column": 2
} | {
"line": 777,
"column": 38
} | {
"line": 778,
"column": 2
} | [
{
"pp": "J : Type w\nC : Type uC\ninst✝⁷ : Category.{uC', uC} C\ninst✝⁶ : HasZeroMorphisms C\nD : Type uD\ninst✝⁵ : Category.{uD', uD} D\ninst✝⁴ : HasZeroMorphisms D\nP Q W X Y Z : C\nf : W ⟶ Y\ng : X ⟶ Z\ninst✝³ : Mono f\ninst✝² : Mono g\ninst✝¹ : HasBinaryBiproduct W X\ninst✝ : HasBinaryBiproduct Y Z\n⊢ Mono ... | [
"J : Type w\nC : Type uC\ninst✝⁷ : Category.{uC', uC} C\ninst✝⁶ : HasZeroMorphisms C\nD : Type uD\ninst✝⁵ : Category.{uD', uD} D\ninst✝⁴ : HasZeroMorphisms D\nP Q W X Y Z : C\nf : W ⟶ Y\ng : X ⟶ Z\ninst✝³ : Mono f\ninst✝² : Mono g\ninst✝¹ : HasBinaryBiproduct W X\ninst✝ : HasBinaryBiproduct Y Z\n⊢ Mono ((isoProd W ... | rw [show biprod.map f g = (biprod.isoProd _ _).hom ≫ prod.map f g ≫
(biprod.isoProd _ _).inv by aesop] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Preadditive.Biproducts | {
"line": 559,
"column": 10
} | {
"line": 559,
"column": 24
} | {
"line": 559,
"column": 25
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Preadditive C\nX✝ Y✝ : C\ninst✝ : HasBinaryBiproduct X✝ Y✝\nX Y : C\nb : BinaryBicone X Y\nhb : IsLimit b.sndKernelFork\nT : C\nf : T ⟶ X\ng : T ⟶ Y\nm : T ⟶ b.pt\nh₁ : m ≫ BinaryFan.fst b.toCone = f\nh₂ : m ≫ BinaryFan.snd b.toCone = g\nh₁' : (m - (f ≫ ... | [
"C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Preadditive C\nX✝ Y✝ : C\ninst✝ : HasBinaryBiproduct X✝ Y✝\nX Y : C\nb : BinaryBicone X Y\nhb : IsLimit b.sndKernelFork\nT : C\nf : T ⟶ X\ng : T ⟶ Y\nm : T ⟶ b.pt\nh₁ : m ≫ BinaryFan.fst b.toCone = f\nh₂ : m ≫ BinaryFan.snd b.toCone = g\nh₁' : (m - (f ≫ b.inl + g ≫ ... | ← sub_eq_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {
"line": 1047,
"column": 2
} | {
"line": 1048,
"column": 79
} | {
"line": 1050,
"column": 0
} | [
{
"pp": "J : Type w\nC : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : HasZeroMorphisms C\nf : J → C\ninst✝ : HasBiproduct f\nb : Bicone f\nhb : b.IsBilimit\nj : J\nj' : Discrete J\n⊢ (ι f j ≫ (hb.isLimit.conePointUniqueUpToIso (isLimit f)).inv) ≫ b.toCone.π.app j' =\n (ι f j ≫ desc b.ι) ≫ b.toCone.π.app j'",... | [] | rw [Category.assoc, IsLimit.conePointUniqueUpToIso_inv_comp, Bicone.toCone_π_app,
biproduct.bicone_π, biproduct.ι_desc, biproduct.ι_π, b.toCone_π_app, b.ι_π] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Preadditive.Biproducts | {
"line": 575,
"column": 10
} | {
"line": 575,
"column": 24
} | {
"line": 575,
"column": 25
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Preadditive C\nX✝ Y✝ : C\ninst✝ : HasBinaryBiproduct X✝ Y✝\nX Y : C\nb : BinaryBicone X Y\nhb : IsLimit b.fstKernelFork\nT : C\nf : T ⟶ X\ng : T ⟶ Y\nm : T ⟶ b.pt\nh₁ : m ≫ BinaryFan.fst b.toCone = f\nh₂ : m ≫ BinaryFan.snd b.toCone = g\nh₁' : (m - (f ≫ ... | [
"C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Preadditive C\nX✝ Y✝ : C\ninst✝ : HasBinaryBiproduct X✝ Y✝\nX Y : C\nb : BinaryBicone X Y\nhb : IsLimit b.fstKernelFork\nT : C\nf : T ⟶ X\ng : T ⟶ Y\nm : T ⟶ b.pt\nh₁ : m ≫ BinaryFan.fst b.toCone = f\nh₂ : m ≫ BinaryFan.snd b.toCone = g\nh₁' : (m - (f ≫ b.inl + g ≫ ... | ← sub_eq_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Preadditive.Biproducts | {
"line": 591,
"column": 10
} | {
"line": 591,
"column": 24
} | {
"line": 591,
"column": 25
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Preadditive C\nX✝ Y✝ : C\ninst✝ : HasBinaryBiproduct X✝ Y✝\nX Y : C\nb : BinaryBicone X Y\nhb : IsColimit b.inrCokernelCofork\nT : C\nf : X ⟶ T\ng : Y ⟶ T\nm : b.pt ⟶ T\nh₁ : BinaryCofan.inl b.toCocone ≫ m = f\nh₂ : BinaryCofan.inr b.toCocone ≫ m = g\nh₁... | [
"C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Preadditive C\nX✝ Y✝ : C\ninst✝ : HasBinaryBiproduct X✝ Y✝\nX Y : C\nb : BinaryBicone X Y\nhb : IsColimit b.inrCokernelCofork\nT : C\nf : X ⟶ T\ng : Y ⟶ T\nm : b.pt ⟶ T\nh₁ : BinaryCofan.inl b.toCocone ≫ m = f\nh₂ : BinaryCofan.inr b.toCocone ≫ m = g\nh₁' : b.inl ≫ ... | ← sub_eq_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Preadditive.Biproducts | {
"line": 607,
"column": 10
} | {
"line": 607,
"column": 24
} | {
"line": 607,
"column": 25
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Preadditive C\nX✝ Y✝ : C\ninst✝ : HasBinaryBiproduct X✝ Y✝\nX Y : C\nb : BinaryBicone X Y\nhb : IsColimit b.inlCokernelCofork\nT : C\nf : X ⟶ T\ng : Y ⟶ T\nm : b.pt ⟶ T\nh₁ : BinaryCofan.inl b.toCocone ≫ m = f\nh₂ : BinaryCofan.inr b.toCocone ≫ m = g\nh₁... | [
"C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : Preadditive C\nX✝ Y✝ : C\ninst✝ : HasBinaryBiproduct X✝ Y✝\nX Y : C\nb : BinaryBicone X Y\nhb : IsColimit b.inlCokernelCofork\nT : C\nf : X ⟶ T\ng : Y ⟶ T\nm : b.pt ⟶ T\nh₁ : BinaryCofan.inl b.toCocone ≫ m = f\nh₂ : BinaryCofan.inr b.toCocone ≫ m = g\nh₁' : b.inl ≫ ... | ← sub_eq_zero, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.Fin.Tuple.NatAntidiagonal | {
"line": 93,
"column": 2
} | {
"line": 93,
"column": 33
} | {
"line": 94,
"column": 2
} | [
{
"pp": "k n : ℕ\n⊢ (antidiagonalTuple k n).Nodup",
"ppTerm": "?m.2",
"assigned": true,
"usedConstants": [
"False",
"Nat.recAux",
"congrArg",
"and_self",
"Membership.mem",
"List.nodup_nil._simp_1",
"instOfNatNat",
"List.not_mem_nil._simp_1",
"Lis... | [
"case succ\nk : ℕ\nih : ∀ (n : ℕ), (antidiagonalTuple k n).Nodup\nn : ℕ\n⊢ (antidiagonalTuple (k + 1) n).Nodup"
] | induction k generalizing n with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Combinatorics.Enumerative.Composition | {
"line": 567,
"column": 2
} | {
"line": 567,
"column": 13
} | {
"line": 568,
"column": 2
} | [
{
"pp": "n : ℕ\nhn : 0 < n\nc : Composition n\n⊢ c ≠ single n hn ↔ ∀ (i : Fin c.length), c.blocksFun i < n",
"ppTerm": "?m.10",
"assigned": true,
"usedConstants": [
"Mathlib.Tactic.Push.not_forall_eq",
"Eq.mpr",
"Preorder.toLT",
"Composition.length",
"congrArg",
"... | [
"n : ℕ\nhn : 0 < n\nc : Composition n\n⊢ c = single n hn ↔ ∃ i, n ≤ c.blocksFun i"
] | contrapose! | Mathlib.Tactic.Contrapose._aux_Mathlib_Tactic_Contrapose___macroRules_Mathlib_Tactic_Contrapose_contrapose!_1 | Mathlib.Tactic.Contrapose.contrapose! |
Mathlib.GroupTheory.Perm.Support | {
"line": 401,
"column": 56
} | {
"line": 407,
"column": 39
} | {
"line": 409,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nl : List (Perm α)\nh : List.Pairwise Disjoint l\n⊢ l.prod.support = List.foldr (fun x1 x2 ↦ x1 ⊔ x2) ⊥ (List.map support l)",
"ppTerm": "?m.25",
"assigned": true,
"usedConstants": [
"Equiv.Perm.support",
"Lattice.toSemilat... | [] | by
induction l with
| nil => simp
| cons hd tl hl =>
rw [List.pairwise_cons] at h
have : Disjoint hd tl.prod := disjoint_prod_right _ h.left
simp [this.support_mul, hl h.right] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.Perm.Support | {
"line": 452,
"column": 2
} | {
"line": 454,
"column": 34
} | {
"line": 455,
"column": 2
} | [
{
"pp": "case a\nα : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nx y z : α\nh : (x ≠ y ∧ x ≠ z ∧ True) ∧ y ≠ z ∧ True\n⊢ (swap x y * swap y z).support ⊆ {x, y, z}",
"ppTerm": "?a✝",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Equiv.Perm.support",
"Lattice.toSemilattice... | [
"case a\nα : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nx y z : α\nh : (x ≠ y ∧ x ≠ z ∧ True) ∧ y ≠ z ∧ True\n⊢ {x, y, z} ⊆ (swap x y * swap y z).support"
] | · convert! support_mul_le (swap x y) (swap y z) using 1
rw [support_swap h.left.left, support_swap h.right.left]
simp [-Finset.union_singleton] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.GroupTheory.Perm.List | {
"line": 145,
"column": 2
} | {
"line": 145,
"column": 54
} | {
"line": 147,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nx : α\nxs : List α\n⊢ (x :: xs).formPerm (x :: xs)[xs.length] = x",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"List.getLast",
"Eq.mpr",
"Equiv.instEquivLike",
"List.getElem_cons_length._proof_1",
"congrArg",
... | [] | rw [getElem_cons_length rfl, formPerm_apply_getLast] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.Perm.List | {
"line": 145,
"column": 2
} | {
"line": 145,
"column": 54
} | {
"line": 147,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nx : α\nxs : List α\n⊢ (x :: xs).formPerm (x :: xs)[xs.length] = x",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"List.getLast",
"Eq.mpr",
"Equiv.instEquivLike",
"List.getElem_cons_length._proof_1",
"congrArg",
... | [] | rw [getElem_cons_length rfl, formPerm_apply_getLast] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Perm.List | {
"line": 145,
"column": 2
} | {
"line": 145,
"column": 54
} | {
"line": 147,
"column": 0
} | [
{
"pp": "α : Type u_1\ninst✝ : DecidableEq α\nx : α\nxs : List α\n⊢ (x :: xs).formPerm (x :: xs)[xs.length] = x",
"ppTerm": "?m.15",
"assigned": true,
"usedConstants": [
"List.getLast",
"Eq.mpr",
"Equiv.instEquivLike",
"List.getElem_cons_length._proof_1",
"congrArg",
... | [] | rw [getElem_cons_length rfl, formPerm_apply_getLast] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Perm.Support | {
"line": 642,
"column": 6
} | {
"line": 642,
"column": 28
} | {
"line": 642,
"column": 29
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nσ : Perm α\nh : σ ≠ 1\n⊢ #{x | σ x = x} < Fintype.card α - 1",
"ppTerm": "?m.21",
"assigned": true,
"usedConstants": [
"Eq.mpr",
"Nat.lt_sub_iff_add_lt",
"Equiv.instEquivLike",
"Finset.univ",
"congrArg",
... | [
"α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nσ : Perm α\nh : σ ≠ 1\n⊢ #{x | σ x = x} + 1 < Fintype.card α"
] | Nat.lt_sub_iff_add_lt, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.Closure | {
"line": 69,
"column": 8
} | {
"line": 70,
"column": 23
} | {
"line": 71,
"column": 6
} | [
{
"pp": "case pos\nα : Type u_2\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nσ : Perm α\nh1 : σ.IsCycle\nh2 : σ.support = univ\nx : α\nH : Subgroup (Perm α) := closure {σ, swap x (σ x)}\nh3 : σ ∈ H\nh4 : swap x (σ x) ∈ H\nstep1 : ∀ (n : ℕ), swap ((σ ^ n) x) ((σ ^ (n + 1)) x) ∈ H\nn : ℕ\nih : swap x ((σ ^ n) x) ∈... | [] | rw [← h6, swap_self]
exact H.one_mem | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Perm.Closure | {
"line": 69,
"column": 8
} | {
"line": 70,
"column": 23
} | {
"line": 71,
"column": 6
} | [
{
"pp": "case pos\nα : Type u_2\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nσ : Perm α\nh1 : σ.IsCycle\nh2 : σ.support = univ\nx : α\nH : Subgroup (Perm α) := closure {σ, swap x (σ x)}\nh3 : σ ∈ H\nh4 : swap x (σ x) ∈ H\nstep1 : ∀ (n : ℕ), swap ((σ ^ n) x) ((σ ^ (n + 1)) x) ∈ H\nn : ℕ\nih : swap x ((σ ^ n) x) ∈... | [] | rw [← h6, swap_self]
exact H.one_mem | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Perm.Closure | {
"line": 76,
"column": 8
} | {
"line": 76,
"column": 13
} | {
"line": 76,
"column": 14
} | [
{
"pp": "α : Type u_2\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nσ : Perm α\nh1 : σ.IsCycle\nh2 : σ.support = univ\nx : α\nH : Subgroup (Perm α) := closure {σ, swap x (σ x)}\nh3 : σ ∈ H\nh4 : swap x (σ x) ∈ H\nstep1 : ∀ (n : ℕ), swap ((σ ^ n) x) ((σ ^ (n + 1)) x) ∈ H\nstep2 : ∀ (n : ℕ), swap x ((σ ^ n) x) ∈ H\... | [
"α : Type u_2\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nσ : Perm α\nh1 : σ.IsCycle\nh2 : σ.support = univ\nx : α\nH : Subgroup (Perm α) := closure {σ, swap x (σ x)}\nh3 : σ ∈ H\nh4 : swap x (σ x) ∈ H\nstep1 : ∀ (n : ℕ), swap ((σ ^ n) x) ((σ ^ (n + 1)) x) ∈ H\nstep2 : ∀ (n : ℕ), swap x ((σ ^ n) x) ∈ H\ny : α\nhx :... | ← h2, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.Closure | {
"line": 78,
"column": 8
} | {
"line": 78,
"column": 13
} | {
"line": 78,
"column": 14
} | [
{
"pp": "α : Type u_2\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nσ : Perm α\nh1 : σ.IsCycle\nh2 : σ.support = univ\nx : α\nH : Subgroup (Perm α) := closure {σ, swap x (σ x)}\nh3 : σ ∈ H\nh4 : swap x (σ x) ∈ H\nstep1 : ∀ (n : ℕ), swap ((σ ^ n) x) ((σ ^ (n + 1)) x) ∈ H\nstep2 : ∀ (n : ℕ), swap x ((σ ^ n) x) ∈ H\... | [
"α : Type u_2\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nσ : Perm α\nh1 : σ.IsCycle\nh2 : σ.support = univ\nx : α\nH : Subgroup (Perm α) := closure {σ, swap x (σ x)}\nh3 : σ ∈ H\nh4 : swap x (σ x) ∈ H\nstep1 : ∀ (n : ℕ), swap ((σ ^ n) x) ((σ ^ (n + 1)) x) ∈ H\nstep2 : ∀ (n : ℕ), swap x ((σ ^ n) x) ∈ H\ny : α\nhx :... | ← h2, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.Closure | {
"line": 100,
"column": 26
} | {
"line": 100,
"column": 31
} | {
"line": 100,
"column": 32
} | [
{
"pp": "α : Type u_2\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nn : ℕ\nσ : Perm α\nh0 : n.Coprime #univ\nh1 : σ.IsCycle\nh2 : σ.support = univ\nx : α\n⊢ closure {σ, swap x ((σ ^ n) x)} = ⊤",
"ppTerm": "?m.36",
"assigned": true,
"usedConstants": [
"Nat.Coprime",
"Equiv.Perm.support",
... | [
"α : Type u_2\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nn : ℕ\nσ : Perm α\nh0 : n.Coprime #σ.support\nh1 : σ.IsCycle\nh2 : σ.support = univ\nx : α\n⊢ closure {σ, swap x ((σ ^ n) x)} = ⊤"
] | ← h2, | Lean.Elab.Tactic.evalRewriteSeq | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.