ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Finset.prod_congr
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
h : s₁ = s₂
⊢ (∀ x ∈ s₂, f x = g x) → s₁.prod f = s₂.prod g
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
h : s₁ = s₂
⊢ (∀ x ∈ s₂, f x = g x) → s₂.prod f = s₂.prod g
tactic: rw [h]
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : CommMonoid β
h : s₁ = s₂
⊢ (∀ x ∈ s₂, f x = g x) → s₂.prod f = s₂.prod g
state_after: no goals
tactic: exact fold_congr
Theorem: BoundedContinuousFunction.norm_eq_of_nonempty
File: Mathlib/Topology/ContinuousFunction/Bounded.lean

Proof steps:
state_before: F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
h : Nonempty α
⊢ ‖f‖ = sInf {C | ∀ (x : α), ‖f x‖ ≤ C}
state_after: case intro
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
a : α
⊢ ‖f‖ = sInf {C | ∀ (x : α), ‖f x‖ ≤ C}
tactic: obtain ⟨a⟩ := h
state_before: case intro
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
a : α
⊢ ‖f‖ = sInf {C | ∀ (x : α), ‖f x‖ ≤ C}
state_after: case intro
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
a : α
⊢ sInf {C | 0 ≤ C ∧ ∀ (x : α), ‖f x‖ ≤ C} = sInf {C | ∀ (x : α), ‖f x‖ ≤ C}
tactic: rw [norm_eq]
state_before: case intro
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
a : α
⊢ sInf {C | 0 ≤ C ∧ ∀ (x : α), ‖f x‖ ≤ C} = sInf {C | ∀ (x : α), ‖f x‖ ≤ C}
state_after: case intro.e_a
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
a : α
⊢ {C | 0 ≤ C ∧ ∀ (x : α), ‖f x‖ ≤ C} = {C | ∀ (x : α), ‖f x‖ ≤ C}
tactic: congr
state_before: case intro.e_a
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
a : α
⊢ {C | 0 ≤ C ∧ ∀ (x : α), ‖f x‖ ≤ C} = {C | ∀ (x : α), ‖f x‖ ≤ C}
state_after: case intro.e_a.h
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
a : α
x✝ : ℝ
⊢ x✝ ∈ {C | 0 ≤ C ∧ ∀ (x : α), ‖f x‖ ≤ C} ↔ x✝ ∈ {C | ∀ (x : α), ‖f x‖ ≤ C}
tactic: ext
state_before: case intro.e_a.h
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
a : α
x✝ : ℝ
⊢ x✝ ∈ {C | 0 ≤ C ∧ ∀ (x : α), ‖f x‖ ≤ C} ↔ x✝ ∈ {C | ∀ (x : α), ‖f x‖ ≤ C}
state_after: case intro.e_a.h
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
a : α
x✝ : ℝ
⊢ (∀ (x : α), ‖f x‖ ≤ x✝) → 0 ≤ x✝
tactic: simp only [mem_setOf_eq, and_iff_right_iff_imp]
state_before: case intro.e_a.h
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝¹ : TopologicalSpace α
inst✝ : SeminormedAddCommGroup β
f g : α →ᵇ β
x : α
C : ℝ
a : α
x✝ : ℝ
⊢ (∀ (x : α), ‖f x‖ ≤ x✝) → 0 ≤ x✝
state_after: no goals
tactic: exact fun h' => le_trans (norm_nonneg (f a)) (h' a)
Theorem: Multiset.strongDownwardInductionOn_eq
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : Multiset α → Sort u_3
s : Multiset α
n : ℕ
H : (t₁ : Multiset α) → ({t₂ : Multiset α} → card t₂ ≤ n → t₁ < t₂ → p t₂) → card t₁ ≤ n → p t₁
⊢ (fun a => s.strongDownwardInductionOn H a) = H s fun {t} ht _h => t.strongDownwardInductionOn H ht
state_after: α : Type u_1
β : Type v
γ : Type u_2
p : Multiset α → Sort u_3
s : Multiset α
n : ℕ
H : (t₁ : Multiset α) → ({t₂ : Multiset α} → card t₂ ≤ n → t₁ < t₂ → p t₂) → card t₁ ≤ n → p t₁
⊢ (fun a => strongDownwardInduction H s a) = H s fun {t} ht _h => strongDownwardInduction H t ht
tactic: dsimp only [strongDownwardInductionOn]
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : Multiset α → Sort u_3
s : Multiset α
n : ℕ
H : (t₁ : Multiset α) → ({t₂ : Multiset α} → card t₂ ≤ n → t₁ < t₂ → p t₂) → card t₁ ≤ n → p t₁
⊢ (fun a => strongDownwardInduction H s a) = H s fun {t} ht _h => strongDownwardInduction H t ht
state_after: no goals
tactic: rw [strongDownwardInduction]
Theorem: Polynomial.degree_sub_eq_left_of_degree_lt
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Ring R
p q : R[X]
h : q.degree < p.degree
⊢ (p - q).degree = p.degree
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Ring R
p q : R[X]
h : (-q).degree < p.degree
⊢ (p - q).degree = p.degree
tactic: rw [← degree_neg q] at h
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Ring R
p q : R[X]
h : (-q).degree < p.degree
⊢ (p - q).degree = p.degree
state_after: no goals
tactic: rw [sub_eq_add_neg, degree_add_eq_left_of_degree_lt h]
Theorem: List.mem_keys_kerase_of_ne
File: Mathlib/Data/List/Sigma.lean

