ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: PadicInt.modPart_lt_p
File: Mathlib/NumberTheory/Padics/RingHoms.lean

Proof steps:
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
⊢ modPart p r < ↑p
state_after: case h.e'_4
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
⊢ ↑p = |↑p|

case convert_3
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
⊢ ↑p ≠ 0
tactic: convert Int.emod_lt _ _
Theorem: List.sum_cons
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a : M
⊢ (a :: l).prod = foldl (fun x x_1 => x * x_1) (a * 1) l
state_after: no goals
tactic: simp only [List.prod, foldl_cons, one_mul, mul_one]
Theorem: Cardinal.mk_emptyCollection_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α✝ β : Type u
c : Cardinal.{?u.193412}
α : Type u
s : Set α
⊢ #↑s = 0 ↔ s = ∅
state_after: case mp
α✝ β : Type u
c : Cardinal.{?u.193412}
α : Type u
s : Set α
⊢ #↑s = 0 → s = ∅

case mpr
α✝ β : Type u
c : Cardinal.{?u.193412}
α : Type u
s : Set α
⊢ s = ∅ → #↑s = 0
tactic: constructor
Theorem: mul_add_one
File: Mathlib/Algebra/Ring/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝² : Add α
inst✝¹ : MulOneClass α
inst✝ : LeftDistribClass α
a b : α
⊢ a * (b + 1) = a * b + a
state_after: no goals
tactic: rw [mul_add, mul_one]
Theorem: Finset.prod_le_one'
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝¹ : CommMonoid M
inst✝ : OrderedCommMonoid N
f g : ι → N
s t : Finset ι
h : ∀ i ∈ s, f i ≤ 1
⊢ ∏ i ∈ s, 1 = 1
state_after: no goals
tactic: rw [prod_const_one]
Theorem: HahnSeries.single_zero_mul_eq_smul
File: Mathlib/RingTheory/HahnSeries/Multiplication.lean

Proof steps:
state_before: Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : Semiring R
r : R
x : HahnSeries Γ R
⊢ (single 0) r * x = r • x
state_after: case coeff.h
Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : Semiring R
r : R
x : HahnSeries Γ R
x✝ : Γ
⊢ ((single 0) r * x).coeff x✝ = (r • x).coeff x✝
tactic: ext
state_before: case coeff.h
Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝¹ : OrderedCancelAddCommMonoid Γ
inst✝ : Semiring R
r : R
x : HahnSeries Γ R
x✝ : Γ
⊢ ((single 0) r * x).coeff x✝ = (r • x).coeff x✝
state_after: no goals
tactic: exact single_zero_mul_coeff
Theorem: Cycle.next_reverse_eq_prev
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s : Cycle α
hs : s.Nodup
x : α
hx : x ∈ s
⊢ s.reverse.next ⋯ x ⋯ = s.prev hs x hx
state_after: no goals
tactic: simp [← prev_reverse_eq_next]
Theorem: absorbs_iff_eventually_nhdsWithin_zero
File: Mathlib/Analysis/LocallyConvex/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : NormedDivisionRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
x : E
a b : 𝕜
⊢ Absorbs 𝕜 s t ↔ ∀ᶠ (c : 𝕜) in 𝓝[≠] 0, MapsTo (fun x => c • x) t s
state_after: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : NormedDivisionRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
x : E
a b : 𝕜
⊢ (∀ᶠ (c : 𝕜) in Bornology.cobounded 𝕜, MapsTo (fun x => c⁻¹ • x) t s) ↔
    ∀ᶠ (c : 𝕜) in (Bornology.cobounded 𝕜)⁻¹, MapsTo (fun x => c • x) t s
tactic: rw [absorbs_iff_eventually_cobounded_mapsTo, ← Filter.inv_cobounded₀]
state_before: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : NormedDivisionRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
x : E
a b : 𝕜
⊢ (∀ᶠ (c : 𝕜) in Bornology.cobounded 𝕜, MapsTo (fun x => c⁻¹ • x) t s) ↔
    ∀ᶠ (c : 𝕜) in (Bornology.cobounded 𝕜)⁻¹, MapsTo (fun x => c • x) t s
state_after: no goals
tactic: rfl
Theorem: Field.lift_sepDegree_mul_lift_sepDegree_of_isAlgebraic
File: Mathlib/FieldTheory/PurelyInseparable.lean

