ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.MorphismProperty.StableUnderBaseChange.diagonal
File: Mathlib/CategoryTheory/MorphismProperty/Limits.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasPullbacks C
P : MorphismProperty C
hP : P.StableUnderBaseChange
inst✝ : P.RespectsIso
⊢ ∀ (X Y S : C) (f : X ⟶ S) (g : Y ⟶ S), P.diagonal g → P.diagonal (pullback.fst f g)
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasPullbacks C
P : MorphismProperty C
hP : P.StableUnderBaseChange
inst✝ : P.RespectsIso
X Y S : C
f : X ⟶ S
g : Y ⟶ S
h : P.diagonal g
⊢ P.diagonal (pullback.fst f g)
tactic: introv h
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasPullbacks C
P : MorphismProperty C
hP : P.StableUnderBaseChange
inst✝ : P.RespectsIso
X Y S : C
f : X ⟶ S
g : Y ⟶ S
h : P.diagonal g
⊢ P.diagonal (pullback.fst f g)
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasPullbacks C
P : MorphismProperty C
hP : P.StableUnderBaseChange
inst✝ : P.RespectsIso
X Y S : C
f : X ⟶ S
g : Y ⟶ S
h : P.diagonal g
⊢ P ((Over.pullback f).map (Over.homMk (pullback.diagonal g) ⋯)).left
tactic: rw [diagonal_iff, diagonal_pullback_fst, P.cancel_left_of_respectsIso,
        P.cancel_right_of_respectsIso]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasPullbacks C
P : MorphismProperty C
hP : P.StableUnderBaseChange
inst✝ : P.RespectsIso
X Y S : C
f : X ⟶ S
g : Y ⟶ S
h : P.diagonal g
⊢ P ((Over.pullback f).map (Over.homMk (pullback.diagonal g) ⋯)).left
state_after: no goals
tactic: exact hP.baseChange_map f _ (by simpa)
Theorem: Nat.geom_sum_le
File: Mathlib/Algebra/GeomSum.lean

Proof steps:
state_before: α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ ∑ i ∈ range n, a / b ^ i ≤ a * b / (b - 1)
state_after: α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ (∑ i ∈ range n, a / b ^ i) * (b - 1) ≤ a * b
tactic: refine (Nat.le_div_iff_mul_le <| tsub_pos_of_lt hb).2 ?_
state_before: α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ (∑ i ∈ range n, a / b ^ i) * (b - 1) ≤ a * b
state_after: case zero
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a : ℕ
⊢ (∑ i ∈ range 0, a / b ^ i) * (b - 1) ≤ a * b

