module stringlengths 16 90 | startPos dict | endPos dict | goals listlengths 0 96 | ppTac stringlengths 1 14.5k | elaborator stringclasses 366
values | kind stringclasses 370
values |
|---|---|---|---|---|---|---|
Mathlib.Algebra.Polynomial.Derivative | {
"line": 205,
"column": 2
} | {
"line": 205,
"column": 88
} | [
{
"pp": "R : Type u\ninst✝ : Semiring R\np : R[X]\nx : ℕ\nhx : p.natDegree < x\n⊢ (⇑derivative)^[x] p = 0",
"usedConstants": [
"Nat",
"Eq.refl",
"Polynomial.natDegree"
]
}
] | induction h : p.natDegree using Nat.strong_induction_on generalizing p x with | _ _ ih
=> _ | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | Lean.Parser.Tactic.induction |
Mathlib.Algebra.Polynomial.Expand | {
"line": 139,
"column": 2
} | {
"line": 139,
"column": 60
} | [
{
"pp": "case neg\nR : Type u\ninst✝ : CommSemiring R\np : ℕ\nf : R[X]\nhp : p > 0\nhf : ¬f = 0\n⊢ ((expand R p) f).natDegree = f.natDegree * p",
"usedConstants": [
"CommSemiring.toSemiring",
"AlgHom",
"AlgHom.funLike",
"Polynomial.algebraOfAlgebra",
"mt",
"Algebra.id",
... | have hf1 : expand R p f ≠ 0 := mt (expand_eq_zero hp).1 hf | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Algebra.Polynomial.Expand | {
"line": 221,
"column": 2
} | {
"line": 221,
"column": 96
} | [
{
"pp": "case a.h\nR : Type u\ninst✝ : CommSemiring R\np : ℕ\nhp : p ≠ 0\nf g : R[X]\nn : ℕ\n⊢ image (fun x ↦ (x.1 * p, x.2 * p)) (antidiagonal n) ⊆ antidiagonal (n * p)",
"usedConstants": [
"add_mul",
"Eq.mpr",
"HMul.hMul",
"AddMonoid.toAddSemigroup",
"instDecidableEqProd",
... | · simp_rw [subset_iff, mem_image, mem_antidiagonal]; rintro _ ⟨x, rfl, rfl⟩; simp_rw [add_mul] | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.Algebra.Polynomial.Expand | {
"line": 227,
"column": 69
} | {
"line": 227,
"column": 90
} | [
{
"pp": "R : Type u\ninst✝ : CommSemiring R\np : ℕ\nhp : p ≠ 0\nf g : R[X]\nn x y : ℕ\neq : (p * x, p * y).1 + (p * x, p * y).2 = n * p\nnex : ¬∃ a, a.1 + a.2 = n ∧ (a.1 * p, a.2 * p) = (p * x, p * y)\n⊢ ((x, y).1 * p, (x, y).2 * p) = (p * x, p * y)",
"usedConstants": [
"HMul.hMul",
"CommSemirin... | by simp_rw [mul_comm] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Polynomial.CancelLeads | {
"line": 64,
"column": 9
} | {
"line": 64,
"column": 27
} | [
{
"pp": "case neg.a.a\nR : Type u_1\ninst✝ : Ring R\np q : R[X]\ncomm : p.leadingCoeff * q.leadingCoeff = q.leadingCoeff * p.leadingCoeff\nh : p.natDegree ≤ q.natDegree\nhq : 0 < q.natDegree\nhp : ¬p = 0\nh0 : ¬C p.leadingCoeff * q + -(C q.leadingCoeff * X ^ (q.natDegree - p.natDegree) * p) = 0\n⊢ q.natDegree -... | Nat.sub_add_cancel | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Div | {
"line": 463,
"column": 58
} | {
"line": 463,
"column": 76
} | [
{
"pp": "case inr.refine_1.e_a.refine_2\nR : Type u\ninst✝ : Ring R\np : R[X]\na : R\nn✝ : ℕ\nthis :\n ∀ (n : ℕ), p.natDegree ≤ n → (p /ₘ (X - C a)).coeff n = ∑ i ∈ Icc (n + 1) p.natDegree, a ^ (i - (n + 1)) * p.coeff i\nh : ¬p.natDegree ≤ n✝\nn : ℕ\nhn : n < p.natDegree\nx✝ : n✝ ≤ n\nih : (p /ₘ (X - C a)).coe... | Nat.sub_add_cancel | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Polynomial.Div | {
"line": 555,
"column": 2
} | {
"line": 555,
"column": 76
} | [
{
"pp": "R : Type u\ninst✝ : Ring R\np : R[X]\na : R\n⊢ (X - C a) ^ rootMultiplicity a p * (p /ₘ (X - C a) ^ rootMultiplicity a p) = p",
"usedConstants": [
"Polynomial.monic_X_sub_C",
"Polynomial.C",
"HSub.hSub",
"RingHom",
"Polynomial",
"Monoid.toPow",
"Polynomial.... | have : Monic ((X - C a) ^ rootMultiplicity a p) := (monic_X_sub_C _).pow _ | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticHave___1 | Lean.Parser.Tactic.tacticHave__ |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 547,
"column": 2
} | {
"line": 548,
"column": 49
} | [
{
"pp": "R : Type u\ninst✝ : CommSemiring R\nn : ℕ\np : R[X]\n⊢ (⇑derivative)^[n] (derivative p * X) = (⇑derivative)^[n + 1] p * X + n • (⇑derivative)^[n] p",
"usedConstants": [
"Polynomial.derivative",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"NonAssocSemiring.toAddCommMonoidWithO... | convert! (derivative p).iterate_derivative_mul_X_pow n 1; · simp
rcases n with rfl | n <;> simp [sum_range_succ] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Polynomial.Derivative | {
"line": 547,
"column": 2
} | {
"line": 548,
"column": 49
} | [
{
"pp": "R : Type u\ninst✝ : CommSemiring R\nn : ℕ\np : R[X]\n⊢ (⇑derivative)^[n] (derivative p * X) = (⇑derivative)^[n + 1] p * X + n • (⇑derivative)^[n] p",
"usedConstants": [
"Polynomial.derivative",
"Eq.mpr",
"Nat.instCanonicallyOrderedAdd",
"NonAssocSemiring.toAddCommMonoidWithO... | convert! (derivative p).iterate_derivative_mul_X_pow n 1; · simp
rcases n with rfl | n <;> simp [sum_range_succ] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Polynomial.Div | {
"line": 708,
"column": 6
} | {
"line": 708,
"column": 45
} | [
{
"pp": "case inr\nR : Type u\ninst✝ : CommRing R\np : R[X]\nt : R\nhp : p ≠ 0\nm : ℕ := rootMultiplicity t p\ng : R[X] := p /ₘ (X - C t) ^ m\nmul_eq : (X - C t) ^ m * g = p\nthis : (g.comp (X + C t)).coeff 0 = eval t g\n⊢ eval t g = (p.comp (X + C t)).trailingCoeff",
"usedConstants": [
"Eq.mpr",
... | ← congr_arg (comp · <| X + C t) mul_eq, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.BigOperators.Associated | {
"line": 98,
"column": 4
} | {
"line": 121,
"column": 72
} | [
{
"pp": "case cons\nM₀ : Type u_3\ninst✝¹ : CommMonoidWithZero M₀\ninst✝ : IsCancelMulZero M₀\nc : M₀\ns : Multiset M₀\nhind :\n ∀ (x y : M₀),\n x * y ∈ closure {r | IsUnit r ∨ Prime r} →\n (∀ y ∈ s, y ∈ {r | IsUnit r ∨ Prime r}) → s.prod = x * y → x ∈ closure {r | IsUnit r ∨ Prime r}\nx y : M₀\nhxy : ... | simp only [Multiset.mem_cons, forall_eq_or_imp, Set.mem_setOf] at hm
simp only [Multiset.prod_cons] at hprod
simp only [Set.mem_setOf_eq] at hind
obtain ⟨ha₁ | ha₂, hs⟩ := hm
· rcases ha₁.exists_right_inv with ⟨k, hk⟩
refine hind x (y * k) ?_ hs ?_
· simp only [← mul_assoc, ← hprod, ← Multis... | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BigOperators.Associated | {
"line": 98,
"column": 4
} | {
"line": 121,
"column": 72
} | [
{
"pp": "case cons\nM₀ : Type u_3\ninst✝¹ : CommMonoidWithZero M₀\ninst✝ : IsCancelMulZero M₀\nc : M₀\ns : Multiset M₀\nhind :\n ∀ (x y : M₀),\n x * y ∈ closure {r | IsUnit r ∨ Prime r} →\n (∀ y ∈ s, y ∈ {r | IsUnit r ∨ Prime r}) → s.prod = x * y → x ∈ closure {r | IsUnit r ∨ Prime r}\nx y : M₀\nhxy : ... | simp only [Multiset.mem_cons, forall_eq_or_imp, Set.mem_setOf] at hm
simp only [Multiset.prod_cons] at hprod
simp only [Set.mem_setOf_eq] at hind
obtain ⟨ha₁ | ha₂, hs⟩ := hm
· rcases ha₁.exists_right_inv with ⟨k, hk⟩
refine hind x (y * k) ?_ hs ?_
· simp only [← mul_assoc, ← hprod, ← Multis... | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.BigOperators.Associated | {
"line": 229,
"column": 2
} | {
"line": 229,
"column": 86
} | [
{
"pp": "M₀ : Type u_3\nM : Type u_4\ninst✝ : CommMonoidWithZero M\nS : Finset M₀\np : M\npp : Prime p\ng : M₀ → M\nhS : ∀ a ∈ S, ¬p ∣ g a\n⊢ ¬p ∣ S.prod g",
"usedConstants": [
"CommMonoidWithZero.toCommMonoid",
"Iff.mpr",
"Dvd.dvd",
"Finset",
"semigroupDvd",
"Prime.dvd_f... | exact mt (Prime.dvd_finsetProd_iff pp _).1 <| not_exists.2 fun a => not_and.2 (hS a) | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.BigOperators.Associated | {
"line": 229,
"column": 2
} | {
"line": 229,
"column": 86
} | [
{
"pp": "M₀ : Type u_3\nM : Type u_4\ninst✝ : CommMonoidWithZero M\nS : Finset M₀\np : M\npp : Prime p\ng : M₀ → M\nhS : ∀ a ∈ S, ¬p ∣ g a\n⊢ ¬p ∣ S.prod g",
"usedConstants": [
"CommMonoidWithZero.toCommMonoid",
"Iff.mpr",
"Dvd.dvd",
"Finset",
"semigroupDvd",
"Prime.dvd_f... | exact mt (Prime.dvd_finsetProd_iff pp _).1 <| not_exists.2 fun a => not_and.2 (hS a) | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BigOperators.Associated | {
"line": 229,
"column": 2
} | {
"line": 229,
"column": 86
} | [
{
"pp": "M₀ : Type u_3\nM : Type u_4\ninst✝ : CommMonoidWithZero M\nS : Finset M₀\np : M\npp : Prime p\ng : M₀ → M\nhS : ∀ a ∈ S, ¬p ∣ g a\n⊢ ¬p ∣ S.prod g",
"usedConstants": [
"CommMonoidWithZero.toCommMonoid",
"Iff.mpr",
"Dvd.dvd",
"Finset",
"semigroupDvd",
"Prime.dvd_f... | exact mt (Prime.dvd_finsetProd_iff pp _).1 <| not_exists.2 fun a => not_and.2 (hS a) | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | {
"line": 180,
"column": 2
} | {
"line": 180,
"column": 43
} | [
{
"pp": "α : Type u_1\ninst✝² : CommMonoidWithZero α\ninst✝¹ : NormalizationMonoid α\ninst✝ : UniqueFactorizationMonoid α\ns : Multiset α\nhs : ∀ a ∈ s, Irreducible a\n⊢ normalizedFactors s.prod = Multiset.map (⇑normalize) s",
"usedConstants": [
"Multiset.prod_zero",
"UniqueFactorizationMonoid.n... | induction s using Multiset.induction with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | {
"line": 258,
"column": 2
} | {
"line": 258,
"column": 32
} | [
{
"pp": "α : Type u_1\ninst✝² : CommMonoidWithZero α\ninst✝¹ : NormalizationMonoid α\ninst✝ : UniqueFactorizationMonoid α\np r : α\nh : ∀ {m : α}, m ∈ normalizedFactors r → m = p\nhr : r ≠ 0\n⊢ ∃ i, p ^ i ~ᵤ r",
"usedConstants": [
"UniqueFactorizationMonoid.normalizedFactors",
"CommMonoidWithZer... | use (normalizedFactors r).card | Mathlib.Tactic._aux_Mathlib_Tactic_Use___elabRules_Mathlib_Tactic_useSyntax_1 | Mathlib.Tactic.useSyntax |
Mathlib.RingTheory.UniqueFactorizationDomain.Basic | {
"line": 355,
"column": 12
} | {
"line": 355,
"column": 36
} | [
{
"pp": "α : Type u_1\ninst✝¹ : CommMonoidWithZero α\ninst✝ : IsCancelMulZero α\npf : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a\na b : α\nane0 : a ≠ 0\nc : α\nhc : ¬IsUnit c\nb_eq : b = a * c\nh : ¬b = 0\ncne0 : c ≠ 0\n⊢ (Classical.choose ⋯).prod * (Classical.choose ⋯).prod ~ᵤ a * c",
"usedCo... | apply Associated.mul_mul | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Algebra.Polynomial.Roots | {
"line": 384,
"column": 8
} | {
"line": 384,
"column": 52
} | [
{
"pp": "case neg\nR : Type u\nn : ℕ\ninst✝⁵ : CommRing R\ninst✝⁴ : IsDomain R\nS : Type u_1\nF : Type u_2\ninst✝³ : CommRing S\ninst✝² : IsDomain S\ninst✝¹ : FunLike F R S\ninst✝ : MonoidHomClass F R S\na x : R\nhx : x ∈ nthRootsFinset n a\nf : F\nhn : ¬n = 0\n⊢ f x ∈ nthRootsFinset n (f a)",
"usedConstant... | mem_nthRootsFinset <| Nat.pos_of_ne_zero hn, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.UniqueFactorizationDomain.NormalizedFactors | {
"line": 331,
"column": 2
} | {
"line": 331,
"column": 43
} | [
{
"pp": "case inr\nα : Type u_1\ninst✝² : CommMonoidWithZero α\ninst✝¹ : NormalizationMonoid α\ninst✝ : UniqueFactorizationMonoid α\ns : Multiset α\nhs : 0 ∉ s\nh✝ : Nontrivial α\n⊢ normalizedFactors s.prod = (Multiset.map normalizedFactors s).sum",
"usedConstants": [
"Multiset.sum",
"UniqueFact... | induction s using Multiset.induction with | _private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalInduction | null |
Mathlib.Algebra.Polynomial.Roots | {
"line": 733,
"column": 2
} | {
"line": 733,
"column": 40
} | [
{
"pp": "R : Type u\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\nf : R[X]\nhf : ∀ (r : R), eval r f = 0\nhfR : ↑f.natDegree < #R\n⊢ f = 0",
"usedConstants": [
"finite_or_infinite"
]
}
] | obtain hR | hR := finite_or_infinite R | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.Algebra.Polynomial.Roots | {
"line": 771,
"column": 41
} | {
"line": 771,
"column": 60
} | [
{
"pp": "R : Type u\ninst✝¹ : CommRing R\ninst✝ : IsDomain R\np : R[X]\n⊢ map (algebraMap R (FractionRing R)) (∏ a ∈ p.roots.toFinset, (X - C a) ^ rootMultiplicity a p) ∣\n map (algebraMap R (FractionRing R)) p",
"usedConstants": [
"Multiset.toFinset",
"Eq.mpr",
"Polynomial.C",
"P... | Polynomial.map_prod | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.Polynomial.Content | {
"line": 173,
"column": 2
} | {
"line": 175,
"column": 29
} | [
{
"pp": "case hab\nR : Type u_1\ninst✝¹ : CommRing R\ninst✝ : NormalizedGCDMonoid R\np : R[X]\nn : ℕ\nh : p.natDegree < n\n⊢ p.content ∣ (Finset.range n).gcd p.coeff",
"usedConstants": [
"Eq.mpr",
"Dvd.dvd",
"congrArg",
"CommSemiring.toSemiring",
"Finset",
"semigroupDvd",... | · rw [Finset.dvd_gcd_iff]
intro i _
apply content_dvd_coeff _ | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | {
"line": 630,
"column": 53
} | {
"line": 630,
"column": 91
} | [
{
"pp": "α : Type u_1\ninst✝² : CommMonoidWithZero α\ninst✝¹ : UniqueFactorizationMonoid α\na p : Associates α\nhp : Irreducible p\ninst✝ : (n : ℕ) → Decidable (a ∣ p ^ n)\nn : ℕ\nh : a ∣ p ^ n\n⊢ a = p ^ p.count a.factors",
"usedConstants": [
"Eq.mpr",
"Associates.eq_pow_count_factors_of_dvd_po... | ← eq_pow_count_factors_of_dvd_pow hp h | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.DirectedInverseSystem | {
"line": 367,
"column": 8
} | {
"line": 367,
"column": 56
} | [
{
"pp": "case inl.inr.h\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✝¹ : SuccOrder ι\nequiv : (j : ↑(Iic i)) → F ↑j ≃ piLT X ↑j\ne : F i⁺ ≃ F i × X i\nhi : ¬IsMax i\ninst✝ : InverseSystem f\nH : ∀ (x : F i⁺), (e x).1 = f ⋯ x\nnat : IsN... | ← InverseSystem.map_map (f := f) hk (le_succ i), | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.DirectedInverseSystem | {
"line": 484,
"column": 20
} | {
"line": 484,
"column": 85
} | [
{
"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✝²... | piSplitLE_lt (hi.succ_lt <| (succ_le_iff_of_not_isMax hj).mp hsj) | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Order.Interval.Finset.Gaps | {
"line": 154,
"column": 6
} | {
"line": 154,
"column": 59
} | [
{
"pp": "case pos\nα : Type u_1\ninst✝ : LinearOrder α\nF : Finset (α × α)\nk : ℕ\nh : #F = k\nj✝ : ℕ\na b : α\nhab : a ≤ b\nhFab : ∀ ⦃z : α × α⦄, z ∈ F → a ≤ z.1 ∧ z.1 ≤ z.2 ∧ z.2 ≤ b\nhF : (↑F).PairwiseDisjoint fun z ↦ Icc z.1 z.2\nj : ℕ\nhj : j < k + 1\nhj₁ : j = 0\nhk : 0 = k\n⊢ (F.intervalGapsWithin h a b ... | simp only [natCast_zero, intervalGapsWithin_zero_fst] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.Algebra.BigOperators.Expect | {
"line": 208,
"column": 19
} | {
"line": 208,
"column": 46
} | [
{
"pp": "ι : Type u_1\nκ : Type u_2\nM : Type u_3\ninst✝¹ : AddCommMonoid M\ninst✝ : Module ℚ≥0 M\ns : Finset ι\nf : ι → M\nt : Finset κ\ng : κ → M\ni : (a : ι) → a ∈ s → κ\nhi : ∀ (a : ι) (ha : a ∈ s), i a ha ∈ t\nh : ∀ (a : ι) (ha : a ∈ s), f a = g (i a ha)\ni_inj : ∀ (a₁ : ι) (ha₁ : a₁ ∈ s) (a₂ : ι) (ha₂ : a... | card_bij i hi i_inj i_surj, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.Order.Interval.Finset.Gaps | {
"line": 148,
"column": 75
} | {
"line": 174,
"column": 27
} | [
{
"pp": "α : Type u_1\ninst✝ : LinearOrder α\nF : Finset (α × α)\nk : ℕ\nh : #F = k\nj : ℕ\na b : α\nhab : a ≤ b\nhFab : ∀ ⦃z : α × α⦄, z ∈ F → a ≤ z.1 ∧ z.1 ≤ z.2 ∧ z.2 ≤ b\nhF : (↑F).PairwiseDisjoint fun z ↦ Icc z.1 z.2\n⊢ (F.intervalGapsWithin h a b ↑j).1 ≤ (F.intervalGapsWithin h a b ↑j).2",
"usedConsta... | by
wlog hj : j < k + 1 generalizing j
· convert! this (j : Fin (k + 1)) (by grind) using 3 <;> grind [cast_val_eq_self]
by_cases hj₁ : j = 0
· simp only [hj₁]
by_cases hk : 0 = k
· simp only [natCast_zero, intervalGapsWithin_zero_fst]
simp [show 0 = last k by grind, hab]
· exact hFab (F.interv... | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.BigOperators.Module | {
"line": 36,
"column": 6
} | {
"line": 36,
"column": 33
} | [
{
"pp": "R : Type u_1\nM : Type u_2\ninst✝² : Ring R\ninst✝¹ : AddCommGroup M\ninst✝ : Module R M\nf : ℕ → R\ng : ℕ → M\nm n : ℕ\nhmn : m < n\nh₁ : ∑ i ∈ Ico (m + 1) n, f i • ∑ i ∈ range i, g i = ∑ i ∈ Ico m (n - 1), f (i + 1) • ∑ i ∈ range (i + 1), g i\nh₂ :\n ∑ i ∈ Ico (m + 1) n, f i • ∑ i ∈ range (i + 1), g... | sum_eq_sum_Ico_succ_bot hmn | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Data.List.Sym | {
"line": 185,
"column": 4
} | {
"line": 185,
"column": 43
} | [
{
"pp": "case cons\nα : Type u_1\nxs ys l₁✝ l₂✝ : List α\na : α\nh : l₁✝ <+ l₂✝\nih : l₁✝.sym2 <+ l₂✝.sym2\n⊢ l₁✝.sym2 <+ map (fun y ↦ s(a, y)) (a :: l₂✝) ++ l₂✝.sym2",
"usedConstants": [
"Sym2.mk",
"List.map",
"List.cons",
"List.sym2",
"List.nil_sublist",
"List.Sublist.a... | exact Sublist.append (nil_sublist _) ih | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Data.List.Sym | {
"line": 223,
"column": 24
} | {
"line": 223,
"column": 35
} | [
{
"pp": "case cons\nα : Type u_1\nxs✝ : List α\nx : α\nxs : List α\nih : map (⇑(Sym2.equivSym α)) xs.sym2 = List.sym 2 xs\n⊢ map (⇑(Sym2.equivSym α)) (x :: xs).sym2 =\n map (fun p ↦ x ::ₛ p) (List.sym 1 (x :: xs)) ++ map (⇑(Sym2.equivSym α)) xs.sym2",
"usedConstants": [
"Eq.mpr",
"Equiv.instE... | sym_one_eq, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.BigOperators.WithTop | {
"line": 79,
"column": 4
} | {
"line": 79,
"column": 77
} | [
{
"pp": "case mp\nι : Type u_1\nM₀ : Type u_3\ninst✝³ : CommMonoidWithZero M₀\ninst✝² : NoZeroDivisors M₀\ninst✝¹ : Nontrivial M₀\ninst✝ : DecidableEq M₀\ns : Finset ι\nf : ι → WithTop M₀\n⊢ ∏ j ∈ s, f j = ⊤ → (∃ i ∈ s, f i = ⊤) ∧ ∀ i ∈ s, f i ≠ 0",
"usedConstants": [
"CommMonoidWithZero.toCommMonoid"... | exact fun h ↦ ⟨prod_eq_top_ex_top h, fun _ ih ↦ prod_eq_top_ne_zero ih h⟩ | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.Algebra.BigOperators.WithTop | {
"line": 79,
"column": 4
} | {
"line": 79,
"column": 77
} | [
{
"pp": "case mp\nι : Type u_1\nM₀ : Type u_3\ninst✝³ : CommMonoidWithZero M₀\ninst✝² : NoZeroDivisors M₀\ninst✝¹ : Nontrivial M₀\ninst✝ : DecidableEq M₀\ns : Finset ι\nf : ι → WithTop M₀\n⊢ ∏ j ∈ s, f j = ⊤ → (∃ i ∈ s, f i = ⊤) ∧ ∀ i ∈ s, f i ≠ 0",
"usedConstants": [
"CommMonoidWithZero.toCommMonoid"... | exact fun h ↦ ⟨prod_eq_top_ex_top h, fun _ ih ↦ prod_eq_top_ne_zero ih h⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.BigOperators.WithTop | {
"line": 79,
"column": 4
} | {
"line": 79,
"column": 77
} | [
{
"pp": "case mp\nι : Type u_1\nM₀ : Type u_3\ninst✝³ : CommMonoidWithZero M₀\ninst✝² : NoZeroDivisors M₀\ninst✝¹ : Nontrivial M₀\ninst✝ : DecidableEq M₀\ns : Finset ι\nf : ι → WithTop M₀\n⊢ ∏ j ∈ s, f j = ⊤ → (∃ i ∈ s, f i = ⊤) ∧ ∀ i ∈ s, f i ≠ 0",
"usedConstants": [
"CommMonoidWithZero.toCommMonoid"... | exact fun h ↦ ⟨prod_eq_top_ex_top h, fun _ ih ↦ prod_eq_top_ne_zero ih h⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Data.Sym.Sym2 | {
"line": 275,
"column": 2
} | {
"line": 275,
"column": 53
} | [
{
"pp": "α : Type u_1\nβ : Type u_2\nf : α → β\nhinj : Injective f\nz z' : Sym2 α\n⊢ map f z = map f z' → z = z'",
"usedConstants": [
"Sym2.map",
"Eq",
"Sym2",
"Sym2.inductionOn₂"
]
}
] | refine Sym2.inductionOn₂ z z' (fun x y x' y' => ?_) | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.RingTheory.IsTensorProduct | {
"line": 241,
"column": 10
} | {
"line": 241,
"column": 21
} | [
{
"pp": "case tmul.tmul\nR✝ : Type u_1\ninst✝⁴² : CommSemiring R✝\nM₁✝ : Type u_2\nM₂✝ : Type u_3\nM : Type u_4\nM' : Type u_5\ninst✝⁴¹ : AddCommMonoid M₁✝\ninst✝⁴⁰ : AddCommMonoid M₂✝\ninst✝³⁹ : AddCommMonoid M\ninst✝³⁸ : AddCommMonoid M'\ninst✝³⁷ : Module R✝ M₁✝\ninst✝³⁶ : Module R✝ M₂✝\ninst✝³⁵ : Module R✝ M... | smul_tmul', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.RingTheory.IsTensorProduct | {
"line": 485,
"column": 4
} | {
"line": 488,
"column": 95
} | [
{
"pp": "R : Type u_1\nM : Type v₁\nN : Type v₂\nS : Type v₃\ninst✝⁸ : AddCommMonoid M\ninst✝⁷ : AddCommMonoid N\ninst✝⁶ : CommSemiring R\ninst✝⁵ : CommSemiring S\ninst✝⁴ : Algebra R S\ninst✝³ : Module R M\ninst✝² : Module R N\ninst✝¹ : Module S N\ninst✝ : IsScalarTower R S N\nf : M →ₗ[R] N\nh :\n ∀ (Q : Type ... | refine
{ f' with
map_smul' := fun s x =>
TensorProduct.induction_on x ?_ (fun s' y => smul_assoc s s' _) fun x y hx hy => ?_ } | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.Combinatorics.Quiver.Path | {
"line": 276,
"column": 38
} | {
"line": 276,
"column": 77
} | [
{
"pp": "V✝ : Type u\ninst✝² : Quiver V✝\na b c d : V✝\ninst✝¹ : ∀ (a b : V✝), Subsingleton (a ⟶ b)\nV : Type u_1\ninst✝ : Quiver V\nn : ℕ\nh₁ : DecidableEq V\nh₂ : (v w : V) → DecidableEq (v ⟶ w)\nh₃ : (v w : V) → DecidableEq (BoundedPaths v w n)\nv w : V\np q : Path v w\na✝¹ x✝² v' v'' : V\nx✝¹ x✝ : BoundedPa... | by simp [Quiver.Path.length] at hp; lia | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Opposites | {
"line": 197,
"column": 6
} | {
"line": 197,
"column": 18
} | [
{
"pp": "case hom_inv_id\nC : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\nX Y : Cᵒᵖ\nf : X ⟶ Y\ninst✝ : IsIso f\n⊢ f.unop ≫ (inv f).unop = 𝟙 (unop Y)",
"usedConstants": [
"Eq.mpr",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.op... | ← unop_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Opposites | {
"line": 549,
"column": 25
} | {
"line": 549,
"column": 93
} | [
{
"pp": "C : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\nD : Type u₂\ninst✝ : Category.{v₂, u₂} D\nF G H : Cᵒᵖ ⥤ D\nα : F.rightOp ⟶ G.rightOp\nX Y : Cᵒᵖ\nf : X ⟶ Y\n⊢ (G.map f ≫ (α.app (unop Y)).unop).op = ((α.app (unop X)).unop ≫ F.map f).op",
"usedConstants": [
"Opposite",
"CategoryTheory.CategoryS... | by simpa only [Functor.rightOp_map] using (α.naturality f.unop).symm | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Opposites | {
"line": 615,
"column": 6
} | {
"line": 615,
"column": 18
} | [
{
"pp": "C : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\nD : Type u_1\ninst✝ : Category.{v_1, u_1} D\nF G : C ⥤ Dᵒᵖ\ne : F ≅ G\nX : C\n⊢ (e.hom.app X).unop ≫ (e.inv.app X).unop = 𝟙 (Opposite.unop (G.obj X))",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Functor",
"Opposite",
"CategoryThe... | ← unop_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Opposites | {
"line": 619,
"column": 6
} | {
"line": 619,
"column": 18
} | [
{
"pp": "C : Type u₁\ninst✝¹ : Category.{v₁, u₁} C\nD : Type u_1\ninst✝ : Category.{v_1, u_1} D\nF G : C ⥤ Dᵒᵖ\ne : F ≅ G\nX : C\n⊢ (e.inv.app X).unop ≫ (e.hom.app X).unop = 𝟙 (Opposite.unop (F.obj X))",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Functor",
"Opposite",
"CategoryThe... | ← unop_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.MorphismProperty.Basic | {
"line": 579,
"column": 2
} | {
"line": 582,
"column": 26
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u_1\ninst✝ : Category.{v_1, u_1} D\nW : MorphismProperty C\nF : C ⥤ D\n⊢ W.map F = (W.strictMap F).isoClosure",
"usedConstants": [
"_private.Mathlib.CategoryTheory.MorphismProperty.Basic.0.CategoryTheory.MorphismProperty.map_eq_isoClosure.match... | ext
refine ⟨fun ⟨_, _, f, hf, hf'⟩ ↦ ⟨_, _, _, ⟨hf⟩, hf'⟩, fun ⟨_, _, f, hf, hf'⟩ ↦ ?_⟩
obtain ⟨hf⟩ := hf
exact ⟨_, _, _, hf, hf'⟩ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.MorphismProperty.Basic | {
"line": 579,
"column": 2
} | {
"line": 582,
"column": 26
} | [
{
"pp": "C : Type u\ninst✝¹ : Category.{v, u} C\nD : Type u_1\ninst✝ : Category.{v_1, u_1} D\nW : MorphismProperty C\nF : C ⥤ D\n⊢ W.map F = (W.strictMap F).isoClosure",
"usedConstants": [
"_private.Mathlib.CategoryTheory.MorphismProperty.Basic.0.CategoryTheory.MorphismProperty.map_eq_isoClosure.match... | ext
refine ⟨fun ⟨_, _, f, hf, hf'⟩ ↦ ⟨_, _, _, ⟨hf⟩, hf'⟩, fun ⟨_, _, f, hf, hf'⟩ ↦ ?_⟩
obtain ⟨hf⟩ := hf
exact ⟨_, _, _, hf, hf'⟩ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Algebra.Category.Grp.Basic | {
"line": 596,
"column": 4
} | {
"line": 596,
"column": 46
} | [
{
"pp": "X Y : CommGrpCat\nf : X ⟶ Y\nx✝ : IsIso ((forget CommGrpCat).map f)\n⊢ IsIso f",
"usedConstants": [
"MonoidHom.instFunLike",
"MonoidHom",
"Monoid.toMulOneClass",
"CommGrpCat.instCategory",
"CommGrpCat.str",
"CategoryTheory.Iso",
"DivInvMonoid.toMonoid",
... | let i := asIso ((forget CommGrpCat).map f) | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticLet___1 | Lean.Parser.Tactic.tacticLet__ |
Mathlib.Algebra.Category.Grp.Basic | {
"line": 596,
"column": 4
} | {
"line": 598,
"column": 34
} | [
{
"pp": "X Y : CommGrpCat\nf : X ⟶ Y\nx✝ : IsIso ((forget CommGrpCat).map f)\n⊢ IsIso f",
"usedConstants": [
"MonoidHom.instMonoidHomClass",
"MonoidHom.instFunLike",
"HMul.hMul",
"MonoidHom",
"Monoid.toMulOneClass",
"CategoryTheory.Iso.toEquiv",
"congrArg",
"C... | let i := asIso ((forget CommGrpCat).map f)
let e : X ≃* Y := { i.toEquiv with map_mul' := by simp [Iso.toEquiv, i] }
exact e.toCommGrpIso.isIso_hom | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Algebra.Category.Grp.Basic | {
"line": 596,
"column": 4
} | {
"line": 598,
"column": 34
} | [
{
"pp": "X Y : CommGrpCat\nf : X ⟶ Y\nx✝ : IsIso ((forget CommGrpCat).map f)\n⊢ IsIso f",
"usedConstants": [
"MonoidHom.instMonoidHomClass",
"MonoidHom.instFunLike",
"HMul.hMul",
"MonoidHom",
"Monoid.toMulOneClass",
"CategoryTheory.Iso.toEquiv",
"congrArg",
"C... | let i := asIso ((forget CommGrpCat).map f)
let e : X ≃* Y := { i.toEquiv with map_mul' := by simp [Iso.toEquiv, i] }
exact e.toCommGrpIso.isIso_hom | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Yoneda | {
"line": 345,
"column": 8
} | {
"line": 345,
"column": 51
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nF : Cᵒᵖ ⥤ Type v\nY Y' : C\ne : F.RepresentableBy Y\ne' : F.RepresentableBy Y'\nε : {X : C} → (X ⟶ Y) ≃ (X ⟶ Y') := fun {X} ↦ e.homEquiv.trans e'.homEquiv.symm\n⊢ ∀ {Z Z' : C} (f : Z' ⟶ Z) (g : Z ⟶ Y), (fun {Z} ↦ ⇑ε) (f ≫ g) = f ≫ (fun {Z} ↦ ⇑ε) g",
"usedCo... | simp [ε, comp_homEquiv_symm, homEquiv_comp] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.CategoryTheory.Yoneda | {
"line": 345,
"column": 8
} | {
"line": 345,
"column": 51
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nF : Cᵒᵖ ⥤ Type v\nY Y' : C\ne : F.RepresentableBy Y\ne' : F.RepresentableBy Y'\nε : {X : C} → (X ⟶ Y) ≃ (X ⟶ Y') := fun {X} ↦ e.homEquiv.trans e'.homEquiv.symm\n⊢ ∀ {Z Z' : C} (f : Z' ⟶ Z) (g : Z ⟶ Y), (fun {Z} ↦ ⇑ε) (f ≫ g) = f ≫ (fun {Z} ↦ ⇑ε) g",
"usedCo... | simp [ε, comp_homEquiv_symm, homEquiv_comp] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.CategoryTheory.Yoneda | {
"line": 345,
"column": 8
} | {
"line": 345,
"column": 51
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nF : Cᵒᵖ ⥤ Type v\nY Y' : C\ne : F.RepresentableBy Y\ne' : F.RepresentableBy Y'\nε : {X : C} → (X ⟶ Y) ≃ (X ⟶ Y') := fun {X} ↦ e.homEquiv.trans e'.homEquiv.symm\n⊢ ∀ {Z Z' : C} (f : Z' ⟶ Z) (g : Z ⟶ Y), (fun {Z} ↦ ⇑ε) (f ≫ g) = f ≫ (fun {Z} ↦ ⇑ε) g",
"usedCo... | simp [ε, comp_homEquiv_symm, homEquiv_comp] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.CategoryTheory.Yoneda | {
"line": 353,
"column": 5
} | {
"line": 353,
"column": 51
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nF : C ⥤ Type v\nX X' : C\ne : F.CorepresentableBy X\ne' : F.CorepresentableBy X'\nε : {Y : C} → (X ⟶ Y) ≃ (X' ⟶ Y) := fun {Y} ↦ e.homEquiv.trans e'.homEquiv.symm\n⊢ ∀ {Z Z' : C} (f : X' ⟶ Z) (g : Z ⟶ Z'), (fun {Z} ↦ ⇑ε.symm) (f ≫ g) = (fun {Z} ↦ ⇑ε.symm) f ≫ g"... | by simp [ε, homEquiv_symm_comp, homEquiv_comp] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.IsLimit | {
"line": 469,
"column": 85
} | {
"line": 470,
"column": 29
} | [
{
"pp": "J : Type u₁\ninst✝¹ : Category.{v₁, u₁} J\nC : Type u₃\ninst✝ : Category.{v₃, u₃} C\nF : J ⥤ C\nX : C\nh : F.cones.RepresentableBy X\nY : C\nf : Y ⟶ X\n⊢ homOfCone h (coneOfHom h f) = f",
"usedConstants": [
"CategoryTheory.Functor",
"CategoryTheory.CategoryStruct.toQuiver",
"Quive... | by
simp [coneOfHom, homOfCone] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Yoneda | {
"line": 1119,
"column": 2
} | {
"line": 1119,
"column": 48
} | [
{
"pp": "C : Type u₁\ninst✝ : Category.{v₁, u₁} C\nX Y : C\nf : X ⟶ Y\nhf : ∀ (T : C), Function.Bijective fun x ↦ f ≫ x\n⊢ IsIso f",
"usedConstants": [
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"CategoryTheory.CategoryStruct.id",
"And.right",
"CategoryTheory.Categ... | obtain ⟨g, hg : f ≫ g = 𝟙 X⟩ := (hf X).2 (𝟙 X) | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalObtain | Lean.Parser.Tactic.obtain |
Mathlib.CategoryTheory.CommSq | {
"line": 114,
"column": 3
} | {
"line": 114,
"column": 77
} | [
{
"pp": "C : Type u_1\ninst✝ : Category.{v_1, u_1} C\nW X X' Y Z Z' : C\nf : W ⟶ X\nf' : X ⟶ X'\ng : W ⟶ Y\nh : X ⟶ Z\nh' : X' ⟶ Z'\ni : Y ⟶ Z\ni' : Z ⟶ Z'\nhsq₁ : CommSq f g h i\nhsq₂ : CommSq f' h h' i'\n⊢ (f ≫ f') ≫ h' = g ≫ i ≫ i'",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Category.assoc... | by rw [← Category.assoc, Category.assoc, ← hsq₁.w, hsq₂.w, Category.assoc] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.CommSq | {
"line": 216,
"column": 21
} | {
"line": 216,
"column": 33
} | [
{
"pp": "C : Type u_1\ninst✝ : Category.{v_1, u_1} C\nA✝ B✝ X✝ Y✝ : C\nf✝ : A✝ ⟶ X✝\ni✝ : A✝ ⟶ B✝\np✝ : X✝ ⟶ Y✝\ng✝ : B✝ ⟶ Y✝\nA B X Y : Cᵒᵖ\nf : A ⟶ X\ni : A ⟶ B\np : X ⟶ Y\ng : B ⟶ Y\nsq : CommSq f i p g\nl : sq.LiftStruct\n⊢ p.unop ≫ l.l.unop = g.unop",
"usedConstants": [
"Eq.mpr",
"Opposite"... | ← unop_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.CommSq | {
"line": 217,
"column": 22
} | {
"line": 217,
"column": 34
} | [
{
"pp": "C : Type u_1\ninst✝ : Category.{v_1, u_1} C\nA✝ B✝ X✝ Y✝ : C\nf✝ : A✝ ⟶ X✝\ni✝ : A✝ ⟶ B✝\np✝ : X✝ ⟶ Y✝\ng✝ : B✝ ⟶ Y✝\nA B X Y : Cᵒᵖ\nf : A ⟶ X\ni : A ⟶ B\np : X ⟶ Y\ng : B ⟶ Y\nsq : CommSq f i p g\nl : sq.LiftStruct\n⊢ l.l.unop ≫ i.unop = f.unop",
"usedConstants": [
"Eq.mpr",
"Opposite"... | ← unop_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.LiftingProperties.Adjunction | {
"line": 61,
"column": 8
} | {
"line": 61,
"column": 41
} | [
{
"pp": "C : Type u_1\nD : Type u_2\ninst✝¹ : Category.{v_1, u_1} C\ninst✝ : Category.{v_2, u_2} D\nG : C ⥤ D\nF : D ⥤ C\nA B : C\nX Y : D\ni : A ⟶ B\np : X ⟶ Y\nu : G.obj A ⟶ X\nv : G.obj B ⟶ Y\nsq : CommSq u (G.map i) p v\nadj : G ⊣ F\nl : ⋯.LiftStruct\n⊢ (adj.homEquiv A X).symm ((adj.homEquiv A X) u) = u",
... | apply (adj.homEquiv _ _).left_inv | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.CategoryTheory.LiftingProperties.Adjunction | {
"line": 64,
"column": 8
} | {
"line": 64,
"column": 41
} | [
{
"pp": "C : Type u_1\nD : Type u_2\ninst✝¹ : Category.{v_1, u_1} C\ninst✝ : Category.{v_2, u_2} D\nG : C ⥤ D\nF : D ⥤ C\nA B : C\nX Y : D\ni : A ⟶ B\np : X ⟶ Y\nu : G.obj A ⟶ X\nv : G.obj B ⟶ Y\nsq : CommSq u (G.map i) p v\nadj : G ⊣ F\nl : ⋯.LiftStruct\n⊢ (adj.homEquiv B Y).symm ((adj.homEquiv B Y) v) = v",
... | apply (adj.homEquiv _ _).left_inv | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.CategoryTheory.PUnit | {
"line": 80,
"column": 4
} | {
"line": 80,
"column": 23
} | [
{
"pp": "case mp.allEq\nC : Type u\ninst✝ : Category.{v, u} C\nh : C ≌ Discrete PUnit.{w + 1}\nx y : C\nf : x ⟶ y :=\n have hx := ⋯.mpr (h.unit.app x);\n have hy := ⋯.mpr (h.unitInv.app y);\n hx ≫ hy\nthis : ∀ (z : x ⟶ y), z = h.unit.app x ≫ (h.functor ⋙ h.inverse).map z ≫ h.unitInv.app y\na b : x ⟶ y\n⊢ a =... | rw [this a, this b] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.CategoryTheory.Limits.Shapes.Products | {
"line": 947,
"column": 4
} | {
"line": 947,
"column": 38
} | [
{
"pp": "β : Type w\nα : Type w₂\nγ : Type w₃\nC : Type u\ninst✝³ : Category.{v, u} C\nJ : Type u₂\ninst✝² : Category.{v₂, u₂} J\nF : J ⥤ C\ninst✝¹ : HasColimit F\ninst✝ : HasCoproduct F.obj\nZ✝ : C\nx✝¹ x✝ : colimit F ⟶ Z✝\nh : Sigma.desc (colimit.ι F) ≫ x✝¹ = Sigma.desc (colimit.ι F) ≫ x✝\n⊢ x✝¹ = x✝",
"u... | refine colimit.hom_ext fun j => ?_ | Lean.Elab.Tactic.evalRefine | Lean.Parser.Tactic.refine |
Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | {
"line": 325,
"column": 89
} | {
"line": 327,
"column": 32
} | [
{
"pp": "C : Type u\ninst✝ : Category.{v, u} C\nX Y Z : C\nf : X ⟶ Y\ng : X ⟶ Z\nt : PushoutCocone f g\n⊢ t.ι.app WalkingSpan.zero = f ≫ t.inl",
"usedConstants": [
"CategoryTheory.Functor",
"CategoryTheory.Limits.WalkingSpan",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
... | by
have w := t.ι.naturality WalkingSpan.Hom.fst
dsimp at w; simpa using w.symm | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Limits.Shapes.Images | {
"line": 604,
"column": 2
} | {
"line": 604,
"column": 78
} | [
{
"pp": "C : Type u\ninst✝⁴ : Category.{v, u} C\nX Y : C\nf : X ⟶ Y\nZ : C\ng : Y ⟶ Z\ninst✝³ : HasEqualizers C\ninst✝² : HasImage g\ninst✝¹ : HasImage (f ≫ g)\ninst✝ : Epi f\n⊢ Epi (preComp f g)",
"usedConstants": [
"CategoryTheory.Limits.factorThruImage",
"CategoryTheory.Limits.image.preComp",... | apply @epi_of_epi_fac _ _ _ _ _ _ _ _ ?_ (image.factorThruImage_preComp _ _) | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.CategoryTheory.Comma.Over.Basic | {
"line": 1341,
"column": 67
} | {
"line": 1341,
"column": 79
} | [
{
"pp": "T : Type u₁\ninst✝¹ : Category.{v₁, u₁} T\nD : Type u₂\ninst✝ : Category.{v₂, u₂} D\nX : T\nZ Y : Over (op X)\nf : Z ⟶ Y\n⊢ Y.hom.unop ≫ (Hom.left f).unop = Z.hom.unop",
"usedConstants": [
"Eq.mpr",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
"C... | ← unop_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.CategoryTheory.Comma.Over.Basic | {
"line": 1351,
"column": 67
} | {
"line": 1351,
"column": 79
} | [
{
"pp": "T : Type u₁\ninst✝¹ : Category.{v₁, u₁} T\nD : Type u₂\ninst✝ : Category.{v₂, u₂} D\nX : T\nZ Y : Under (op X)\nf : Z ⟶ Y\n⊢ (Hom.right f).unop ≫ Z.hom.unop = Y.hom.unop",
"usedConstants": [
"Eq.mpr",
"Opposite",
"CategoryTheory.CategoryStruct.toQuiver",
"Quiver.Hom",
... | ← unop_comp, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Group.Ext | {
"line": 134,
"column": 4
} | {
"line": 134,
"column": 11
} | [
{
"pp": "M : Type u_1\nm₁ m₂ : DivInvMonoid M\nh_mul : HMul.hMul = HMul.hMul\nh_inv : Inv.inv = Inv.inv\nh_mon : m₁.toMonoid = m₂.toMonoid\nh₁ : One.one = One.one\nf : M →* M := { toFun := id, map_one' := h₁, map_mul' := ⋯ }\n⊢ DivInvMonoid.zpow = DivInvMonoid.zpow",
"usedConstants": [
"Int",
"D... | ext m x | _private.Lean.Elab.Tactic.Ext.0.Lean.Elab.Tactic.Ext.evalExt | Lean.Elab.Tactic.Ext.ext |
Mathlib.CategoryTheory.Limits.Shapes.Kernels | {
"line": 122,
"column": 32
} | {
"line": 122,
"column": 46
} | [
{
"pp": "C : Type u\ninst✝⁴ : Category.{v, u} C\ninst✝³ : HasZeroMorphisms C\nX Y : C\nf : X ⟶ Y\nD : Type u'\ninst✝² : Category.{v, u'} D\ninst✝¹ : HasZeroMorphisms D\nF : C ⥤ D\ninst✝ : F.IsEquivalence\napp : (j : WalkingParallelPair) → (parallelPair f 0 ⋙ F).obj j ≅ (parallelPair (F.map f) 0).obj j :=\n fun... | rintro ⟨i⟩ ⟨j⟩ | _private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.evalRIntro | Lean.Parser.Tactic.rintro |
Mathlib.CategoryTheory.Limits.Shapes.Kernels | {
"line": 1048,
"column": 28
} | {
"line": 1049,
"column": 76
} | [
{
"pp": "C : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : HasZeroMorphisms C\nX Y : C\nf : X ⟶ Y\ninst✝ : HasKernel f\nF : MonoFactorisation f\n⊢ kernel.ι f ≫ F.e = 0",
"usedConstants": [
"CategoryTheory.Limits.MonoFactorisation.fac",
"CategoryTheory.Limits.MonoFactorisation.I",
"Eq.mpr",
... | by
rw [← cancel_mono F.m, zero_comp, Category.assoc, F.fac, kernel.condition] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | {
"line": 144,
"column": 22
} | {
"line": 146,
"column": 65
} | [
{
"pp": "C : Type u_1\nD : Type u_2\ninst✝³ : Category.{v_1, u_1} C\ninst✝² : Category.{v_2, u_2} D\ninst✝¹ : Preadditive C\ninst✝ : Preadditive D\nF : C ⥤ D\nhF : IsZero F\nx✝³ x✝² : C\nx✝¹ x✝ : x✝³ ⟶ x✝²\n⊢ IsZero (F.obj x✝²)",
"usedConstants": [
"Eq.mpr",
"CategoryTheory.Functor",
"Cate... | by
rw [IsZero.iff_id_eq_zero]
exact NatTrans.congr_app ((IsZero.iff_id_eq_zero _).1 hF) _ | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.CategoryTheory.Preadditive.Biproducts | {
"line": 660,
"column": 4
} | {
"line": 660,
"column": 25
} | [
{
"pp": "C✝ : Type u\ninst✝⁴ : Category.{v, u} C✝\ninst✝³ : Preadditive C✝\nC : Type u\ninst✝² : Category.{v, u} C\ninst✝¹ : HasZeroMorphisms C\ninst✝ : HasBinaryBiproducts C\na b : Preadditive C\n⊢ a = b",
"usedConstants": [
"CategoryTheory.Preadditive.ext"
]
}
] | apply Preadditive.ext | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.Data.Fin.Tuple.NatAntidiagonal | {
"line": 155,
"column": 6
} | {
"line": 156,
"column": 39
} | [
{
"pp": "case zero\nk : ℕ\n⊢ Pairwise\n (fun a₁ a₂ ↦\n ∀ a ∈ antidiagonalTuple k a₁.2,\n ∀ a_2 ∈ antidiagonalTuple k a₂.2,\n a₁.1 < a₂.1 ∨ a₁.1 = a₂.1 ∧ Pi.Lex (fun x1 x2 ↦ x1 < x2) (fun i x1 x2 ↦ x1 < x2) a a_2)\n (antidiagonal 0)",
"usedConstants": [
"Eq.mpr",
"List.... | rw [antidiagonal_zero]
exact List.pairwise_singleton _ _ | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.Data.Fin.Tuple.NatAntidiagonal | {
"line": 155,
"column": 6
} | {
"line": 156,
"column": 39
} | [
{
"pp": "case zero\nk : ℕ\n⊢ Pairwise\n (fun a₁ a₂ ↦\n ∀ a ∈ antidiagonalTuple k a₁.2,\n ∀ a_2 ∈ antidiagonalTuple k a₂.2,\n a₁.1 < a₂.1 ∨ a₁.1 = a₂.1 ∧ Pi.Lex (fun x1 x2 ↦ x1 < x2) (fun i x1 x2 ↦ x1 < x2) a a_2)\n (antidiagonal 0)",
"usedConstants": [
"Eq.mpr",
"List.... | rw [antidiagonal_zero]
exact List.pairwise_singleton _ _ | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.Combinatorics.Enumerative.Partition.Basic | {
"line": 225,
"column": 6
} | {
"line": 225,
"column": 37
} | [
{
"pp": "n : ℕ\nx : n.Partition\n⊢ (∀ i ∈ x.parts, count i x.parts < 2) ↔ x.parts.Nodup",
"usedConstants": [
"Eq.mpr",
"Multiset.nodup_iff_count_le_one",
"Multiset.Nodup",
"congrArg",
"Nat.Partition.parts",
"Membership.mem",
"Multiset.count",
"Multiset",
... | Multiset.nodup_iff_count_le_one | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.Algebra.Order.Antidiag.Pi | {
"line": 68,
"column": 12
} | {
"line": 68,
"column": 48
} | [
{
"pp": "ι : Type u_1\nμ : Type u_2\nμ' : Type u_3\ninst✝³ : DecidableEq ι\ninst✝² : AddCommMonoid μ\ninst✝¹ : HasAntidiagonal μ\ninst✝ : DecidableEq μ\nn✝ : μ\nd : ℕ\nn : μ\nh : n = 0\n⊢ ∀ (f : Fin 0 → μ), f ∈ {0} ↔ ∑ i, f i = n",
"usedConstants": [
"Finset.univ",
"congrArg",
"Finset",
... | by simp [h, Subsingleton.elim _ ![]] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.Algebra.Order.Antidiag.Pi | {
"line": 82,
"column": 10
} | {
"line": 82,
"column": 24
} | [
{
"pp": "case fst\nι : Type u_1\nμ : Type u_2\nμ' : Type u_3\ninst✝³ : DecidableEq ι\ninst✝² : AddCommMonoid μ\ninst✝¹ : HasAntidiagonal μ\ninst✝ : DecidableEq μ\nn✝ : μ\nd✝ : ℕ\nn : μ\nd : ℕ\ni : μ × μ\n_hi : i ∈ ↑(antidiagonal n)\nj : μ × μ\n_hj : j ∈ ↑(antidiagonal n)\nhij : i ≠ j\nai : Fin d → μ\nhai : ai ∈... | · exact hij'.1 | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.GroupTheory.Perm.Support | {
"line": 380,
"column": 58
} | {
"line": 386,
"column": 80
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nf g : Perm α\nh : ∀ x ∈ f.support ∩ g.support, f x = g x\nk : ℕ\n⊢ ∀ x ∈ f.support ∩ g.support, (f ^ k) x = (g ^ k) x",
"usedConstants": [
"Eq.mpr",
"Equiv.Perm.support",
"MulOne.toOne",
"Nat.recAux",
"Equiv.inst... | by
induction k with
| zero => simp
| succ k hk =>
intro x hx
rw [pow_succ, mul_apply, pow_succ, mul_apply, h _ hx, hk]
rwa [mem_inter, apply_mem_support, ← h _ hx, apply_mem_support, ← mem_inter] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.Perm.Finite | {
"line": 169,
"column": 8
} | {
"line": 170,
"column": 83
} | [
{
"pp": "case pos.refine_1\nα : Type u\nβ : Type v\np : β → Prop\ninst✝ : DecidablePred p\nf : α ≃ Subtype p\nσ τ : Perm α\nh : σ.Disjoint τ\nb : β\npb : p b\n⊢ σ (f.symm ⟨b, pb⟩) = f.symm ⟨b, pb⟩ → (σ.extendDomain f) b = b",
"usedConstants": [
"Subtype.coe_mk",
"Eq.mpr",
"Equiv.apply_symm... | intro h
rw [extendDomain_apply_subtype _ _ pb, h, apply_symm_apply, Subtype.coe_mk] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Perm.Finite | {
"line": 169,
"column": 8
} | {
"line": 170,
"column": 83
} | [
{
"pp": "case pos.refine_1\nα : Type u\nβ : Type v\np : β → Prop\ninst✝ : DecidablePred p\nf : α ≃ Subtype p\nσ τ : Perm α\nh : σ.Disjoint τ\nb : β\npb : p b\n⊢ σ (f.symm ⟨b, pb⟩) = f.symm ⟨b, pb⟩ → (σ.extendDomain f) b = b",
"usedConstants": [
"Subtype.coe_mk",
"Eq.mpr",
"Equiv.apply_symm... | intro h
rw [extendDomain_apply_subtype _ _ pb, h, apply_symm_apply, Subtype.coe_mk] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Perm.Finite | {
"line": 169,
"column": 8
} | {
"line": 170,
"column": 83
} | [
{
"pp": "case pos.refine_2\nα : Type u\nβ : Type v\np : β → Prop\ninst✝ : DecidablePred p\nf : α ≃ Subtype p\nσ τ : Perm α\nh : σ.Disjoint τ\nb : β\npb : p b\n⊢ τ (f.symm ⟨b, pb⟩) = f.symm ⟨b, pb⟩ → (τ.extendDomain f) b = b",
"usedConstants": [
"Subtype.coe_mk",
"Eq.mpr",
"Equiv.apply_symm... | intro h
rw [extendDomain_apply_subtype _ _ pb, h, apply_symm_apply, Subtype.coe_mk] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Perm.Finite | {
"line": 169,
"column": 8
} | {
"line": 170,
"column": 83
} | [
{
"pp": "case pos.refine_2\nα : Type u\nβ : Type v\np : β → Prop\ninst✝ : DecidablePred p\nf : α ≃ Subtype p\nσ τ : Perm α\nh : σ.Disjoint τ\nb : β\npb : p b\n⊢ τ (f.symm ⟨b, pb⟩) = f.symm ⟨b, pb⟩ → (τ.extendDomain f) b = b",
"usedConstants": [
"Subtype.coe_mk",
"Eq.mpr",
"Equiv.apply_symm... | intro h
rw [extendDomain_apply_subtype _ _ pb, h, apply_symm_apply, Subtype.coe_mk] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Perm.Support | {
"line": 590,
"column": 47
} | {
"line": 590,
"column": 100
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nf : Perm α\nh : #f.support = 2\nx y : α\nhmem : ¬x = y\nhins : {x, y} = f.support\nht : #{y} = 1\na b : α\n⊢ f b ≠ b ↔ ?m.105 b",
"usedConstants": [
"Eq.mpr",
"Equiv.Perm.support",
"Finset.mem_singleton",
"Equiv.instEq... | rw [← mem_support, ← hins, mem_insert, mem_singleton] | Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_rwSeq_1 | Lean.Parser.Tactic.rwSeq |
Mathlib.GroupTheory.Perm.Support | {
"line": 590,
"column": 47
} | {
"line": 590,
"column": 100
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nf : Perm α\nh : #f.support = 2\nx y : α\nhmem : ¬x = y\nhins : {x, y} = f.support\nht : #{y} = 1\na b : α\n⊢ f b ≠ b ↔ ?m.105 b",
"usedConstants": [
"Eq.mpr",
"Equiv.Perm.support",
"Finset.mem_singleton",
"Equiv.instEq... | rw [← mem_support, ← hins, mem_insert, mem_singleton] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Perm.Support | {
"line": 590,
"column": 47
} | {
"line": 590,
"column": 100
} | [
{
"pp": "α : Type u_1\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nf : Perm α\nh : #f.support = 2\nx y : α\nhmem : ¬x = y\nhins : {x, y} = f.support\nht : #{y} = 1\na b : α\n⊢ f b ≠ b ↔ ?m.105 b",
"usedConstants": [
"Eq.mpr",
"Equiv.Perm.support",
"Finset.mem_singleton",
"Equiv.instEq... | rw [← mem_support, ← hins, mem_insert, mem_singleton] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Perm.List | {
"line": 222,
"column": 8
} | {
"line": 222,
"column": 36
} | [
{
"pp": "case pos\nα : Type u_1\ninst✝ : DecidableEq α\nl : List α\nh : l.Nodup\nh' : (l.rotate 1).Nodup\nk : ℕ\nhk : k < (l.rotate 1).length\nhx : (l.rotate 1)[k] ∈ l.rotate 1\n⊢ (l.rotate 1).formPerm (l.rotate 1)[k] = l.formPerm (l.rotate 1)[k]",
"usedConstants": [
"Eq.mpr",
"Nat.zero_le",
... | formPerm_apply_getElem _ h', | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.Finite | {
"line": 274,
"column": 4
} | {
"line": 274,
"column": 51
} | [
{
"pp": "case inv\nα : Type u\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nS : Set (Perm α)\n⊢ ∀ x ∈ closure S, ↑x.support ⊆ ⋃ b ∈ S, ↑b.support → ↑x⁻¹.support ⊆ ⋃ b ∈ S, ↑b.support",
"usedConstants": [
"Equiv.Perm.support",
"Subgroup.closure",
"DivInvOneMonoid.toInvOneClass",
"congrA... | simp only [support_inv, imp_self, implies_true] | Lean.Elab.Tactic.evalSimp | Lean.Parser.Tactic.simp |
Mathlib.GroupTheory.Perm.Finite | {
"line": 274,
"column": 4
} | {
"line": 274,
"column": 51
} | [
{
"pp": "case inv\nα : Type u\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nS : Set (Perm α)\n⊢ ∀ x ∈ closure S, ↑x.support ⊆ ⋃ b ∈ S, ↑b.support → ↑x⁻¹.support ⊆ ⋃ b ∈ S, ↑b.support",
"usedConstants": [
"Equiv.Perm.support",
"Subgroup.closure",
"DivInvOneMonoid.toInvOneClass",
"congrA... | simp only [support_inv, imp_self, implies_true] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.GroupTheory.Perm.Finite | {
"line": 274,
"column": 4
} | {
"line": 274,
"column": 51
} | [
{
"pp": "case inv\nα : Type u\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nS : Set (Perm α)\n⊢ ∀ x ∈ closure S, ↑x.support ⊆ ⋃ b ∈ S, ↑b.support → ↑x⁻¹.support ⊆ ⋃ b ∈ S, ↑b.support",
"usedConstants": [
"Equiv.Perm.support",
"Subgroup.closure",
"DivInvOneMonoid.toInvOneClass",
"congrA... | simp only [support_inv, imp_self, implies_true] | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.GroupTheory.Perm.Finite | {
"line": 283,
"column": 37
} | {
"line": 283,
"column": 63
} | [
{
"pp": "α : Type u\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nS T : Set (Perm α)\nh : ∀ a ∈ S, ∀ b ∈ T, _root_.Disjoint a.support b.support\na : Perm α\nha : a ∈ closure S\nb : Perm α\nhb : b ∈ closure T\nkey1 : ↑a.support ⊆ ⋃ b ∈ S, ↑b.support\nkey2 : ↑b.support ⊆ ⋃ b ∈ T, ↑b.support\nkey : (∀ i ∈ S, _root_.... | Set.disjoint_iUnion_right, | Mathlib.Tactic._aux_Mathlib_Tactic_SimpRw___elabRules_Mathlib_Tactic_tacticSimp_rw____1 | null |
Mathlib.GroupTheory.Perm.Finite | {
"line": 278,
"column": 77
} | {
"line": 284,
"column": 13
} | [
{
"pp": "α : Type u\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nS T : Set (Perm α)\nh : ∀ a ∈ S, ∀ b ∈ T, _root_.Disjoint a.support b.support\n⊢ ∀ a ∈ closure S, ∀ b ∈ closure T, _root_.Disjoint a.support b.support",
"usedConstants": [
"Equiv.Perm.support_closure_subset_union",
"Equiv.Perm.suppo... | by
intro a ha b hb
have key1 := support_closure_subset_union S a ha
have key2 := support_closure_subset_union T b hb
have key := Set.disjoint_of_subset key1 key2
simp_rw [Set.disjoint_iUnion_left, Set.disjoint_iUnion_right, Finset.disjoint_coe] at key
exact key h | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.Perm.Closure | {
"line": 106,
"column": 18
} | {
"line": 106,
"column": 58
} | [
{
"pp": "α : Type u_2\ninst✝¹ : DecidableEq α\ninst✝ : Fintype α\nn : ℕ\nσ : Perm α\nh0 : n.Coprime (orderOf σ)\nh1 : σ.IsCycle\nh2 : σ.support = univ\nx : α\nm : ℕ\nhm : (σ ^ n) ^ m = σ\nh2' : (σ ^ n).support = univ\nh1' : (σ ^ n).IsCycle\n⊢ ⊤ ≤ closure {σ, swap x ((σ ^ n) x)}",
"usedConstants": [
"E... | ← closure_cycle_adjacent_swap h1' h2' x, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.GroupTheory.Perm.Sign | {
"line": 194,
"column": 2
} | {
"line": 195,
"column": 81
} | [
{
"pp": "n : ℕ\nf : Perm (Fin n)\na₁ a₂ : Fin n\nha : ⟨a₁, a₂⟩.snd < ⟨a₁, a₂⟩.fst\nb₁ b₂ : Fin n\nhb : ⟨b₁, b₂⟩.snd < ⟨b₁, b₂⟩.fst\nh : (if f a₂ < f a₁ then ⟨f a₁, f a₂⟩ else ⟨f a₂, f a₁⟩) = if f b₂ < f b₁ then ⟨f b₁, f b₂⟩ else ⟨f b₂, f b₁⟩\nthis : ¬b₁ < b₂\n⊢ ⟨a₁, a₂⟩ = ⟨b₁, b₂⟩",
"usedConstants": [
... | split_ifs at h <;>
simp_all only [not_lt, Sigma.mk.inj_iff, (Equiv.injective f).eq_iff, heq_eq_eq] | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.GroupTheory.Perm.Cycle.Basic | {
"line": 397,
"column": 6
} | {
"line": 397,
"column": 60
} | [
{
"pp": "α : Type u_4\ninst✝ : DecidableEq α\nn : ℕ\nb x : α\nf : Perm α\nhb : (swap x (f x) * f) b ≠ b\nh : (f ^ Int.negSucc n) (f x) = b\nhfxb : f x ≠ b\nhfb : f b ≠ b\nhbx : b ≠ x\n⊢ (if f⁻¹ ((Equiv.symm f) b) = x then (Equiv.symm f) x\n else if f⁻¹ ((Equiv.symm f) b) = (Equiv.symm f) x then x else f⁻¹ ((... | split_ifs <;> simp [symm_apply_eq, eq_symm_apply] at * | Lean.Parser.Tactic.«_aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tactic_<;>__1» | Lean.Parser.Tactic.«tactic_<;>_» |
Mathlib.GroupTheory.NoncommPiCoprod | {
"line": 164,
"column": 4
} | {
"line": 164,
"column": 35
} | [
{
"pp": "case a\nM : Type u_1\ninst✝² : Monoid M\nι : Type u_2\ninst✝¹ : Fintype ι\nN : ι → Type u_3\ninst✝ : (i : ι) → Monoid (N i)\nϕ : (i : ι) → N i →* M\nhcomm : Pairwise fun i j ↦ ∀ (x : N i) (y : N j), Commute ((ϕ i) x) ((ϕ j) y)\nthis : DecidableEq ι := Classical.decEq ι\nf : (i : ι) → N i\ni : ι\nx✝ : i... | apply Submonoid.mem_sSup_of_mem | Lean.Elab.Tactic.evalApply | Lean.Parser.Tactic.apply |
Mathlib.GroupTheory.Perm.Fin | {
"line": 163,
"column": 79
} | {
"line": 163,
"column": 91
} | [
{
"pp": "n : ℕ\ni j : Fin n\ninst✝ : NeZero n\nh : i ≤ j\niin : i ∈ Set.range ⇑(castLEEmb ⋯)\nthis : (castLEEmb ⋯).toEquivRange (i.castLT ⋯) = ⟨i, iin⟩\nch : i = j\n⊢ ↑(i.castLT ⋯) = ↑(last ↑j)",
"usedConstants": [
"congrArg",
"instOfNatNat",
"Fin.val",
"instHAdd",
"HAdd.hAdd",... | by simp [ch] | [anonymous] | Lean.Parser.Term.byTactic |
Mathlib.GroupTheory.Perm.Fin | {
"line": 239,
"column": 2
} | {
"line": 241,
"column": 24
} | [
{
"pp": "case succ.inr.inl\nn✝ : ℕ\ni j : Fin (n✝ + 1)\nheq : j = i\n⊢ i.succ.succAbove (i.cycleRange j) = (swap 0 i.succ) j.succ",
"usedConstants": [
"Fin.succAbove",
"Eq.mpr",
"instNeZeroNatHAdd_1",
"Equiv.instEquivLike",
"Fin.succ",
"congrArg",
"instDecidableEqFi... | · rw [heq, Fin.cycleRange_self, Fin.succAbove_of_castSucc_lt, swap_apply_right, Fin.castSucc_zero]
· rw [Fin.castSucc_zero]
apply Fin.succ_pos | Lean.Elab.Tactic.evalTacticCDot | Lean.cdot |
Mathlib.GroupTheory.Perm.Cycle.Type | {
"line": 305,
"column": 20
} | {
"line": 305,
"column": 37
} | [
{
"pp": "case base_one\nα : Type u_1\ninst✝⁴ : Fintype α\ninst✝³ : DecidableEq α\nβ : Type u_2\ninst✝² : Fintype β\ninst✝¹ : DecidableEq β\np : β → Prop\ninst✝ : DecidablePred p\nf : α ≃ Subtype p\n⊢ (extendDomain 1 f).cycleType = cycleType 1",
"usedConstants": [
"Eq.mpr",
"Equiv.Perm.cycleType"... | extendDomain_one, | Lean.Elab.Tactic.evalRewriteSeq | null |
Mathlib.LinearAlgebra.Alternating.Basic | {
"line": 901,
"column": 4
} | {
"line": 901,
"column": 16
} | [
{
"pp": "case pos\nι : Type u_7\nι₁ : Type u_10\ninst✝⁵ : Finite ι\nR' : Type u_11\nN₁ : Type u_12\nN₂ : Type u_13\ninst✝⁴ : CommSemiring R'\ninst✝³ : AddCommMonoid N₁\ninst✝² : AddCommMonoid N₂\ninst✝¹ : Module R' N₁\ninst✝ : Module R' N₂\nf g : N₁ [⋀^ι]→ₗ[R'] N₂\ne : Basis ι₁ R' N₁\nh : ∀ (v : ι → ι₁), Functi... | exact h v hi | Lean.Elab.Tactic.evalExact | Lean.Parser.Tactic.exact |
Mathlib.LinearAlgebra.Alternating.Basic | {
"line": 901,
"column": 4
} | {
"line": 901,
"column": 16
} | [
{
"pp": "case pos\nι : Type u_7\nι₁ : Type u_10\ninst✝⁵ : Finite ι\nR' : Type u_11\nN₁ : Type u_12\nN₂ : Type u_13\ninst✝⁴ : CommSemiring R'\ninst✝³ : AddCommMonoid N₁\ninst✝² : AddCommMonoid N₂\ninst✝¹ : Module R' N₁\ninst✝ : Module R' N₂\nf g : N₁ [⋀^ι]→ₗ[R'] N₂\ne : Basis ι₁ R' N₁\nh : ∀ (v : ι → ι₁), Functi... | exact h v hi | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Mathlib.LinearAlgebra.Alternating.Basic | {
"line": 901,
"column": 4
} | {
"line": 901,
"column": 16
} | [
{
"pp": "case pos\nι : Type u_7\nι₁ : Type u_10\ninst✝⁵ : Finite ι\nR' : Type u_11\nN₁ : Type u_12\nN₂ : Type u_13\ninst✝⁴ : CommSemiring R'\ninst✝³ : AddCommMonoid N₁\ninst✝² : AddCommMonoid N₂\ninst✝¹ : Module R' N₁\ninst✝ : Module R' N₂\nf g : N₁ [⋀^ι]→ₗ[R'] N₂\ne : Basis ι₁ R' N₁\nh : ∀ (v : ι → ι₁), Functi... | exact h v hi | Lean.Elab.Tactic.evalTacticSeq | Lean.Parser.Tactic.tacticSeq |
Mathlib.LinearAlgebra.Matrix.Determinant.Basic | {
"line": 241,
"column": 2
} | {
"line": 244,
"column": 95
} | [
{
"pp": "m : Type u_1\nn : Type u_2\ninst✝⁶ : DecidableEq n\ninst✝⁵ : Fintype n\ninst✝⁴ : DecidableEq m\ninst✝³ : Fintype m\nR : Type u_3\ninst✝² : CommRing R\ninst✝¹ : LinearOrder R\ninst✝ : IsStrictOrderedRing R\ne₁ e₂ : n ≃ m\nA : Matrix m m R\n⊢ |(A.submatrix ⇑e₁ ⇑e₂).det| = |A.det|",
"usedConstants": [... | have hee : e₂ = e₁.trans (e₁.symm.trans e₂) := by ext; simp
rw [hee]
change |((A.submatrix id (e₁.symm.trans e₂)).submatrix e₁ e₁).det| = |A.det|
rw [Matrix.det_submatrix_equiv_self, Matrix.det_permute', abs_mul, abs_unit_intCast, one_mul] | Lean.Elab.Tactic.evalTacticSeq1Indented | Lean.Parser.Tactic.tacticSeq1Indented |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.