Proof steps:
state_before: F : Type u
E : Type v
inst✝⁷ : Field F
inst✝⁶ : Field E
inst✝⁵ : Algebra F E
K : Type w
inst✝⁴ : Field K
inst✝³ : Algebra F K
inst✝² : Algebra E K
inst✝¹ : IsScalarTower F E K
inst✝ : Algebra.IsAlgebraic F E
⊢ Cardinal.lift.{w, v} (sepDegree F E) * Cardinal.lift.{v, w} (sepDegree E K) = Cardinal.lift.{v, w} (sepDegree F K)
state_after: F : Type u
E : Type v
inst✝⁷ : Field F
inst✝⁶ : Field E
inst✝⁵ : Algebra F E
K : Type w
inst✝⁴ : Field K
inst✝³ : Algebra F K
inst✝² : Algebra E K
inst✝¹ : IsScalarTower F E K
inst✝ : Algebra.IsAlgebraic F E
h :
  Cardinal.lift.{w, v} (Module.rank F ↥(separableClosure F E)) *
      Cardinal.lift.{v, w} (sepDegree (↥(separableClosure F E)) K) =
    Cardinal.lift.{v, w} (sepDegree F K)
⊢ Cardinal.lift.{w, v} (sepDegree F E) * Cardinal.lift.{v, w} (sepDegree E K) = Cardinal.lift.{v, w} (sepDegree F K)
tactic: have h := lift_rank_mul_lift_sepDegree_of_isSeparable F (separableClosure F E) K
state_before: F : Type u
E : Type v
inst✝⁷ : Field F
inst✝⁶ : Field E
inst✝⁵ : Algebra F E
K : Type w
inst✝⁴ : Field K
inst✝³ : Algebra F K
inst✝² : Algebra E K
inst✝¹ : IsScalarTower F E K
inst✝ : Algebra.IsAlgebraic F E
h :
  Cardinal.lift.{w, v} (Module.rank F ↥(separableClosure F E)) *
      Cardinal.lift.{v, w} (sepDegree (↥(separableClosure F E)) K) =
    Cardinal.lift.{v, w} (sepDegree F K)
⊢ Cardinal.lift.{w, v} (sepDegree F E) * Cardinal.lift.{v, w} (sepDegree E K) = Cardinal.lift.{v, w} (sepDegree F K)
state_after: F : Type u
E : Type v
inst✝⁷ : Field F
inst✝⁶ : Field E
inst✝⁵ : Algebra F E
K : Type w
inst✝⁴ : Field K
inst✝³ : Algebra F K
inst✝² : Algebra E K
inst✝¹ : IsScalarTower F E K
inst✝ : Algebra.IsAlgebraic F E
h :
  Cardinal.lift.{w, v} (Module.rank F ↥(separableClosure F E)) *
      Cardinal.lift.{v, w} (sepDegree (↥(separableClosure F E)) K) =
    Cardinal.lift.{v, w} (sepDegree F K)
this : IsPurelyInseparable (↥(separableClosure F E)) E
⊢ Cardinal.lift.{w, v} (sepDegree F E) * Cardinal.lift.{v, w} (sepDegree E K) = Cardinal.lift.{v, w} (sepDegree F K)
tactic: haveI := separableClosure.isPurelyInseparable F E
state_before: F : Type u
E : Type v
inst✝⁷ : Field F
inst✝⁶ : Field E
inst✝⁵ : Algebra F E
K : Type w
inst✝⁴ : Field K
inst✝³ : Algebra F K
inst✝² : Algebra E K
inst✝¹ : IsScalarTower F E K
inst✝ : Algebra.IsAlgebraic F E
h :
  Cardinal.lift.{w, v} (Module.rank F ↥(separableClosure F E)) *
      Cardinal.lift.{v, w} (sepDegree (↥(separableClosure F E)) K) =
    Cardinal.lift.{v, w} (sepDegree F K)