case succ
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ (∑ i ∈ range (n + 1), a / b ^ i) * (b - 1) ≤ a * b
tactic: cases' n with n
state_before: case succ
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ (∑ i ∈ range (n + 1), a / b ^ i) * (b - 1) ≤ a * b
state_after: case succ
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ (b - 1) * ∑ i ∈ range (n + 1), a / b ^ i ≤ a * b
tactic: rw [mul_comm]
state_before: case succ
α : Type u
β : Type u_1
b : ℕ
hb : 2 ≤ b
a n : ℕ
⊢ (b - 1) * ∑ i ∈ range (n + 1), a / b ^ i ≤ a * b
state_after: no goals
tactic: exact (Nat.pred_mul_geom_sum_le a b n).trans tsub_le_self
Theorem: iteratedDeriv_neg
File: Mathlib/Analysis/Calculus/IteratedDeriv/Lemmas.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
R : Type u_3
inst✝³ : Semiring R
inst✝² : Module R F
inst✝¹ : SMulCommClass 𝕜 R F
inst✝ : ContinuousConstSMul R F
n✝ : ℕ
x : 𝕜
s : Set 𝕜
hx : x ∈ s
h : UniqueDiffOn 𝕜 s
f✝ g : 𝕜 → F
n : ℕ
f : 𝕜 → F
a : 𝕜
⊢ iteratedDeriv n (fun x => -f x) a = -iteratedDeriv n f a
state_after: no goals
tactic: simp_rw [← iteratedDerivWithin_univ, iteratedDerivWithin_neg' (Set.mem_univ a) uniqueDiffOn_univ]
Theorem: CochainComplex.HomComplex.Cochain.δ_rightShift
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' m' : ℤ
hn' : n' + a = n
m : ℤ
hm' : m' + a = m
⊢ δ n' m' (γ.rightShift a n' hn') = a.negOnePow • (δ n m γ).rightShift a m' hm'
state_after: case pos
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' m' : ℤ
hn' : n' + a = n
m : ℤ
hm' : m' + a = m
hnm : n + 1 = m
⊢ δ n' m' (γ.rightShift a n' hn') = a.negOnePow • (δ n m γ).rightShift a m' hm'

case neg
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' m' : ℤ
hn' : n' + a = n
m : ℤ
hm' : m' + a = m
hnm : ¬n + 1 = m
⊢ δ n' m' (γ.rightShift a n' hn') = a.negOnePow • (δ n m γ).rightShift a m' hm'
tactic: by_cases hnm : n + 1 = m
Theorem: Finset.map_add_right_Ioc
File: Mathlib/Algebra/Order/Interval/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (addRightEmbedding c) (Ioc a b) = Ioc (a + c) (b + c)
state_after: ι : Type u_1
α : Type u_2
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ ⇑(addRightEmbedding c) '' Set.Ioc a b = Set.Ioc (a + c) (b + c)
tactic: rw [← coe_inj, coe_map, coe_Ioc, coe_Ioc]
state_before: ι : Type u_1
α : Type u_2
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ ⇑(addRightEmbedding c) '' Set.Ioc a b = Set.Ioc (a + c) (b + c)
state_after: no goals
tactic: exact Set.image_add_const_Ioc _ _ _
Theorem: Int.eq_pow_of_mul_eq_pow_odd_right
File: Mathlib/RingTheory/Int/Basic.lean

Proof steps:
state_before: a b c : ℤ
hab : IsCoprime a b
k : ℕ
hk : Odd k
h : a * b = c ^ k
⊢ b * a = ?m.13357 ^ k
state_after: no goals
tactic: rwa [mul_comm] at h
Theorem: CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_hom
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

Proof steps:
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
F G : J ⥤ C
s : Cone F
t : Cone G
P : IsLimit s
Q : IsLimit t
w : F ≅ G
⊢ ∀ (j : J), (map s Q w.hom ≫ map t P w.inv) ≫ s.π.app j = 𝟙 s.pt ≫ s.π.app j
state_after: no goals
tactic: aesop_cat
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
F G : J ⥤ C
s : Cone F
t : Cone G
P : IsLimit s
Q : IsLimit t
w : F ≅ G
⊢ ∀ (j : J), (map t P w.inv ≫ map s Q w.hom) ≫ t.π.app j = 𝟙 t.pt ≫ t.π.app j
state_after: no goals
tactic: aesop_cat
Theorem: Commute.div_div_div_comm
File: Mathlib/Algebra/Group/Commute/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝ : DivisionMonoid G
a b c d : G
hbc : Commute b c
hbd : Commute b⁻¹ d
hcd : Commute c⁻¹ d
⊢ a / b / (c / d) = a / c / (b / d)
state_after: no goals
tactic: simp_rw [div_eq_mul_inv, mul_inv_rev, inv_inv, hbd.symm.eq, hcd.symm.eq,
    hbc.inv_inv.mul_mul_mul_comm]
Theorem: MeasureTheory.Measure.count_ne_zero'
File: Mathlib/MeasureTheory/Measure/Count.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s : Set α
hs' : s.Nonempty
s_mble : MeasurableSet s
⊢ count s ≠ 0
state_after: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s : Set α
hs' : s.Nonempty
s_mble : MeasurableSet s
⊢ ¬s = ∅
tactic: rw [Ne, count_eq_zero_iff' s_mble]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
s : Set α
hs' : s.Nonempty
s_mble : MeasurableSet s
⊢ ¬s = ∅
state_after: no goals
tactic: exact hs'.ne_empty
Theorem: SimpleGraph.Dart.ext_iff
File: Mathlib/Combinatorics/SimpleGraph/Dart.lean

Proof steps:
state_before: V : Type u_1
G : SimpleGraph V
d₁ d₂ : G.Dart
⊢ d₁ = d₂ ↔ d₁.toProd = d₂.toProd
state_after: case mk
V : Type u_1
G : SimpleGraph V
d₂ : G.Dart
toProd✝ : V × V
adj✝ : G.Adj toProd✝.1 toProd✝.2
⊢ { toProd := toProd✝, adj := adj✝ } = d₂ ↔ { toProd := toProd✝, adj := adj✝ }.toProd = d₂.toProd
tactic: cases d₁
state_before: case mk
V : Type u_1
G : SimpleGraph V
d₂ : G.Dart
toProd✝ : V × V
adj✝ : G.Adj toProd✝.1 toProd✝.2
⊢ { toProd := toProd✝, adj := adj✝ } = d₂ ↔ { toProd := toProd✝, adj := adj✝ }.toProd = d₂.toProd
state_after: case mk.mk
V : Type u_1
G : SimpleGraph V
toProd✝¹ : V × V
adj✝¹ : G.Adj toProd✝¹.1 toProd✝¹.2
toProd✝ : V × V
adj✝ : G.Adj toProd✝.1 toProd✝.2
⊢ { toProd := toProd✝¹, adj := adj✝¹ } = { toProd := toProd✝, adj := adj✝ } ↔
    { toProd := toProd✝¹, adj := adj✝¹ }.toProd = { toProd := toProd✝, adj := adj✝ }.toProd
tactic: cases d₂
state_before: case mk.mk
V : Type u_1
G : SimpleGraph V
toProd✝¹ : V × V
adj✝¹ : G.Adj toProd✝¹.1 toProd✝¹.2
toProd✝ : V × V
adj✝ : G.Adj toProd✝.1 toProd✝.2
⊢ { toProd := toProd✝¹, adj := adj✝¹ } = { toProd := toProd✝, adj := adj✝ } ↔
    { toProd := toProd✝¹, adj := adj✝¹ }.toProd = { toProd := toProd✝, adj := adj✝ }.toProd
state_after: no goals
tactic: simp
Theorem: Mathlib.Tactic.Abel.const_add_term
File: Mathlib/Tactic/Abel.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommMonoid α
k : α
n : ℕ
x a a' : α
h : k + a = a'
⊢ k + term n x a = term n x a'
state_after: no goals
tactic: simp [h.symm, term, add_comm, add_assoc]
Theorem: UpperSet.compl_iSup
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LE α
s t : UpperSet α
a : α
f : ι → UpperSet α
⊢ ↑(⨆ i, f i).compl = ↑(⨆ i, (f i).compl)
state_after: no goals
tactic: simp only [coe_compl, coe_iSup, compl_iInter, LowerSet.coe_iSup]
Theorem: SimpleGraph.chromaticNumber_eq_iInf
File: Mathlib/Combinatorics/SimpleGraph/Coloring.lean

Proof steps:
state_before: V : Type u
G✝ : SimpleGraph V
n : ℕ
α : Type u_1
β : Type u_2
C : G✝.Coloring α
G : SimpleGraph V
⊢ G.chromaticNumber = ⨅ n, ↑↑n
state_after: no goals
tactic: rw [chromaticNumber, iInf_subtype]
Theorem: MeasureTheory.Measure.WeaklyRegular.smul
File: Mathlib/MeasureTheory/Measure/Regular.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ : Measure α
inst✝ : μ.WeaklyRegular
x : ℝ≥0∞
hx : x ≠ ⊤
⊢ (x • μ).WeaklyRegular
state_after: α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ : Measure α
inst✝ : μ.WeaklyRegular
x : ℝ≥0∞
hx : x ≠ ⊤
this : (x • μ).OuterRegular
⊢ (x • μ).WeaklyRegular
tactic: haveI := OuterRegular.smul μ hx
state_before: α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : TopologicalSpace α
μ : Measure α
inst✝ : μ.WeaklyRegular
x : ℝ≥0∞
hx : x ≠ ⊤
this : (x • μ).OuterRegular
⊢ (x • μ).WeaklyRegular
state_after: no goals
tactic: exact ⟨WeaklyRegular.innerRegular.smul x⟩
Theorem: Int.ceil_sub_int
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a : α
z : ℤ
⊢ ⌈a - ↑z⌉ = ⌈a + ↑(-z)⌉
state_after: no goals
tactic: rw [Int.cast_neg, sub_eq_add_neg]
Theorem: SubgroupClass.subtype_comp_inclusion
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁷ : Group G
inst✝⁶ : Group G'
inst✝⁵ : Group G''
A : Type u_4
inst✝⁴ : AddGroup A
M : Type u_5
S : Type u_6
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H✝ K✝ : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
H K : S
hH : H ≤ K
⊢ (↑K).comp (inclusion hH) = ↑H
state_after: case h
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁷ : Group G
inst✝⁶ : Group G'
inst✝⁵ : Group G''
A : Type u_4
inst✝⁴ : AddGroup A
M : Type u_5
S : Type u_6
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H✝ K✝ : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
H K : S
hH : H ≤ K
x✝ : ↥H
⊢ ((↑K).comp (inclusion hH)) x✝ = ↑H x✝
tactic: ext
state_before: case h
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁷ : Group G
inst✝⁶ : Group G'
inst✝⁵ : Group G''
A : Type u_4
inst✝⁴ : AddGroup A
M : Type u_5
S : Type u_6
inst✝³ : DivInvMonoid M
inst✝² : SetLike S M
hSM : SubgroupClass S M
H✝ K✝ : S
inst✝¹ : SetLike S G
inst✝ : SubgroupClass S G
H K : S
hH : H ≤ K
x✝ : ↥H
⊢ ((↑K).comp (inclusion hH)) x✝ = ↑H x✝
state_after: no goals
tactic: simp only [MonoidHom.comp_apply, coeSubtype, coe_inclusion]
Theorem: Finsupp.span_image_eq_map_total
File: Mathlib/LinearAlgebra/Finsupp.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
s : Set α
⊢ span R (v '' s) = map (Finsupp.total α M R v) (supported R R s)
state_after: case h₁
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
s : Set α
⊢ v '' s ⊆ ↑(map (Finsupp.total α M R v) (supported R R s))

case h₂
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid N
inst✝⁴ : Module R N
inst✝³ : AddCommMonoid P
inst✝² : Module R P
α' : Type u_7
M' : Type u_8
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
v : α → M
v' : α' → M'
s : Set α
⊢ map (Finsupp.total α M R v) (supported R R s) ≤ span R (v '' s)
tactic: apply span_eq_of_le
Theorem: MonoidHom.ker_eq_bot_iff
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁶ : Group G
inst✝⁵ : Group G'
inst✝⁴ : Group G''
A : Type u_4
inst✝³ : AddGroup A
N : Type u_5
P : Type u_6
inst✝² : Group N
inst✝¹ : Group P
K : Subgroup G
M : Type u_7
inst✝ : MulOneClass M
f : G →* M
h : f.ker = ⊥
x y : G
hxy : f x = f y
⊢ x = y
state_after: no goals
tactic: rwa [eq_iff, h, mem_bot, inv_mul_eq_one, eq_comm] at hxy
Theorem: HahnSeries.coeff_order_ne_zero
File: Mathlib/RingTheory/HahnSeries/Basic.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
hx : x ≠ 0
⊢ x.coeff x.order ≠ 0
state_after: Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
hx : x ≠ 0
⊢ x.coeff (⋯.min ⋯) ≠ 0
tactic: rw [order_of_ne hx]
state_before: Γ : Type u_1
R : Type u_2
inst✝² : PartialOrder Γ
inst✝¹ : Zero R
a b : Γ
r : R
inst✝ : Zero Γ
x : HahnSeries Γ R
hx : x ≠ 0
⊢ x.coeff (⋯.min ⋯) ≠ 0
state_after: no goals
tactic: exact x.isWF_support.min_mem (support_nonempty_iff.2 hx)
Theorem: Basis.mk_eq_rank''
File: Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι✝ : Type w
ι' : Type w'
inst✝ : StrongRankCondition R
ι : Type v
v : Basis ι R M
⊢ #ι = Module.rank R M
state_after: R : Type u
M : Type v
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι✝ : Type w
ι' : Type w'
inst✝ : StrongRankCondition R
ι : Type v
v : Basis ι R M
this : Nontrivial R
⊢ #ι = Module.rank R M
tactic: haveI := nontrivial_of_invariantBasisNumber R
state_before: R : Type u
M : Type v
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι✝ : Type w
ι' : Type w'
inst✝ : StrongRankCondition R
ι : Type v
v : Basis ι R M
this : Nontrivial R
⊢ #ι = Module.rank R M
state_after: R : Type u
M : Type v
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι✝ : Type w
ι' : Type w'
inst✝ : StrongRankCondition R
ι : Type v
v : Basis ι R M
this : Nontrivial R
⊢ #ι = ⨆ ι, #↑↑ι
tactic: rw [Module.rank_def]
state_before: R : Type u
M : Type v
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι✝ : Type w
ι' : Type w'
inst✝ : StrongRankCondition R
ι : Type v
v : Basis ι R M
this : Nontrivial R
⊢ #ι = ⨆ ι, #↑↑ι
state_after: case a
R : Type u
M : Type v
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι✝ : Type w
ι' : Type w'
inst✝ : StrongRankCondition R
ι : Type v
v : Basis ι R M
this : Nontrivial R
⊢ #ι ≤ ⨆ ι, #↑↑ι

case a
R : Type u
M : Type v
inst✝³ : Ring R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
ι✝ : Type w
ι' : Type w'
inst✝ : StrongRankCondition R
ι : Type v
v : Basis ι R M
this : Nontrivial R
⊢ ⨆ ι, #↑↑ι ≤ #ι
tactic: apply le_antisymm
Theorem: Ordnode.size_balanceL
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Balanced
hr : r.Balanced
sl : l.Sized
sr : r.Sized
H : (∃ l', Raised l' l.size ∧ BalancedSz l' r.size) ∨ ∃ r', Raised r.size r' ∧ BalancedSz l.size r'
⊢ (l.balanceL x r).size = l.size + r.size + 1
state_after: no goals
tactic: rw [balanceL_eq_balance' hl hr sl sr H, size_balance' sl sr]
Theorem: Polynomial.expand_contract
File: Mathlib/Algebra/Polynomial/Expand.lean

Proof steps:
state_before: R : Type u
inst✝³ : CommSemiring R
S : Type v
inst✝² : CommSemiring S
p q : ℕ
inst✝¹ : CharP R p
inst✝ : NoZeroDivisors R
f : R[X]
hf : derivative f = 0
hp : p ≠ 0
⊢ (expand R p) (contract p f) = f
state_after: case a
R : Type u
inst✝³ : CommSemiring R
S : Type v
inst✝² : CommSemiring S
p q : ℕ
inst✝¹ : CharP R p
inst✝ : NoZeroDivisors R
f : R[X]
hf : derivative f = 0
hp : p ≠ 0
n : ℕ
⊢ ((expand R p) (contract p f)).coeff n = f.coeff n
tactic: ext n
state_before: case a
R : Type u
inst✝³ : CommSemiring R
S : Type v
inst✝² : CommSemiring S
p q : ℕ
inst✝¹ : CharP R p
inst✝ : NoZeroDivisors R
f : R[X]
hf : derivative f = 0
hp : p ≠ 0
n : ℕ
⊢ ((expand R p) (contract p f)).coeff n = f.coeff n
state_after: case a
R : Type u
inst✝³ : CommSemiring R
S : Type v
inst✝² : CommSemiring S
p q : ℕ
inst✝¹ : CharP R p
inst✝ : NoZeroDivisors R
f : R[X]
hf : derivative f = 0
hp : p ≠ 0
n : ℕ
⊢ (if p ∣ n then f.coeff (n / p * p) else 0) = f.coeff n
tactic: rw [coeff_expand hp.bot_lt, coeff_contract hp]
state_before: case a
R : Type u
inst✝³ : CommSemiring R
S : Type v
inst✝² : CommSemiring S
p q : ℕ
inst✝¹ : CharP R p
inst✝ : NoZeroDivisors R
f : R[X]
hf : derivative f = 0
hp : p ≠ 0
n : ℕ
⊢ (if p ∣ n then f.coeff (n / p * p) else 0) = f.coeff n
state_after: case pos
R : Type u
inst✝³ : CommSemiring R
S : Type v
inst✝² : CommSemiring S
p q : ℕ
inst✝¹ : CharP R p
inst✝ : NoZeroDivisors R
f : R[X]
hf : derivative f = 0
hp : p ≠ 0
n : ℕ
h : p ∣ n
⊢ f.coeff (n / p * p) = f.coeff n

case neg
R : Type u
inst✝³ : CommSemiring R
S : Type v
inst✝² : CommSemiring S
p q : ℕ
inst✝¹ : CharP R p
inst✝ : NoZeroDivisors R
f : R[X]
hf : derivative f = 0
hp : p ≠ 0
n : ℕ
h : ¬p ∣ n
⊢ 0 = f.coeff n
tactic: split_ifs with h
Theorem: Finsupp.sum_filter_index
File: Mathlib/Data/Finsupp/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
p : α → Prop
inst✝¹ : DecidablePred p
f : α →₀ M
inst✝ : CommMonoid N
g : α → M → N
⊢ (filter p f).prod g = ∏ x ∈ (filter p f).support, g x (f x)
state_after: no goals
tactic: classical
    refine Finset.prod_congr rfl fun x hx => ?_
    rw [support_filter, Finset.mem_filter] at hx
    rw [filter_apply_pos _ _ hx.2]
Theorem: dvd_of_eq
File: Mathlib/Algebra/Divisibility/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Monoid α
a b c : α
m n : ℕ
h : a = b
⊢ a ∣ b
state_after: no goals
tactic: rw [h]
Theorem: AlgebraicTopology.DoldKan.PInfty_f_comp_QInfty_f
File: Mathlib/AlgebraicTopology/DoldKan/PInfty.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
⊢ PInfty.f n ≫ QInfty.f n = 0
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
⊢ PInfty.f n ≫ (𝟙 K[X] - PInfty).f n = 0
tactic: dsimp only [QInfty]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
⊢ PInfty.f n ≫ (𝟙 K[X] - PInfty).f n = 0
state_after: no goals
tactic: simp only [HomologicalComplex.sub_f_apply, HomologicalComplex.id_f, comp_sub, comp_id,
    PInfty_f_idem, sub_self]
Theorem: sSup_image'
File: Mathlib/Order/CompleteLattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : SupSet α
f✝ g : ι → α
s : Set β
f : β → α
⊢ sSup (f '' s) = ⨆ a, f ↑a
state_after: no goals
tactic: rw [iSup, image_eq_range]
Theorem: Dioph.ex_dioph
File: Mathlib/NumberTheory/Dioph.lean

Proof steps:
state_before: α β γ✝ : Type u
S✝ S' : Set (α → ℕ)
S : Set (α ⊕ β → ℕ)
γ : Type u
p : Poly ((α ⊕ β) ⊕ γ)
pe : ∀ (v : α ⊕ β → ℕ), S v ↔ ∃ t, p (v ⊗ t) = 0
v : α → ℕ
x✝ : {v | ∃ x, v ⊗ x ∈ S} v
x : β → ℕ
hx : v ⊗ x ∈ S
t : γ → ℕ
ht : p ((v ⊗ x) ⊗ t) = 0
⊢ (Poly.map ((inl ⊗ inr ∘ inl) ⊗ inr ∘ inr) p) (v ⊗ x ⊗ t) = 0
state_after: α β γ✝ : Type u
S✝ S' : Set (α → ℕ)
S : Set (α ⊕ β → ℕ)
γ : Type u
p : Poly ((α ⊕ β) ⊕ γ)
pe : ∀ (v : α ⊕ β → ℕ), S v ↔ ∃ t, p (v ⊗ t) = 0
v : α → ℕ
x✝ : {v | ∃ x, v ⊗ x ∈ S} v
x : β → ℕ
hx : v ⊗ x ∈ S
t : γ → ℕ
ht : p ((v ⊗ x) ⊗ t) = 0
⊢ p ((v ⊗ x ⊗ t) ∘ ((inl ⊗ inr ∘ inl) ⊗ inr ∘ inr)) = 0
tactic: simp
state_before: α β γ✝ : Type u
S✝ S' : Set (α → ℕ)
S : Set (α ⊕ β → ℕ)
γ : Type u
p : Poly ((α ⊕ β) ⊕ γ)
pe : ∀ (v : α ⊕ β → ℕ), S v ↔ ∃ t, p (v ⊗ t) = 0
v : α → ℕ
x✝ : {v | ∃ x, v ⊗ x ∈ S} v
x : β → ℕ
hx : v ⊗ x ∈ S
t : γ → ℕ
ht : p ((v ⊗ x) ⊗ t) = 0
⊢ p ((v ⊗ x ⊗ t) ∘ ((inl ⊗ inr ∘ inl) ⊗ inr ∘ inr)) = 0
state_after: α β γ✝ : Type u
S✝ S' : Set (α → ℕ)
S : Set (α ⊕ β → ℕ)
γ : Type u
p : Poly ((α ⊕ β) ⊕ γ)
pe : ∀ (v : α ⊕ β → ℕ), S v ↔ ∃ t, p (v ⊗ t) = 0
v : α → ℕ
x✝ : {v | ∃ x, v ⊗ x ∈ S} v
x : β → ℕ
hx : v ⊗ x ∈ S
t : γ → ℕ
ht : p ((v ⊗ x) ⊗ t) = 0
⊢ p ((v ⊗ x) ⊗ t) = 0
tactic: rw [show (v ⊗ x ⊗ t) ∘ ((inl ⊗ inr ∘ inl) ⊗ inr ∘ inr) = (v ⊗ x) ⊗ t from
            funext fun s => by cases' s with a b <;> try { cases a <;> rfl }; rfl]
state_before: α β γ✝ : Type u
S✝ S' : Set (α → ℕ)
S : Set (α ⊕ β → ℕ)
γ : Type u
p : Poly ((α ⊕ β) ⊕ γ)
pe : ∀ (v : α ⊕ β → ℕ), S v ↔ ∃ t, p (v ⊗ t) = 0
v : α → ℕ
x✝ : {v | ∃ x, v ⊗ x ∈ S} v
x : β → ℕ
hx : v ⊗ x ∈ S
t : γ → ℕ
ht : p ((v ⊗ x) ⊗ t) = 0
⊢ p ((v ⊗ x) ⊗ t) = 0
state_after: no goals
tactic: exact ht
state_before: α β γ✝ : Type u
S✝ S' : Set (α → ℕ)
S : Set (α ⊕ β → ℕ)
γ : Type u
p : Poly ((α ⊕ β) ⊕ γ)
pe : ∀ (v : α ⊕ β → ℕ), S v ↔ ∃ t, p (v ⊗ t) = 0
v : α → ℕ
x✝ : ∃ t, (Poly.map ((inl ⊗ inr ∘ inl) ⊗ inr ∘ inr) p) (v ⊗ t) = 0
t : β ⊕ γ → ℕ
ht : (Poly.map ((inl ⊗ inr ∘ inl) ⊗ inr ∘ inr) p) (v ⊗ t) = 0
⊢ p ((v ⊗ t ∘ inl) ⊗ t ∘ inr) = 0
state_after: α β γ✝ : Type u
S✝ S' : Set (α → ℕ)
S : Set (α ⊕ β → ℕ)
γ : Type u
p : Poly ((α ⊕ β) ⊕ γ)
pe : ∀ (v : α ⊕ β → ℕ), S v ↔ ∃ t, p (v ⊗ t) = 0
v : α → ℕ
x✝ : ∃ t, (Poly.map ((inl ⊗ inr ∘ inl) ⊗ inr ∘ inr) p) (v ⊗ t) = 0
t : β ⊕ γ → ℕ
ht : p ((v ⊗ t) ∘ ((inl ⊗ inr ∘ inl) ⊗ inr ∘ inr)) = 0
⊢ p ((v ⊗ t ∘ inl) ⊗ t ∘ inr) = 0
tactic: simp only [Poly.map_apply] at ht
state_before: α β γ✝ : Type u
S✝ S' : Set (α → ℕ)
S : Set (α ⊕ β → ℕ)
γ : Type u
p : Poly ((α ⊕ β) ⊕ γ)
pe : ∀ (v : α ⊕ β → ℕ), S v ↔ ∃ t, p (v ⊗ t) = 0
v : α → ℕ
x✝ : ∃ t, (Poly.map ((inl ⊗ inr ∘ inl) ⊗ inr ∘ inr) p) (v ⊗ t) = 0
t : β ⊕ γ → ℕ
ht : p ((v ⊗ t) ∘ ((inl ⊗ inr ∘ inl) ⊗ inr ∘ inr)) = 0
⊢ p ((v ⊗ t ∘ inl) ⊗ t ∘ inr) = 0
state_after: no goals
tactic: rwa [show (v ⊗ t) ∘ ((inl ⊗ inr ∘ inl) ⊗ inr ∘ inr) = (v ⊗ t ∘ inl) ⊗ t ∘ inr from
                funext fun s => by cases' s with a b <;> try { cases a <;> rfl }; rfl] at ht