Proof steps:
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a₁ a₂ : α
l : List (Sigma β)
h : a₁ ≠ a₂
p✝ : a₁ ∈ l.keys
w✝² : β a₂
w✝¹ w✝ : List (Sigma β)
left✝ : a₂ ∉ w✝¹.keys
p : a₁ ∈ (w✝¹ ++ ⟨a₂, w✝²⟩ :: w✝).keys
q : a₂ ∈ (w✝¹ ++ ⟨a₂, w✝²⟩ :: w✝).keys
⊢ a₁ ∈ (w✝¹ ++ w✝).keys
state_after: no goals
tactic: simpa [keys, h] using p
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a₁ a₂ : α
l : List (Sigma β)
h : a₁ ≠ a₂
p : a₁ ∈ l.keys
q : a₂ ∉ l.keys
⊢ a₁ ∈ (kerase a₂ l).keys
state_after: no goals
tactic: simp [q, p]
Theorem: TensorAlgebra.hom_ext
File: Mathlib/LinearAlgebra/TensorAlgebra/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Type u_2
inst✝³ : AddCommMonoid M
inst✝² : Module R M
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f g : TensorAlgebra R M →ₐ[R] A
w : f.toLinearMap ∘ₗ ι R = g.toLinearMap ∘ₗ ι R
⊢ f = g
state_after: R : Type u_1
inst✝⁴ : CommSemiring R
M : Type u_2
inst✝³ : AddCommMonoid M
inst✝² : Module R M
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f g : TensorAlgebra R M →ₐ[R] A
w : (lift R).symm f = (lift R).symm g
⊢ f = g
tactic: rw [← lift_symm_apply, ← lift_symm_apply] at w
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Type u_2
inst✝³ : AddCommMonoid M
inst✝² : Module R M
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f g : TensorAlgebra R M →ₐ[R] A
w : (lift R).symm f = (lift R).symm g
⊢ f = g
state_after: no goals
tactic: exact (lift R).symm.injective w
Theorem: CategoryTheory.Limits.walkingParallelFamilyEquivWalkingParallelPair_counitIso_inv_app
File: Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean

Proof steps:
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X✝ Y : C
f : J → (X✝ ⟶ Y)
X : WalkingParallelFamily (ULift.{w, 0} Bool)
⊢ (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).obj X =
    ((parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
          parallelPair (line { down := true }) (line { down := false })).obj
      X
state_after: no goals
tactic: cases X <;> rfl
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ ∀ {X Y : WalkingParallelFamily (ULift.{w, 0} Bool)} (f : X ⟶ Y),
    (𝟭 (WalkingParallelFamily (ULift.{w, 0} Bool))).map f ≫ ((fun X => eqToIso ⋯) Y).hom =
      ((fun X => eqToIso ⋯) X).hom ≫
        ((parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right) ⋙
              parallelPair (line { down := true }) (line { down := false })).map
          f
state_after: no goals
tactic: rintro _ _ (_|⟨_|_⟩) <;> aesop_cat
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X✝ Y : C
f : J → (X✝ ⟶ Y)
X : WalkingParallelPair
⊢ (parallelPair (line { down := true }) (line { down := false }) ⋙
          parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).obj
      X =
    (𝟭 WalkingParallelPair).obj X
state_after: no goals
tactic: cases X <;> rfl
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ ∀ {X Y : WalkingParallelPair} (f : X ⟶ Y),
    (parallelPair (line { down := true }) (line { down := false }) ⋙
              parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).map
          f ≫
        ((fun X => eqToIso ⋯) Y).hom =
      ((fun X => eqToIso ⋯) X).hom ≫ (𝟭 WalkingParallelPair).map f
state_after: no goals
tactic: rintro _ _ (_|_|_) <;> aesop_cat
state_before: J : Type w
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f : J → (X ⟶ Y)
⊢ ∀ (X : WalkingParallelFamily (ULift.{w, 0} Bool)),
    (parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).map
          ((NatIso.ofComponents (fun X => eqToIso ⋯) ⋯).hom.app X) ≫
        (NatIso.ofComponents (fun X => eqToIso ⋯) ⋯).hom.app
          ((parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).obj
            X) =
      𝟙 ((parallelFamily fun p => bif p.down then WalkingParallelPairHom.left else WalkingParallelPairHom.right).obj X)
state_after: no goals
tactic: rintro (_|_) <;> aesop_cat
Theorem: Multiset.filter_comm
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
p : α → Prop
inst✝¹ : DecidablePred p
q : α → Prop
inst✝ : DecidablePred q
s : Multiset α
⊢ filter p (filter q s) = filter q (filter p s)
state_after: no goals
tactic: simp [and_comm]
Theorem: Nat.log_of_one_lt_of_le
File: Mathlib/Data/Nat/Log.lean

Proof steps:
state_before: b n : ℕ
h : 1 < b
hn : b ≤ n
⊢ log b n = log b (n / b) + 1
state_after: b n : ℕ
h : 1 < b
hn : b ≤ n
⊢ (if h : b ≤ n ∧ 1 < b then log b (n / b) + 1 else 0) = log b (n / b) + 1
tactic: rw [log]
state_before: b n : ℕ
h : 1 < b
hn : b ≤ n
⊢ (if h : b ≤ n ∧ 1 < b then log b (n / b) + 1 else 0) = log b (n / b) + 1
state_after: no goals
tactic: exact if_pos ⟨hn, h⟩
Theorem: Irrational.mul_int
File: Mathlib/Data/Real/Irrational.lean

Proof steps:
state_before: q : ℚ
x y : ℝ
h : Irrational x
m : ℤ
hm : m ≠ 0
⊢ Irrational (x * ↑m)
state_after: q : ℚ
x y : ℝ
h : Irrational x
m : ℤ
hm : m ≠ 0
⊢ Irrational (x * ↑↑m)
tactic: rw [← cast_intCast]
state_before: q : ℚ
x y : ℝ
h : Irrational x
m : ℤ
hm : m ≠ 0
⊢ Irrational (x * ↑↑m)
state_after: q : ℚ
x y : ℝ
h : Irrational x
m : ℤ
hm : m ≠ 0
⊢ ↑m ≠ 0
tactic: refine h.mul_rat ?_
state_before: q : ℚ
x y : ℝ
h : Irrational x
m : ℤ
hm : m ≠ 0
⊢ ↑m ≠ 0
state_after: no goals
tactic: rwa [Int.cast_ne_zero]
Theorem: iUnion_Iio_eq_univ_iff
File: Mathlib/Order/Interval/Set/Disjoint.lean

Proof steps:
state_before: ι : Sort u
α : Type v
β : Type w
inst✝ : LinearOrder α
s : Set α
a : α
f : ι → α
⊢ ⋃ i, Iio (f i) = univ ↔ ¬BddAbove (range f)
state_after: no goals
tactic: simp [not_bddAbove_iff, Set.eq_univ_iff_forall]
Theorem: SemiNormedGrp.explicitCokernelDesc_unique
File: Mathlib/Analysis/Normed/Group/SemiNormedGrp/Kernels.lean

Proof steps:
state_before: X Y Z : SemiNormedGrp
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
e : explicitCokernel f ⟶ Z
he : explicitCokernelπ f ≫ e = g
⊢ e = explicitCokernelDesc w
state_after: case x
X Y Z : SemiNormedGrp
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
e : explicitCokernel f ⟶ Z
he : explicitCokernelπ f ≫ e = g
⊢ ∀ (j : WalkingParallelPair), (cokernelCocone f).ι.app j ≫ e = (Cofork.ofπ g ⋯).ι.app j
tactic: apply (isColimitCokernelCocone f).uniq (Cofork.ofπ g (by simp [w]))
state_before: case x
X Y Z : SemiNormedGrp
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
e : explicitCokernel f ⟶ Z
he : explicitCokernelπ f ≫ e = g
⊢ ∀ (j : WalkingParallelPair), (cokernelCocone f).ι.app j ≫ e = (Cofork.ofπ g ⋯).ι.app j
state_after: case x.zero
X Y Z : SemiNormedGrp
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
e : explicitCokernel f ⟶ Z
he : explicitCokernelπ f ≫ e = g
⊢ (cokernelCocone f).ι.app WalkingParallelPair.zero ≫ e = (Cofork.ofπ g ⋯).ι.app WalkingParallelPair.zero

case x.one
X Y Z : SemiNormedGrp
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
e : explicitCokernel f ⟶ Z
he : explicitCokernelπ f ≫ e = g
⊢ (cokernelCocone f).ι.app WalkingParallelPair.one ≫ e = (Cofork.ofπ g ⋯).ι.app WalkingParallelPair.one
tactic: rintro (_ | _)
Theorem: Rep.diagonalHomEquiv_apply
File: Mathlib/RepresentationTheory/GroupCohomology/Resolution.lean

Proof steps:
state_before: k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
A : Rep k G
f : ofMulAction k G (Fin (n + 1) → G) ⟶ A
x : Fin n → G
⊢ (diagonalHomEquiv n A) f x = f.hom (Finsupp.single (Fin.partialProd x) 1)
state_after: k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
A : Rep k G
f : ofMulAction k G (Fin (n + 1) → G) ⟶ A
x : Fin n → G
⊢ f.hom ((diagonalSucc k G n).inv.hom (Finsupp.single 1 1 ⊗ₜ[k] Finsupp.single x 1)) =
    f.hom (Finsupp.single (Fin.partialProd x) 1)
tactic: change f.hom ((diagonalSucc k G n).inv.hom (Finsupp.single 1 1 ⊗ₜ[k] Finsupp.single x 1)) = _
state_before: k G : Type u
inst✝¹ : CommRing k
n : ℕ
inst✝ : Group G
A : Rep k G
f : ofMulAction k G (Fin (n + 1) → G) ⟶ A
x : Fin n → G
⊢ f.hom ((diagonalSucc k G n).inv.hom (Finsupp.single 1 1 ⊗ₜ[k] Finsupp.single x 1)) =
    f.hom (Finsupp.single (Fin.partialProd x) 1)
state_after: no goals
tactic: rw [diagonalSucc_inv_single_single, one_smul, one_mul]
Theorem: addOrderOf_injective
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H✝ : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Monoid G
a b x✝ y : G
n m : ℕ
H : Type u_6
inst✝ : Monoid H
f : G →* H
hf : Injective ⇑f
x : G
⊢ orderOf (f x) = orderOf x
state_after: no goals
tactic: simp_rw [orderOf_eq_orderOf_iff, ← f.map_pow, ← f.map_one, hf.eq_iff, forall_const]
Theorem: String.data_join
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: ss : List String
⊢ (join ss).data = (List.map data ss).join
state_after: no goals
tactic: rw [join_eq]
Theorem: Equiv.Perm.one_lt_card_support_of_ne_one
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
h : f ≠ 1
⊢ 1 < f.support.card
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
h : f ≠ 1
⊢ ∃ a b, ¬(f a = a ∨ f b = b ∨ a = b)
tactic: simp_rw [one_lt_card_iff, mem_support, ← not_or]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
h : f ≠ 1
⊢ ∃ a b, ¬(f a = a ∨ f b = b ∨ a = b)
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
h : ∀ (a b : α), f a = a ∨ f b = b ∨ a = b
⊢ f = 1
tactic: contrapose! h
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
h : ∀ (a b : α), f a = a ∨ f b = b ∨ a = b
⊢ f = 1
state_after: case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
h : ∀ (a b : α), f a = a ∨ f b = b ∨ a = b
a : α
⊢ f a = 1 a
tactic: ext a
state_before: case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
h : ∀ (a b : α), f a = a ∨ f b = b ∨ a = b
a : α
⊢ f a = 1 a
state_after: case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
a : α
h : f (f a) = f a ∨ f a = a ∨ f a = a
⊢ f a = 1 a
tactic: specialize h (f a) a
state_before: case H
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
a : α
h : f (f a) = f a ∨ f a = a ∨ f a = a
⊢ f a = 1 a
state_after: no goals
tactic: rwa [apply_eq_iff_eq, or_self_iff, or_self_iff] at h
Theorem: CategoryTheory.Pseudofunctor.mapComp_id_right_inv
File: Mathlib/CategoryTheory/Bicategory/Functor/Pseudofunctor.lean

Proof steps:
state_before: B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ F : Pseudofunctor B C
a b : B
f : a ⟶ b
⊢ (F.mapComp f (𝟙 b)).inv = F.map f ◁ (F.mapId b).hom ≫ (ρ_ (F.map f)).hom ≫ F.map₂ (ρ_ f).inv
state_after: no goals
tactic: simp [mapComp_id_right]
Theorem: _private.Mathlib.NumberTheory.SiegelsLemma.0.Int.Matrix.card_S_lt_card_T
File: Mathlib/NumberTheory/SiegelsLemma.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
v : β → ℤ
hn : m < n
hm : 0 < m
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ S.card < T.card
state_after: α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
v : β → ℤ
hn : m < n
hm : 0 < m
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ ↑S.card < ↑T.card
tactic: zify
state_before: α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
v : β → ℤ
hn : m < n
hm : 0 < m
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ ↑S.card < ↑T.card
state_after: α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
v : β → ℤ
hn : m < n
hm : 0 < m
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ ∏ i : α, (P i - N i + 1) < ↑((B + 1) ^ n)
tactic: rw [card_T_eq A, card_S_eq]
state_before: α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
v : β → ℤ
hn : m < n
hm : 0 < m
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ ∏ i : α, (P i - N i + 1) < ↑((B + 1) ^ n)
state_after: α : Type u_1
β : Type u_2
inst✝³ : Fintype α
inst✝² : Fintype β
A : Matrix α β ℤ
v : β → ℤ
hn : m < n
hm : 0 < m
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ ∏ x : α, (∑ x_1 : β, ↑B * ↑(A x x_1)⁺ - ∑ x_1 : β, ↑B * -↑(A x x_1)⁻ + 1) < (↑B + 1) ^ n
tactic: rify
Theorem: Matrix.StdBasisMatrix.trace_zero
File: Mathlib/Data/Matrix/Basis.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
R : Type u_4
α : Type u_5
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : Semiring α
i j : n
c : α
i' j' : n
inst✝ : Fintype n
h : j ≠ i
⊢ (stdBasisMatrix i j c).trace = 0
state_after: no goals
tactic: simp [trace, -diag_apply, h]
Theorem: sameRay_neg_iff
File: Mathlib/LinearAlgebra/Ray.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : StrictOrderedCommRing R
M : Type u_2
N : Type u_3
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
x y : M
⊢ SameRay R (-x) (-y) ↔ SameRay R x y
state_after: no goals
tactic: simp only [SameRay, neg_eq_zero, smul_neg, neg_inj]
Theorem: ENNReal.iSup_mul
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
⊢ iSup f * a = ⨆ i, f i * a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
⊢ ⨆ i, a * f i = ⨆ i, f i * a
tactic: rw [mul_comm, mul_iSup]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
⊢ ⨆ i, a * f i = ⨆ i, f i * a
state_after: case e_s
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
⊢ (fun i => a * f i) = fun i => f i * a
tactic: congr
state_before: case e_s
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
⊢ (fun i => a * f i) = fun i => f i * a
state_after: case e_s.h
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
x✝ : ι
⊢ a * f x✝ = f x✝ * a
tactic: funext
state_before: case e_s.h
α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_4
f : ι → ℝ≥0∞
a : ℝ≥0∞
x✝ : ι
⊢ a * f x✝ = f x✝ * a
state_after: no goals
tactic: rw [mul_comm]
Theorem: Lists.Equiv.antisymm_iff
File: Mathlib/SetTheory/Lists.lean

Proof steps:
state_before: α : Type u_1
l₁ l₂ : Lists' α true
⊢ of' l₁ ~ of' l₂ ↔ l₁ ⊆ l₂ ∧ l₂ ⊆ l₁
state_after: α : Type u_1
l₁ l₂ : Lists' α true
h : of' l₁ ~ of' l₂
⊢ l₁ ⊆ l₂ ∧ l₂ ⊆ l₁
tactic: refine ⟨fun h => ?_, fun ⟨h₁, h₂⟩ => Equiv.antisymm h₁ h₂⟩
state_before: α : Type u_1
l₁ l₂ : Lists' α true
h : of' l₁ ~ of' l₂
⊢ l₁ ⊆ l₂ ∧ l₂ ⊆ l₁
state_after: case refl
α : Type u_1
l₁ : Lists' α true
⊢ l₁ ⊆ l₁ ∧ l₁ ⊆ l₁

case antisymm
α : Type u_1
l₁ l₂ : Lists' α true
h₁ : l₁.Subset l₂
h₂ : l₂.Subset l₁
⊢ l₁ ⊆ l₂ ∧ l₂ ⊆ l₁
tactic: cases' h with _ _ _ h₁ h₂
Theorem: AddCommGroup.modEq_refl
File: Mathlib/Algebra/ModEq.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a✝ a₁ a₂ b b₁ b₂ c : α
n : ℕ
z : ℤ
a : α
⊢ a - a = 0 • p
state_after: no goals
tactic: simp
Theorem: ModuleCat.Derivation.d_mul
File: Mathlib/Algebra/Category/ModuleCat/Differentials/Basic.lean

Proof steps:
state_before: A B : CommRingCat
M : ModuleCat ↑B
f : A ⟶ B
D : M.Derivation f
b b' : ↑B
⊢ D.d (b * b') = b • D.d b' + b' • D.d b
state_after: no goals
tactic: simp [d]
Theorem: MonoidHom.comp_div
File: Mathlib/Algebra/Group/Hom/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : CommGroup G
inst✝ : CommGroup H
f : G →* H
g h : M →* G
⊢ f.comp (g / h) = f.comp g / f.comp h
state_after: case h
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : CommGroup G
inst✝ : CommGroup H
f : G →* H
g h : M →* G
x✝ : M
⊢ (f.comp (g / h)) x✝ = (f.comp g / f.comp h) x✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
G : Type u_6
H : Type u_7
F : Type u_8
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : CommGroup G
inst✝ : CommGroup H
f : G →* H
g h : M →* G
x✝ : M
⊢ (f.comp (g / h)) x✝ = (f.comp g / f.comp h) x✝
state_after: no goals
tactic: simp only [Function.comp_apply, div_apply, map_div, coe_comp]
Theorem: Matrix.det_vandermonde_ne_zero_iff
File: Mathlib/LinearAlgebra/Vandermonde.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
v : Fin n → R
⊢ (vandermonde v).det ≠ 0 ↔ Function.Injective v
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
v : Fin n → R
⊢ (vandermonde v).det ≠ 0 ↔ ∀ ⦃a₁ a₂ : Fin n⦄, v a₁ = v a₂ → a₁ = a₂
tactic: unfold Function.Injective
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
v : Fin n → R
⊢ (vandermonde v).det ≠ 0 ↔ ∀ ⦃a₁ a₂ : Fin n⦄, v a₁ = v a₂ → a₁ = a₂
state_after: no goals
tactic: simp only [det_vandermonde_eq_zero_iff, Ne, not_exists, not_and, Classical.not_not]
Theorem: Finset.eq_univ_of_card
File: Mathlib/Data/Fintype/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Fintype α
s : Finset α
hs : s.card = Fintype.card α
⊢ univ.card ≤ s.card
state_after: no goals
tactic: rw [hs, Finset.card_univ]