this : IsPurelyInseparable (↥(separableClosure F E)) E
⊢ Cardinal.lift.{w, v} (sepDegree F E) * Cardinal.lift.{v, w} (sepDegree E K) = Cardinal.lift.{v, w} (sepDegree F K)
state_after: no goals
tactic: rwa [sepDegree_eq_of_isPurelyInseparable (separableClosure F E) E K] at h
Theorem: AlgebraicGeometry.PresheafedSpace.id_c_app
File: Mathlib/Geometry/RingedSpace/PresheafedSpace.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
U : (Opens ↑↑X)ᵒᵖ
⊢ (𝟙 X).c.app U = X.presheaf.map (𝟙 U)
state_after: C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
U : (Opens ↑↑X)ᵒᵖ
⊢ (𝟙 X.presheaf).app U = 𝟙 (X.presheaf.obj U)
tactic: rw [id_c, map_id]
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
X : PresheafedSpace C
U : (Opens ↑↑X)ᵒᵖ
⊢ (𝟙 X.presheaf).app U = 𝟙 (X.presheaf.obj U)
state_after: no goals
tactic: rfl
Theorem: Matrix.conjTranspose_intCast_smul
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : Ring R
inst✝² : AddCommGroup α
inst✝¹ : StarAddMonoid α
inst✝ : Module R α
c : ℤ
M : Matrix m n α
⊢ ∀ (i : n) (j : m), (↑c • M)ᴴ i j = (↑c • Mᴴ) i j
state_after: no goals
tactic: simp
Theorem: UpperSet.coe_eq_empty
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 : Set (UpperSet α)
s t : UpperSet α
a : α
⊢ ↑s = ∅ ↔ s = ⊤
state_after: no goals
tactic: simp [SetLike.ext'_iff]
Theorem: Polynomial.reflect_one_X
File: Mathlib/Algebra/Polynomial/Reverse.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
⊢ reflect 1 X = 1
state_after: no goals
tactic: simpa using reflect_monomial 1 1 (R := R)
Theorem: Int.Prime.dvd_natAbs_of_coe_dvd_sq
File: Mathlib/Data/Int/NatPrime.lean

Proof steps:
state_before: p : ℕ
hp : Nat.Prime p
k : ℤ
h : ↑p ∣ k ^ 2
⊢ p ∣ k.natAbs
state_after: p : ℕ
hp : Nat.Prime p
k : ℤ
h : ↑p ∣ k ^ 2
⊢ p ∣ k.natAbs ^ 2
tactic: apply @Nat.Prime.dvd_of_dvd_pow _ _ 2 hp
state_before: p : ℕ
hp : Nat.Prime p
k : ℤ
h : ↑p ∣ k ^ 2
⊢ p ∣ k.natAbs ^ 2
state_after: no goals
tactic: rwa [sq, ← natAbs_mul, ← natCast_dvd, ← sq]
Theorem: CategoryTheory.Limits.biproduct.whiskerEquiv_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
K : Type u_1
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
f : J → C
g : K → C
e : J ≃ K
w : (j : J) → g (e j) ≅ f j
inst✝¹ : HasBiproduct f
inst✝ : HasBiproduct g
k : K
⊢ g k = g (e (e.symm k))
state_after: no goals
tactic: simp
Theorem: LinearMap.polar_eq_iInter
File: Mathlib/Analysis/LocallyConvex/Polar.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : NormedCommRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜
s : Set E
⊢ B.polar s = ⋂ x ∈ s, {y | ‖(B x) y‖ ≤ 1}
state_after: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : NormedCommRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜
s : Set E
x✝ : F
⊢ x✝ ∈ B.polar s ↔ x✝ ∈ ⋂ x ∈ s, {y | ‖(B x) y‖ ≤ 1}
tactic: ext
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : NormedCommRing 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜
s : Set E
x✝ : F
⊢ x✝ ∈ B.polar s ↔ x✝ ∈ ⋂ x ∈ s, {y | ‖(B x) y‖ ≤ 1}
state_after: no goals
tactic: simp only [polar_mem_iff, Set.mem_iInter, Set.mem_setOf_eq]
Theorem: LieModule.nontrivial_of_isIrreducible
File: Mathlib/Algebra/Lie/Semisimple/Basic.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : LieRing L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : IsIrreducible R L M
⊢ ∃ x y, x ≠ y
state_after: R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : LieRing L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : IsIrreducible R L M
aux : ⊥ ≠ ⊤
⊢ ∃ x y, x ≠ y
tactic: have aux : (⊥ : LieSubmodule R L M) ≠ ⊤ := bot_ne_top
state_before: R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : LieRing L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : IsIrreducible R L M
aux : ⊥ ≠ ⊤
⊢ ∃ x y, x ≠ y
state_after: R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : LieRing L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : IsIrreducible R L M
aux : ∀ (x y : M), x = y
⊢ ⊥ = ⊤
tactic: contrapose! aux
state_before: R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : LieRing L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : IsIrreducible R L M
aux : ∀ (x y : M), x = y
⊢ ⊥ = ⊤
state_after: case h
R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : LieRing L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : IsIrreducible R L M
aux : ∀ (x y : M), x = y
m : M
⊢ m ∈ ⊥ ↔ m ∈ ⊤
tactic: ext m
state_before: case h
R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : LieRing L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : IsIrreducible R L M
aux : ∀ (x y : M), x = y
m : M
⊢ m ∈ ⊥ ↔ m ∈ ⊤
state_after: no goals
tactic: simpa using aux m 0
Theorem: Rat.cast_sub_of_ne_zero
File: Mathlib/Data/Rat/Cast/Defs.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝ : DivisionRing α
p q : ℚ
hp : ↑p.den ≠ 0
hq : ↑q.den ≠ 0
⊢ ↑(p - q) = ↑p - ↑q
state_after: no goals
tactic: simp [sub_eq_add_neg, cast_add_of_ne_zero, hp, hq]
Theorem: memPartitionSet_succ
File: Mathlib/Data/Set/MemPartition.lean

Proof steps:
state_before: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
inst✝ : Decidable (a ∈ f n)
⊢ memPartitionSet f (n + 1) a = if a ∈ f n then memPartitionSet f n a ∩ f n else memPartitionSet f n a \ f n
state_after: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
inst✝ : Decidable (a ∈ f n)
⊢ (if a ∈ f n then memPartitionSet f n a ∩ f n else memPartitionSet f n a \ f n) =
    if a ∈ f n then memPartitionSet f n a ∩ f n else memPartitionSet f n a \ f n
tactic: simp [memPartitionSet]
state_before: α : Type u_1
f : ℕ → Set α
n : ℕ
a : α
inst✝ : Decidable (a ∈ f n)
⊢ (if a ∈ f n then memPartitionSet f n a ∩ f n else memPartitionSet f n a \ f n) =
    if a ∈ f n then memPartitionSet f n a ∩ f n else memPartitionSet f n a \ f n
state_after: no goals
tactic: congr
Theorem: CategoryTheory.predicateShift_zero
File: Mathlib/CategoryTheory/Shift/Predicate.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{u_3, u_1} C
P : C → Prop
A : Type u_2
inst✝² : AddMonoid A
inst✝¹ : HasShift C A
inst✝ : ClosedUnderIsomorphisms P
⊢ PredicateShift P 0 = P
state_after: case h.a
C : Type u_1
inst✝³ : Category.{u_3, u_1} C
P : C → Prop
A : Type u_2
inst✝² : AddMonoid A
inst✝¹ : HasShift C A
inst✝ : ClosedUnderIsomorphisms P
X : C
⊢ PredicateShift P 0 X ↔ P X
tactic: ext X
state_before: case h.a
C : Type u_1
inst✝³ : Category.{u_3, u_1} C
P : C → Prop
A : Type u_2
inst✝² : AddMonoid A
inst✝¹ : HasShift C A
inst✝ : ClosedUnderIsomorphisms P
X : C
⊢ PredicateShift P 0 X ↔ P X
state_after: no goals
tactic: exact mem_iff_of_iso P ((shiftFunctorZero C A).app X)
Theorem: AddOreLocalization.add_neg
File: Mathlib/RingTheory/OreLocalization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝² : Monoid R
S : Submonoid R
inst✝¹ : OreSet S
X : Type ?u.97943
inst✝ : MulAction R X
s s' : ↥S
⊢ ↑s /ₒ s' * (↑s' /ₒ s) = 1
state_after: no goals
tactic: simp [oreDiv_mul_char (s : R) s' s' s 1 1 (by simp)]
Theorem: PEquiv.mem_ofSet_self_iff
File: Mathlib/Data/PEquiv.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
a : α
⊢ a ∈ (ofSet s) a ↔ a ∈ s
state_after: α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
a : α
⊢ (a ∈ if a ∈ s then some a else none) ↔ a ∈ s
tactic: dsimp [ofSet]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
s✝ : Set α
inst✝¹ : DecidablePred fun x => x ∈ s✝
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
a : α
⊢ (a ∈ if a ∈ s then some a else none) ↔ a ∈ s
state_after: no goals
tactic: split_ifs <;> simp [*]
Theorem: Path.Homotopic.pi_lift
File: Mathlib/Topology/Homotopy/Product.lean

