ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AlgebraicTopology.DoldKan.hσ'_eq
File: Mathlib/AlgebraicTopology/DoldKan/Homotopies.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.10933, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q n a m : ℕ
ha : n = a + q
hnm : c.Rel m n
⊢ X _[n + 1] = K[X].X m
state_after: no goals
tactic: congr
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q n a m : ℕ
ha : n = a + q
hnm : c.Rel m n
⊢ hσ' q n m hnm = ((-1) ^ a • X.σ ⟨a, ⋯⟩) ≫ eqToHom ⋯
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q n a m : ℕ
ha : n = a + q
hnm : c.Rel m n
⊢ (if n < q then 0 else (-1) ^ (n - q) • X.σ ⟨n - q, ⋯⟩) ≫ eqToHom ⋯ = ((-1) ^ a • X.σ ⟨a, ⋯⟩) ≫ eqToHom ⋯
tactic: simp only [hσ', hσ]
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q n a m : ℕ
ha : n = a + q
hnm : c.Rel m n
⊢ (if n < q then 0 else (-1) ^ (n - q) • X.σ ⟨n - q, ⋯⟩) ≫ eqToHom ⋯ = ((-1) ^ a • X.σ ⟨a, ⋯⟩) ≫ eqToHom ⋯
state_after: case pos
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q n a m : ℕ
ha : n = a + q
hnm : c.Rel m n
h✝ : n < q
⊢ 0 ≫ eqToHom ⋯ = ((-1) ^ a • X.σ ⟨a, ⋯⟩) ≫ eqToHom ⋯

case neg
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
q n a m : ℕ
ha : n = a + q
hnm : c.Rel m n
h✝ : ¬n < q
⊢ ((-1) ^ (n - q) • X.σ ⟨n - q, ⋯⟩) ≫ eqToHom ⋯ = ((-1) ^ a • X.σ ⟨a, ⋯⟩) ≫ eqToHom ⋯
tactic: split_ifs
Theorem: thickening_cthickening
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
hε : 0 < ε
hδ : 0 ≤ δ
s : Set E
⊢ thickening ε (cthickening δ s) = thickening (ε + δ) s
state_after: case inl
𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
ε : ℝ
hε : 0 < ε
s : Set E
hδ : 0 ≤ 0
⊢ thickening ε (cthickening 0 s) = thickening (ε + 0) s

case inr
𝕜 : Type u_1
E : Type u_2
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
hε : 0 < ε
hδ✝ : 0 ≤ δ
s : Set E
hδ : 0 < δ
⊢ thickening ε (cthickening δ s) = thickening (ε + δ) s
tactic: obtain rfl | hδ := hδ.eq_or_lt
Theorem: Polynomial.coeff_divX
File: Mathlib/Algebra/Polynomial/Inductions.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ p.divX.coeff n = p.coeff (n + 1)
state_after: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ p.divX.coeff n = p.coeff (1 + n)
tactic: rw [add_comm]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ p.divX.coeff n = p.coeff (1 + n)
state_after: case ofFinsupp
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
q : R[X]
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ { toFinsupp := toFinsupp✝ }.divX.coeff n = { toFinsupp := toFinsupp✝ }.coeff (1 + n)
tactic: cases p
state_before: case ofFinsupp
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
q : R[X]
toFinsupp✝ : AddMonoidAlgebra R ℕ
⊢ { toFinsupp := toFinsupp✝ }.divX.coeff n = { toFinsupp := toFinsupp✝ }.coeff (1 + n)
state_after: no goals
tactic: rfl
Theorem: BoxIntegral.Box.dist_le_distortion_mul
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

Proof steps:
state_before: ι : Type u_1
I✝ J : Box ι
x y : ι → ℝ
inst✝ : Fintype ι
I : Box ι
i : ι
⊢ dist I.lower I.upper ≤ ↑I.distortion * (I.upper i - I.lower i)
state_after: ι : Type u_1
I✝ J : Box ι
x y : ι → ℝ
inst✝ : Fintype ι
I : Box ι
i : ι
A : I.lower i - I.upper i < 0
⊢ dist I.lower I.upper ≤ ↑I.distortion * (I.upper i - I.lower i)
tactic: have A : I.lower i - I.upper i < 0 := sub_neg.2 (I.lower_lt_upper i)
state_before: ι : Type u_1
I✝ J : Box ι
x y : ι → ℝ
inst✝ : Fintype ι
I : Box ι
i : ι
A : I.lower i - I.upper i < 0
⊢ dist I.lower I.upper ≤ ↑I.distortion * (I.upper i - I.lower i)
state_after: no goals
tactic: simpa only [← NNReal.coe_le_coe, ← dist_nndist, NNReal.coe_mul, Real.dist_eq, abs_of_neg A,
    neg_sub] using I.nndist_le_distortion_mul i
Theorem: CategoryTheory.isSubterminal_of_mono_terminal_from
File: Mathlib/CategoryTheory/Subterminal.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
A : C
inst✝¹ : HasTerminal C
inst✝ : Mono (terminal.from A)
Z : C
f g : Z ⟶ A
⊢ f = g
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
A : C
inst✝¹ : HasTerminal C
inst✝ : Mono (terminal.from A)
Z : C
f g : Z ⟶ A
⊢ f ≫ terminal.from A = g ≫ terminal.from A
tactic: rw [← cancel_mono (terminal.from A)]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
A : C
inst✝¹ : HasTerminal C
inst✝ : Mono (terminal.from A)
Z : C
f g : Z ⟶ A
⊢ f ≫ terminal.from A = g ≫ terminal.from A
state_after: no goals
tactic: subsingleton
Theorem: ENNReal.coe_div_le
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ ↑(p / r) ≤ ↑p / ↑r
state_after: no goals
tactic: simpa only [div_eq_mul_inv, coe_mul] using mul_le_mul_left' coe_inv_le _
Theorem: CategoryTheory.OplaxNatTrans.rightUnitor_hom_app
File: Mathlib/CategoryTheory/Bicategory/FunctorBicategory.lean

Proof steps:
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I : OplaxFunctor B C
η : F ⟶ G
⊢ ∀ {a b : B} (f : a ⟶ b),
    F.map f ◁ ((fun a => ρ_ (η.app a)) b).hom ≫ η.naturality f =
      (η ≫ 𝟙 G).naturality f ≫ ((fun a => ρ_ (η.app a)) a).hom ▷ G.map f
state_after: no goals
tactic: aesop_cat
Theorem: MeasureTheory.SignedMeasure.toMeasureOfLEZero_toSignedMeasure
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
s : SignedMeasure α
i j : Set α
hs : VectorMeasure.restrict s univ ≤ VectorMeasure.restrict 0 univ
⊢ (s.toMeasureOfLEZero univ ⋯ hs).toSignedMeasure = -s
state_after: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
s : SignedMeasure α
i✝ j : Set α
hs : VectorMeasure.restrict s univ ≤ VectorMeasure.restrict 0 univ
i : Set α
hi : MeasurableSet i
⊢ ↑(s.toMeasureOfLEZero univ ⋯ hs).toSignedMeasure i = ↑(-s) i
tactic: ext i hi
state_before: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
s : SignedMeasure α
i✝ j : Set α
hs : VectorMeasure.restrict s univ ≤ VectorMeasure.restrict 0 univ
i : Set α
hi : MeasurableSet i
⊢ ↑(s.toMeasureOfLEZero univ ⋯ hs).toSignedMeasure i = ↑(-s) i
state_after: no goals
tactic: simp [hi, toMeasureOfLEZero_apply _ _ _ hi]
Theorem: Real.sqrt_zero
File: Mathlib/Data/Real/Sqrt.lean

Proof steps:
state_before: x y : ℝ
⊢ √0 = 0
state_after: no goals
tactic: simp [Real.sqrt]
Theorem: IsAdjoinRootMonic.coeff_apply_le
File: Mathlib/RingTheory/IsAdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
z : S
i : ℕ
hi : f.natDegree ≤ i
⊢ h.coeff z i = 0
state_after: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
z : S
i : ℕ
hi : f.natDegree ≤ i
⊢ { toFun := Polynomial.coeff, map_add' := ⋯ } (h.modByMonicHom z) i = 0
tactic: simp only [coeff, LinearMap.comp_apply, Finsupp.lcoeFun_apply, Finsupp.lmapDomain_apply,
    LinearEquiv.coe_coe, liftPolyₗ_apply, LinearMap.coe_mk, h.basis_repr]
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
z : S
i : ℕ
hi : f.natDegree ≤ i
⊢ { toFun := Polynomial.coeff, map_add' := ⋯ } (h.modByMonicHom z) i = 0
state_after: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
z : S
i : ℕ
hi : f.natDegree ≤ i
a✝ : Nontrivial R
⊢ { toFun := Polynomial.coeff, map_add' := ⋯ } (h.modByMonicHom z) i = 0
tactic: nontriviality R
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h : IsAdjoinRootMonic S f
z : S
i : ℕ
hi : f.natDegree ≤ i
a✝ : Nontrivial R
⊢ { toFun := Polynomial.coeff, map_add' := ⋯ } (h.modByMonicHom z) i = 0
state_after: no goals
tactic: exact
    Polynomial.coeff_eq_zero_of_degree_lt
      ((degree_modByMonic_lt _ h.Monic).trans_le (Polynomial.degree_le_of_natDegree_le hi))
Theorem: List.head_replicate
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
n : ℕ
a : α
h : replicate n a ≠ []
⊢ (replicate n a).head h = a
state_after: no goals
tactic: cases n <;> simp [replicate_succ] at h ⊢
Theorem: bddAbove_iff_exists_ge
File: Mathlib/Order/Bounds/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t : Set α
a b : α
inst✝ : SemilatticeSup γ
s : Set γ
x₀ : γ
⊢ BddAbove s ↔ ∃ x, x₀ ≤ x ∧ ∀ y ∈ s, y ≤ x
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t : Set α
a b : α
inst✝ : SemilatticeSup γ
s : Set γ
x₀ : γ
⊢ Monotone fun x => ∀ y ∈ s, y ≤ x
tactic: rw [bddAbove_def, exists_ge_and_iff_exists]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t : Set α
a b : α
inst✝ : SemilatticeSup γ
s : Set γ
x₀ : γ
⊢ Monotone fun x => ∀ y ∈ s, y ≤ x
state_after: no goals
tactic: exact Monotone.ball fun x _ => monotone_le
Theorem: Subtype.coe_image_subset
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
s : Set α
t : Set ↑s
x : α
x✝ : x ∈ val '' t
y : { x // x ∈ s }
left✝ : y ∈ t
yvaleq : ↑y = x
⊢ x ∈ s
state_after: α : Type u_1
s : Set α
t : Set ↑s
x : α
x✝ : x ∈ val '' t
y : { x // x ∈ s }
left✝ : y ∈ t
yvaleq : ↑y = x
⊢ ↑y ∈ s
tactic: rw [← yvaleq]
state_before: α : Type u_1
s : Set α
t : Set ↑s
x : α
x✝ : x ∈ val '' t
y : { x // x ∈ s }
left✝ : y ∈ t
yvaleq : ↑y = x
⊢ ↑y ∈ s
state_after: no goals
tactic: exact y.property
Theorem: Polynomial.coeff_prod_of_natDegree_le
File: Mathlib/Algebra/Polynomial/BigOperators.lean

Proof steps:
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f✝ : ι → R[X]
t : Multiset R[X]
f : ι → R[X]
n : ℕ
h : ∀ p ∈ s, (f p).natDegree ≤ n
⊢ (∏ i ∈ s, f i).coeff (s.card * n) = ∏ i ∈ s, (f i).coeff n
state_after: case mk
R : Type u
ι : Type w
inst✝ : CommSemiring R
f✝ : ι → R[X]
t : Multiset R[X]
f : ι → R[X]
n : ℕ
l : Multiset ι
hl : l.Nodup
h : ∀ p ∈ { val := l, nodup := hl }, (f p).natDegree ≤ n
⊢ (∏ i ∈ { val := l, nodup := hl }, f i).coeff ({ val := l, nodup := hl }.card * n) =
    ∏ i ∈ { val := l, nodup := hl }, (f i).coeff n
tactic: cases' s with l hl
state_before: case mk
R : Type u
ι : Type w
inst✝ : CommSemiring R
f✝ : ι → R[X]
t : Multiset R[X]
f : ι → R[X]
n : ℕ
l : Multiset ι
hl : l.Nodup
h : ∀ p ∈ { val := l, nodup := hl }, (f p).natDegree ≤ n
⊢ (∏ i ∈ { val := l, nodup := hl }, f i).coeff ({ val := l, nodup := hl }.card * n) =
    ∏ i ∈ { val := l, nodup := hl }, (f i).coeff n
state_after: case h.e'_2.h.e'_4.h.e'_5
R : Type u
ι : Type w
inst✝ : CommSemiring R
f✝ : ι → R[X]
t : Multiset R[X]
f : ι → R[X]
n : ℕ
l : Multiset ι
hl : l.Nodup
h : ∀ p ∈ { val := l, nodup := hl }, (f p).natDegree ≤ n
⊢ { val := l, nodup := hl }.card = Multiset.card (Multiset.map f l)

case h.e'_3
R : Type u
ι : Type w
inst✝ : CommSemiring R
f✝ : ι → R[X]
t : Multiset R[X]
f : ι → R[X]
n : ℕ
l : Multiset ι
hl : l.Nodup
h : ∀ p ∈ { val := l, nodup := hl }, (f p).natDegree ≤ n
⊢ ∏ i ∈ { val := l, nodup := hl }, (f i).coeff n = (Multiset.map (fun p => p.coeff n) (Multiset.map f l)).prod

case mk
R : Type u
ι : Type w
inst✝ : CommSemiring R
f✝ : ι → R[X]
t : Multiset R[X]
f : ι → R[X]
n : ℕ
l : Multiset ι
hl : l.Nodup
h : ∀ p ∈ { val := l, nodup := hl }, (f p).natDegree ≤ n
⊢ ∀ p ∈ Multiset.map f l, p.natDegree ≤ n
tactic: convert coeff_multiset_prod_of_natDegree_le (l.map f) n ?_
Theorem: Set.center_units_subset
File: Mathlib/Algebra/GroupWithZero/Center.lean

Proof steps:
state_before: M₀ : Type u_1
G₀ : Type u_2
inst✝ : GroupWithZero G₀
s : Set G₀
a b : G₀
⊢ center G₀ˣ ⊆ Units.val ⁻¹' center G₀
state_after: M₀ : Type u_1
G₀ : Type u_2
inst✝ : GroupWithZero G₀
s : Set G₀
a b : G₀
⊢ ∀ (x : G₀ˣ), (∀ (g : G₀ˣ), g * x = x * g) → ∀ (g : G₀), g * ↑x = ↑x * g
tactic: simp_rw [subset_def, mem_preimage, _root_.Semigroup.mem_center_iff]
state_before: M₀ : Type u_1
G₀ : Type u_2
inst✝ : GroupWithZero G₀
s : Set G₀
a b : G₀
⊢ ∀ (x : G₀ˣ), (∀ (g : G₀ˣ), g * x = x * g) → ∀ (g : G₀), g * ↑x = ↑x * g
state_after: M₀ : Type u_1
G₀ : Type u_2
inst✝ : GroupWithZero G₀
s : Set G₀
a✝ b : G₀
u : G₀ˣ
hu : ∀ (g : G₀ˣ), g * u = u * g
a : G₀
⊢ a * ↑u = ↑u * a
tactic: intro u hu a
state_before: M₀ : Type u_1
G₀ : Type u_2
inst✝ : GroupWithZero G₀
s : Set G₀
a✝ b : G₀
u : G₀ˣ
hu : ∀ (g : G₀ˣ), g * u = u * g
a : G₀
⊢ a * ↑u = ↑u * a
state_after: case inl
M₀ : Type u_1
G₀ : Type u_2
inst✝ : GroupWithZero G₀
s : Set G₀
a b : G₀
u : G₀ˣ
hu : ∀ (g : G₀ˣ), g * u = u * g
⊢ 0 * ↑u = ↑u * 0

case inr
M₀ : Type u_1
G₀ : Type u_2
inst✝ : GroupWithZero G₀
s : Set G₀
a✝ b : G₀
u : G₀ˣ
hu : ∀ (g : G₀ˣ), g * u = u * g
a : G₀
ha : a ≠ 0
⊢ a * ↑u = ↑u * a
tactic: obtain rfl | ha := eq_or_ne a 0
Theorem: Equiv.Perm.set_support_inv_eq
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
p q : Perm α
⊢ {x | p⁻¹ x ≠ x} = {x | p x ≠ x}
state_after: case h
α : Type u_1
p q : Perm α
x : α
⊢ x ∈ {x | p⁻¹ x ≠ x} ↔ x ∈ {x | p x ≠ x}
tactic: ext x
state_before: case h
α : Type u_1
p q : Perm α
x : α
⊢ x ∈ {x | p⁻¹ x ≠ x} ↔ x ∈ {x | p x ≠ x}
state_after: case h
α : Type u_1
p q : Perm α
x : α
⊢ ¬p⁻¹ x = x ↔ ¬p x = x
tactic: simp only [Set.mem_setOf_eq, Ne]
state_before: case h
α : Type u_1
p q : Perm α
x : α
⊢ ¬p⁻¹ x = x ↔ ¬p x = x
state_after: no goals
tactic: rw [inv_def, symm_apply_eq, eq_comm]
Theorem: CategoryTheory.ShortComplex.homologyMapIso_hom
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
e : S₁ ≅ S₂
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
⊢ homologyMap e.hom ≫ homologyMap e.inv = 𝟙 S₁.homology
state_after: no goals
tactic: rw [← homologyMap_comp, e.hom_inv_id, homologyMap_id]
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
e : S₁ ≅ S₂
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
⊢ homologyMap e.inv ≫ homologyMap e.hom = 𝟙 S₂.homology
state_after: no goals
tactic: rw [← homologyMap_comp, e.inv_hom_id, homologyMap_id]
Theorem: Finset.prod_eq_prod_iff_of_le
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✝ : OrderedCancelCommMonoid M
f✝ g✝ : ι → M
s t : Finset ι
f g : ι → M
h : ∀ i ∈ s, f i ≤ g i
⊢ ∏ i ∈ s, f i = ∏ i ∈ s, g i ↔ ∀ i ∈ s, f i = g i
state_after: no goals
tactic: classical
    revert h
    refine Finset.induction_on s (fun _ ↦ ⟨fun _ _ h ↦ False.elim (Finset.not_mem_empty _ h),
      fun _ ↦ rfl⟩) fun a s ha ih H ↦ ?_
    specialize ih fun i ↦ H i ∘ Finset.mem_insert_of_mem
    rw [Finset.prod_insert ha, Finset.prod_insert ha, Finset.forall_mem_insert, ← ih]
    exact
      mul_eq_mul_iff_eq_and_eq (H a (s.mem_insert_self a))
        (Finset.prod_le_prod' fun i ↦ H i ∘ Finset.mem_insert_of_mem)
Theorem: CategoryTheory.Sieve.pullback_inter
File: Mathlib/CategoryTheory/Sites/Sieves.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f✝ : Y ⟶ X
S✝ R✝ : Sieve X
f : Y ⟶ X
S R : Sieve X
⊢ pullback f (S ⊓ R) = pullback f S ⊓ pullback f R
state_after: no goals
tactic: simp [Sieve.ext_iff]
Theorem: LinearMap.pi_zero
File: Mathlib/LinearAlgebra/Pi.lean

Proof steps:
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₂
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
φ : ι → Type i
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
⊢ (pi fun i => 0) = 0
state_after: case h.h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₂
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
φ : ι → Type i
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
x✝¹ : M₂
x✝ : ι
⊢ (pi fun i => 0) x✝¹ x✝ = 0 x✝¹ x✝
tactic: ext
state_before: case h.h
R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
ι' : Type x'
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M₂
inst✝⁴ : Module R M₂
inst✝³ : AddCommMonoid M₃
inst✝² : Module R M₃
φ : ι → Type i
inst✝¹ : (i : ι) → AddCommMonoid (φ i)
inst✝ : (i : ι) → Module R (φ i)
x✝¹ : M₂
x✝ : ι
⊢ (pi fun i => 0) x✝¹ x✝ = 0 x✝¹ x✝
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.IsSetSemiring.sUnion_union_diffFinset₀_of_subset
File: Mathlib/MeasureTheory/SetSemiring.lean

Proof steps:
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
hI_ss : ∀ t ∈ I, t ⊆ s
inst✝ : DecidableEq (Set α)
⊢ ⋃₀ ↑(I ∪ hC.diffFinset₀ hs hI) = s
state_after: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
hI_ss : ∀ t ∈ I, t ⊆ s
inst✝ : DecidableEq (Set α)
⊢ ⋃₀ ↑(I ∪ hC.diffFinset₀ hs hI) = ⋃₀ ↑I ∪ ⋃₀ ↑(hC.diffFinset₀ hs hI)
tactic: conv_rhs => rw [← sUnion_union_sUnion_diffFinset₀_of_subset hC hs hI hI_ss]
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
hI_ss : ∀ t ∈ I, t ⊆ s
inst✝ : DecidableEq (Set α)
⊢ ⋃₀ ↑(I ∪ hC.diffFinset₀ hs hI) = ⋃₀ ↑I ∪ ⋃₀ ↑(hC.diffFinset₀ hs hI)
state_after: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
hI_ss : ∀ t ∈ I, t ⊆ s
inst✝ : DecidableEq (Set α)
⊢ ⋃₀ (↑I ∪ ↑(hC.diffFinset₀ hs hI)) = ⋃₀ ↑I ∪ ⋃₀ ↑(hC.diffFinset₀ hs hI)
tactic: simp_rw [coe_union]
state_before: α : Type u_1
C : Set (Set α)
s t : Set α
I : Finset (Set α)
hC : IsSetSemiring C
hs : s ∈ C
hI : ↑I ⊆ C
hI_ss : ∀ t ∈ I, t ⊆ s
inst✝ : DecidableEq (Set α)
⊢ ⋃₀ (↑I ∪ ↑(hC.diffFinset₀ hs hI)) = ⋃₀ ↑I ∪ ⋃₀ ↑(hC.diffFinset₀ hs hI)
state_after: no goals
tactic: rw [sUnion_union]
Theorem: ZMod.val_mul_of_lt
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n✝ n : ℕ
a b : ZMod n
h : a.val * b.val < n
⊢ (a * b).val = a.val * b.val
state_after: m n✝ n : ℕ
a b : ZMod n
h : a.val * b.val < n
⊢ a.val * b.val % n = a.val * b.val
tactic: rw [val_mul]
state_before: m n✝ n : ℕ
a b : ZMod n
h : a.val * b.val < n
⊢ a.val * b.val % n = a.val * b.val
state_after: no goals
tactic: apply Nat.mod_eq_of_lt h
Theorem: WittVector.mul_coeff_zero
File: Mathlib/RingTheory/WittVector/Defs.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
x y : 𝕎 R
⊢ (x * y).coeff 0 = x.coeff 0 * y.coeff 0
state_after: no goals
tactic: simp [mul_coeff, peval]
Theorem: MvPolynomial.X_pow_eq_monomial
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S₁
p q : MvPolynomial σ R
⊢ X n ^ e = (monomial (Finsupp.single n e)) 1
state_after: no goals
tactic: simp [X, monomial_pow]
Theorem: disjoint_compl_compl_left_iff
File: Mathlib/Order/Heyting/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : HeytingAlgebra α
a b c : α
⊢ Disjoint aᶜᶜ b ↔ Disjoint a b
state_after: no goals
tactic: simp_rw [← le_compl_iff_disjoint_left, compl_compl_compl]
Theorem: starL'_apply
File: Mathlib/Topology/Algebra/Module/Star.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
inst✝⁸ : CommSemiring R
inst✝⁷ : StarRing R
inst✝⁶ : TrivialStar R
inst✝⁵ : AddCommMonoid A
inst✝⁴ : StarAddMonoid A
inst✝³ : Module R A
inst✝² : StarModule R A
inst✝¹ : TopologicalSpace A
inst✝ : ContinuousStar A
r : R
a : A
⊢ { toFun := __src✝.toFun, map_add' := ⋯ }.toFun (r • a) =
    (starRingEnd R) r • { toFun := __src✝.toFun, map_add' := ⋯ }.toFun a
state_after: no goals
tactic: simp [starRingEnd_apply]
Theorem: Rat.cast_nonpos
File: Mathlib/Data/Rat/Cast/Order.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
p q : ℚ
K : Type u_5
inst✝ : LinearOrderedField K
⊢ ↑q ≤ 0 ↔ q ≤ 0
state_after: no goals
tactic: norm_cast
Theorem: Submodule.exists_add_mem_mem_orthogonal
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
v : E
⊢ v = ↑((orthogonalProjection K) v) + (v - ↑((orthogonalProjection K) v))
state_after: no goals
tactic: simp
Theorem: ENNReal.tsum_biUnion_le_tsum
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∞
f✝ g : α → ℝ≥0∞
ι : Type u_4
f : α → ℝ≥0∞
s : Set ι
t : ι → Set α
⊢ ⋃ i ∈ s, t i = ⋃ i, t ↑i
state_after: no goals
tactic: simp
Theorem: HomologicalComplex.restriction_X
File: Mathlib/Algebra/Homology/Embedding/Restriction.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
C : Type u_3
inst✝³ : Category.{?u.313, u_3} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroObject C
K L M : HomologicalComplex C c'
φ : K ⟶ L
φ' : L ⟶ M
e : c.Embedding c'
inst✝ : e.IsRelIff
i j : ι
hij : ¬c.Rel i j
⊢ ¬c'.Rel (e.f i) (e.f j)
state_after: no goals
tactic: simpa only [← e.rel_iff] using hij
Theorem: Int.testBit_lor
File: Mathlib/Data/Int/Bitwise.lean

Proof steps:
state_before: m n : ℤ
k : ℕ
⊢ (m.lor n).testBit k = (m.testBit k || n.testBit k)
state_after: no goals
tactic: rw [← bitwise_or, testBit_bitwise]
Theorem: Nat.ascFactorial_le_pow_add
File: Mathlib/Data/Nat/Factorial/Basic.lean

Proof steps:
state_before: n : ℕ
⊢ (n + 1).ascFactorial 0 ≤ (n + 0) ^ 0
state_after: no goals
tactic: rw [ascFactorial_zero, Nat.pow_zero]
state_before: n k : ℕ
⊢ (n + 1).ascFactorial (k + 1) ≤ (n + (k + 1)) ^ (k + 1)
state_after: n k : ℕ
⊢ (n + 1).ascFactorial k * (n + k + 1) ≤ (n + k + 1) ^ k * (n + k + 1)
tactic: rw [ascFactorial_succ, Nat.pow_succ, Nat.mul_comm, ← Nat.add_assoc, Nat.add_right_comm n 1 k]
state_before: n k : ℕ
⊢ (n + 1).ascFactorial k * (n + k + 1) ≤ (n + k + 1) ^ k * (n + k + 1)
state_after: no goals
tactic: exact Nat.mul_le_mul_right _
      (Nat.le_trans (ascFactorial_le_pow_add _ k) (Nat.pow_le_pow_left (le_succ _) _))
Theorem: IsAddUnit.sub_add_cancel
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
M : Type u_1
N : Type u_2
inst✝ : DivisionMonoid α
a✝ b c : α
h : IsUnit b
a : α
⊢ a / b * b = a
state_after: no goals
tactic: rw [div_eq_mul_inv, h.inv_mul_cancel_right]
Theorem: CategoryTheory.GradedObject.eqToHom_proj
File: Mathlib/CategoryTheory/GradedObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
I : Type u_1
x x' : GradedObject I C
h : x = x'
i : I
⊢ eqToHom h i = eqToHom ⋯
state_after: C : Type u
inst✝ : Category.{v, u} C
I : Type u_1
x : GradedObject I C
i : I
⊢ eqToHom ⋯ i = eqToHom ⋯
tactic: subst h
state_before: C : Type u
inst✝ : Category.{v, u} C
I : Type u_1
x : GradedObject I C
i : I
⊢ eqToHom ⋯ i = eqToHom ⋯
state_after: no goals
tactic: rfl