Proof steps:
state_before: ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
γ : (i : ι) → Path (as i) (bs i)
⊢ (pi fun i => ⟦γ i⟧) = ⟦Path.pi γ⟧
state_after: ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
γ : (i : ι) → Path (as i) (bs i)
⊢ Quotient.map Path.pi ⋯ (Quotient.choice fun i => ⟦γ i⟧) = ⟦Path.pi γ⟧
tactic: unfold pi
state_before: ι : Type u_1
X : ι → Type u_2
inst✝ : (i : ι) → TopologicalSpace (X i)
as bs cs : (i : ι) → X i
γ : (i : ι) → Path (as i) (bs i)
⊢ Quotient.map Path.pi ⋯ (Quotient.choice fun i => ⟦γ i⟧) = ⟦Path.pi γ⟧
state_after: no goals
tactic: simp
Theorem: Finset.singleton_biUnion
File: Mathlib/Data/Finset/Union.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s s₁ s₂ : Finset α
t t₁ t₂ : α → Finset β
inst✝ : DecidableEq β
a : α
⊢ {a}.biUnion t = t a
state_after: no goals
tactic: classical rw [← insert_emptyc_eq, biUnion_insert, biUnion_empty, union_empty]
Theorem: Polynomial.map_dickson
File: Mathlib/RingTheory/Polynomial/Dickson.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
f : R →+* S
⊢ map f (dickson k a 0) = dickson k (f a) 0
state_after: no goals
tactic: simp_rw [dickson_zero, Polynomial.map_sub, Polynomial.map_natCast, Polynomial.map_ofNat]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
f : R →+* S
⊢ map f (dickson k a 1) = dickson k (f a) 1
state_after: no goals
tactic: simp only [dickson_one, map_X]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
f : R →+* S
n : ℕ
⊢ map f (dickson k a (n + 2)) = dickson k (f a) (n + 2)
state_after: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
f : R →+* S
n : ℕ
⊢ X * map f (dickson k a (n + 1)) - C (f a) * map f (dickson k a n) =
    X * dickson k (f a) (n + 1) - C (f a) * dickson k (f a) n
tactic: simp only [dickson_add_two, Polynomial.map_sub, Polynomial.map_mul, map_X, map_C]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
k : ℕ
a : R
f : R →+* S
n : ℕ
⊢ X * map f (dickson k a (n + 1)) - C (f a) * map f (dickson k a n) =
    X * dickson k (f a) (n + 1) - C (f a) * dickson k (f a) n
state_after: no goals
tactic: rw [map_dickson f n, map_dickson f (n + 1)]
Theorem: FintypeCat.Skeleton.incl_mk_nat_card
File: Mathlib/CategoryTheory/FintypeCat.lean

Proof steps:
state_before: n : ℕ
⊢ Fintype.card ↑(incl.obj (mk n)) = n
state_after: case h.e'_2
n : ℕ
⊢ Fintype.card ↑(incl.obj (mk n)) = Finset.univ.card
tactic: convert Finset.card_fin n
state_before: case h.e'_2
n : ℕ
⊢ Fintype.card ↑(incl.obj (mk n)) = Finset.univ.card
state_after: no goals
tactic: apply Fintype.ofEquiv_card
Theorem: Finset.forall_mem_not_eq'
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s : Finset α
a : α
⊢ (∀ b ∈ s, ¬b = a) ↔ a ∉ s
state_after: no goals
tactic: aesop
Theorem: Polynomial.natCast_comp
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
⊢ (↑n).comp p = ↑n
state_after: no goals
tactic: rw [← C_eq_natCast, C_comp]
Theorem: CategoryTheory.Abelian.mono_inr_of_isColimit
File: Mathlib/CategoryTheory/Abelian/Basic.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Abelian C
inst✝¹ : HasPushouts C
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : Mono f
s : PushoutCocone f g
hs : IsColimit s
⊢ Mono s.inr
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Abelian C
inst✝¹ : HasPushouts C
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : Mono f
s : PushoutCocone f g
hs : IsColimit s
this : Mono ((colimit.cocone (span f g)).ι.app WalkingCospan.right)
⊢ Mono s.inr
tactic: haveI : Mono (NatTrans.app (colimit.cocone (span f g)).ι WalkingCospan.right) :=
    Abelian.mono_pushout_of_mono_f f g
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Abelian C
inst✝¹ : HasPushouts C
W X Y Z : C
f : X ⟶ Y
g : X ⟶ Z
inst✝ : Mono f
s : PushoutCocone f g
hs : IsColimit s
this : Mono ((colimit.cocone (span f g)).ι.app WalkingCospan.right)
⊢ Mono s.inr
state_after: no goals
tactic: apply
    mono_of_mono_fac (IsColimit.comp_coconePointUniqueUpToIso_hom hs (colimit.isColimit _) _)
Theorem: LinearMap.surjective_domRestrict_iff
File: Mathlib/LinearAlgebra/Span.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S✝ : Type u_7
inst✝⁸ : Semiring R
inst✝⁷ : Semiring R₂
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup M₂
inst✝³ : Module R₂ M₂
τ₁₂ : R →+* R₂
inst✝² : RingHomSurjective τ₁₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F τ₁₂ M M₂
f : M →ₛₗ[τ₁₂] M₂
S : Submodule R M
hf : Surjective ⇑f
⊢ Surjective ⇑(f.domRestrict S) ↔ S ⊔ LinearMap.ker f = ⊤
state_after: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S✝ : Type u_7
inst✝⁸ : Semiring R
inst✝⁷ : Semiring R₂
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup M₂
inst✝³ : Module R₂ M₂
τ₁₂ : R →+* R₂
inst✝² : RingHomSurjective τ₁₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F τ₁₂ M M₂
f : M →ₛₗ[τ₁₂] M₂
S : Submodule R M
hf : LinearMap.range f = ⊤
⊢ LinearMap.range (f.domRestrict S) = ⊤ ↔ S ⊔ LinearMap.ker f = ⊤
tactic: rw [← LinearMap.range_eq_top] at hf ⊢
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S✝ : Type u_7
inst✝⁸ : Semiring R
inst✝⁷ : Semiring R₂
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup M₂
inst✝³ : Module R₂ M₂
τ₁₂ : R →+* R₂
inst✝² : RingHomSurjective τ₁₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F τ₁₂ M M₂
f : M →ₛₗ[τ₁₂] M₂
S : Submodule R M
hf : LinearMap.range f = ⊤
⊢ LinearMap.range (f.domRestrict S) = ⊤ ↔ S ⊔ LinearMap.ker f = ⊤
state_after: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S✝ : Type u_7
inst✝⁸ : Semiring R
inst✝⁷ : Semiring R₂
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup M₂
inst✝³ : Module R₂ M₂
τ₁₂ : R →+* R₂
inst✝² : RingHomSurjective τ₁₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F τ₁₂ M M₂
f : M →ₛₗ[τ₁₂] M₂
S : Submodule R M
hf : LinearMap.range f = ⊤
⊢ LinearMap.range (f.domRestrict S) = LinearMap.range f ↔ S ⊔ LinearMap.ker f = ⊤
tactic: rw [← hf]
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S✝ : Type u_7
inst✝⁸ : Semiring R
inst✝⁷ : Semiring R₂
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : AddCommGroup M₂
inst✝³ : Module R₂ M₂
τ₁₂ : R →+* R₂
inst✝² : RingHomSurjective τ₁₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F τ₁₂ M M₂
f : M →ₛₗ[τ₁₂] M₂
S : Submodule R M
hf : LinearMap.range f = ⊤
⊢ LinearMap.range (f.domRestrict S) = LinearMap.range f ↔ S ⊔ LinearMap.ker f = ⊤
state_after: no goals
tactic: exact LinearMap.range_domRestrict_eq_range_iff
Theorem: Int.lcm_mul_left
File: Mathlib/Data/Int/GCD.lean

Proof steps:
state_before: m n k : ℤ
⊢ (m * n).lcm (m * k) = m.natAbs * n.lcm k
state_after: no goals
tactic: simp_rw [Int.lcm, natAbs_mul, Nat.lcm_mul_left]
Theorem: ConjAct.orbitRel_conjAct
File: Mathlib/GroupTheory/GroupAction/ConjAct.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
G : Type u_3
G₀ : Type u_4
R : Type u_5
K : Type u_6
inst✝ : Group G
g h : G
⊢ (orbitRel (ConjAct G) G).Rel g h = IsConj g h
state_after: no goals
tactic: rw [orbitRel_apply, mem_orbit_conjAct]
Theorem: CategoryTheory.Limits.Cone.toUnder_π_app
File: Mathlib/CategoryTheory/Limits/ConeCategory.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
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c : Cone F
j : J
⊢ (((const J).obj (Under.mk (𝟙 c.pt))).obj j).hom ≫ c.π.app j =
    ((c.toStructuredArrow ⋙ StructuredArrow.toUnder c.pt F).obj j).hom
state_after: no goals
tactic: simp