ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: DirectSum.mulHom_of_of
File: Mathlib/Algebra/DirectSum/Ring.lean

Proof steps:
state_before: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : Add ι
inst✝¹ : (i : ι) → AddCommMonoid (A i)
inst✝ : GNonUnitalNonAssocSemiring A
i j : ι
a : A i
b : A j
⊢ ((mulHom A) ((of A i) a)) ((of A j) b) = (of A (i + j)) (GradedMonoid.GMul.mul a b)
state_after: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : Add ι
inst✝¹ : (i : ι) → AddCommMonoid (A i)
inst✝ : GNonUnitalNonAssocSemiring A
i j : ι
a : A i
b : A j
⊢ ((toAddMonoid fun x => (toAddMonoid fun x_1 => ((compHom (of A (x + x_1))).comp (gMulHom A)).flip).flip) ((of A i) a))
      ((of A j) b) =
    (of A (i + j)) (GradedMonoid.GMul.mul a b)
tactic: unfold mulHom
state_before: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : Add ι
inst✝¹ : (i : ι) → AddCommMonoid (A i)
inst✝ : GNonUnitalNonAssocSemiring A
i j : ι
a : A i
b : A j
⊢ ((toAddMonoid fun x => (toAddMonoid fun x_1 => ((compHom (of A (x + x_1))).comp (gMulHom A)).flip).flip) ((of A i) a))
      ((of A j) b) =
    (of A (i + j)) (GradedMonoid.GMul.mul a b)
state_after: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : Add ι
inst✝¹ : (i : ι) → AddCommMonoid (A i)
inst✝ : GNonUnitalNonAssocSemiring A
i j : ι
a : A i
b : A j
⊢ ((compHom (of A (i + j))) ((gMulHom A) a)) b = (of A (i + j)) (GradedMonoid.GMul.mul a b)
tactic: simp only [toAddMonoid_of, flip_apply, coe_comp, Function.comp_apply]
state_before: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : Add ι
inst✝¹ : (i : ι) → AddCommMonoid (A i)
inst✝ : GNonUnitalNonAssocSemiring A
i j : ι
a : A i
b : A j
⊢ ((compHom (of A (i + j))) ((gMulHom A) a)) b = (of A (i + j)) (GradedMonoid.GMul.mul a b)
state_after: no goals
tactic: rfl
Theorem: Set.exists_mem_insert
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a✝ b : α
s✝ s₁ s₂ t t₁ t₂ u : Set α
P : α → Prop
a : α
s : Set α
⊢ (∃ x ∈ insert a s, P x) ↔ P a ∨ ∃ x ∈ s, P x
state_after: no goals
tactic: simp [mem_insert_iff, or_and_right, exists_and_left, exists_or]
Theorem: monotoneOn_dual_iff
File: Mathlib/Order/Monotone/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α → β
s : Set α
⊢ MonotoneOn (⇑toDual ∘ f ∘ ⇑ofDual) s ↔ MonotoneOn f s
state_after: no goals
tactic: rw [monotoneOn_toDual_comp_iff, antitoneOn_comp_ofDual_iff]
Theorem: WeierstrassCurve.Jacobian.addXYZ_self
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
hP : W'.Equation P
⊢ W'.addXYZ P P = ![0, 0, 0]
state_after: no goals
tactic: rw [addXYZ, addX_self hP, addY_self hP, addZ_self]
Theorem: WeierstrassCurve.Jacobian.map_dblZ
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝² : CommRing R
W' : Jacobian R
F : Type v
inst✝¹ : Field F
W : Jacobian F
S : Type u_1
inst✝ : CommRing S
f : R →+* S
P Q : Fin 3 → R
⊢ dblZ (map W' f) (⇑f ∘ P) = f (W'.dblZ P)
state_after: no goals
tactic: simp [dblZ]
Theorem: CategoryTheory.Limits.Fork.ofι_π_app
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y : C
f g : X✝ ⟶ Y
P : C
ι : P ⟶ X✝
w : ι ≫ f = ι ≫ g
X : WalkingParallelPair
⊢ ((Functor.const WalkingParallelPair).obj P).obj X ⟶ (parallelPair f g).obj X
state_after: case zero
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
P : C
ι : P ⟶ X
w : ι ≫ f = ι ≫ g
⊢ ((Functor.const WalkingParallelPair).obj P).obj zero ⟶ (parallelPair f g).obj zero

case one
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
P : C
ι : P ⟶ X
w : ι ≫ f = ι ≫ g
⊢ ((Functor.const WalkingParallelPair).obj P).obj one ⟶ (parallelPair f g).obj one
tactic: cases X
state_before: C : Type u
inst✝ : Category.{v, u} C
X✝ Y✝ : C
f✝ g : X✝ ⟶ Y✝
P : C
ι : P ⟶ X✝
w : ι ≫ f✝ = ι ≫ g
X Y : WalkingParallelPair
f : X ⟶ Y
⊢ ((Functor.const WalkingParallelPair).obj P).map f ≫
      (fun X =>
          WalkingParallelPair.casesOn (motive := fun t =>
            X = t → (((Functor.const WalkingParallelPair).obj P).obj X ⟶ (parallelPair f✝ g).obj X)) X (fun h => ⋯ ▸ ι)
            (fun h => ⋯ ▸ ι ≫ f✝) ⋯)
        Y =
    (fun X =>
          WalkingParallelPair.casesOn (motive := fun t =>
            X = t → (((Functor.const WalkingParallelPair).obj P).obj X ⟶ (parallelPair f✝ g).obj X)) X (fun h => ⋯ ▸ ι)
            (fun h => ⋯ ▸ ι ≫ f✝) ⋯)
        X ≫
      (parallelPair f✝ g).map f
state_after: case zero.one.right
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
P : C
ι : P ⟶ X
w : ι ≫ f = ι ≫ g
⊢ ι ≫ f = ι ≫ g
tactic: cases X <;> cases Y <;> cases f <;> dsimp <;> simp
state_before: case zero.one.right
C : Type u
inst✝ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
P : C
ι : P ⟶ X
w : ι ≫ f = ι ≫ g
⊢ ι ≫ f = ι ≫ g
state_after: no goals
tactic: assumption
Theorem: IsometryEquiv.dimH_univ
File: Mathlib/Topology/MetricSpace/HausdorffDimension.lean

Proof steps:
state_before: ι : Type u_1
X : Type u_2
Y : Type u_3
inst✝¹ : EMetricSpace X
inst✝ : EMetricSpace Y
C K r : ℝ≥0
f : X → Y
s t : Set X
e : X ≃ᵢ Y
⊢ dimH univ = dimH univ
state_after: no goals
tactic: rw [← e.dimH_preimage univ, preimage_univ]
Theorem: Multiset.sum_map_mul_left
File: Mathlib/Algebra/BigOperators/Ring/Multiset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : NonUnitalNonAssocSemiring α
a : α
s : Multiset ι
f : ι → α
⊢ (map (fun i => a * f i) 0).sum = a * (map f 0).sum
state_after: no goals
tactic: simp
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : NonUnitalNonAssocSemiring α
a : α
s✝ : Multiset ι
f : ι → α
i : ι
s : Multiset ι
ih : (map (fun i => a * f i) s).sum = a * (map f s).sum
⊢ (map (fun i => a * f i) (i ::ₘ s)).sum = a * (map f (i ::ₘ s)).sum
state_after: no goals
tactic: simp [ih, mul_add]
Theorem: Matrix.invOf_eq_nonsing_inv
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

Proof steps:
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing α
A B : Matrix n n α
inst✝ : Invertible A
⊢ ⅟A = A⁻¹
state_after: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing α
A B : Matrix n n α
inst✝ : Invertible A
this : Invertible A.det := A.detInvertibleOfInvertible
⊢ ⅟A = A⁻¹
tactic: letI := detInvertibleOfInvertible A
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : CommRing α
A B : Matrix n n α
inst✝ : Invertible A
this : Invertible A.det := A.detInvertibleOfInvertible
⊢ ⅟A = A⁻¹
state_after: no goals
tactic: rw [inv_def, Ring.inverse_invertible, invOf_eq]
Theorem: ascPochhammer_zero_eval_zero
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

Proof steps:
state_before: S : Type u
inst✝ : Semiring S
⊢ eval 0 (ascPochhammer S 0) = 1
state_after: no goals
tactic: simp
Theorem: Commute.inv_add_inv
File: Mathlib/Algebra/Field/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
K : Type u_3
inst✝ : DivisionSemiring α
a b c d : α
hab : Commute a b
ha : a ≠ 0
hb : b ≠ 0
⊢ a⁻¹ + b⁻¹ = (a + b) / (a * b)
state_after: no goals
tactic: rw [inv_eq_one_div, inv_eq_one_div, hab.one_div_add_one_div ha hb]
Theorem: Urysohns.CU.approx_le_one
File: Mathlib/Topology/UrysohnsLemma.lean

Proof steps:
state_before: X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
c : CU P
n : ℕ
x : X
⊢ approx n c x ≤ 1
state_after: case zero
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
x : X
c : CU P
⊢ approx 0 c x ≤ 1

case succ
X : Type u_1
inst✝ : TopologicalSpace X
P : Set X → Prop
x : X
n : ℕ
ihn : ∀ (c : CU P), approx n c x ≤ 1
c : CU P
⊢ approx (n + 1) c x ≤ 1
tactic: induction' n with n ihn generalizing c
Theorem: MonotoneOn.mapsTo_uIcc
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Lattice β
f : α → β
s : Set α
a b : α
hf : MonotoneOn f [[a, b]]
⊢ MapsTo f [[a, b]] [[f a, f b]]
state_after: no goals
tactic: rw [uIcc, uIcc, ← hf.map_sup, ← hf.map_inf] <;>
    apply_rules [left_mem_uIcc, right_mem_uIcc, hf.mapsTo_Icc]
Theorem: CategoryTheory.regularTopology.mem_sieves_iff_hasEffectiveEpi
File: Mathlib/CategoryTheory/Sites/Coherent/RegularTopology.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preregular C
X : C
S : Sieve X
⊢ S ∈ (regularTopology C).sieves X ↔ ∃ Y π, EffectiveEpi π ∧ S.arrows π
state_after: case mp
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preregular C
X : C
S : Sieve X
⊢ S ∈ (regularTopology C).sieves X → ∃ Y π, EffectiveEpi π ∧ S.arrows π

case mpr
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preregular C
X : C
S : Sieve X
⊢ (∃ Y π, EffectiveEpi π ∧ S.arrows π) → S ∈ (regularTopology C).sieves X
tactic: constructor
Theorem: Finset.image₂_right_identity
File: Mathlib/Data/Finset/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f✝ f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b✝ b' : β
c : γ
f : γ → β → γ
b : β
h : ∀ (a : γ), f a b = a
s : Finset γ
⊢ image₂ f s {b} = s
state_after: no goals
tactic: rw [image₂_singleton_right, funext h, image_id']
Theorem: Basis.dvd_coord_smul
File: Mathlib/LinearAlgebra/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i✝ : ι
c : R
x : M
i : ι
m : M
r : R
⊢ (b.coord i) (r • m) = r * (b.coord i) m
state_after: no goals
tactic: simp
Theorem: Cardinal.power_nat_le_max
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: c : Cardinal.{u}
n : ℕ
⊢ c ^ ↑n ≤ max c ℵ₀
state_after: case inl
c : Cardinal.{u}
n : ℕ
hc : ℵ₀ ≤ c
⊢ c ^ ↑n ≤ max c ℵ₀

case inr
c : Cardinal.{u}
n : ℕ
hc : c < ℵ₀
⊢ c ^ ↑n ≤ max c ℵ₀
tactic: rcases le_or_lt ℵ₀ c with hc | hc
Theorem: CategoryTheory.Sheaf.isLocallyInjective_sheafToPresheaf_map_iff
File: Mathlib/CategoryTheory/Sites/LocallyInjective.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : ConcreteCategory D
J : GrothendieckTopology C
F₁ F₂ : Sheaf J D
φ : F₁ ⟶ F₂
⊢ Presheaf.IsLocallyInjective J ((sheafToPresheaf J D).map φ) ↔ IsLocallyInjective φ
state_after: no goals
tactic: rfl
Theorem: Nat.nat_repr_len_aux
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n✝ n b e : ℕ
h_b_pos : 0 < b
⊢ n < b ^ e.succ → n / b < b ^ e
state_after: n✝ n b e : ℕ
h_b_pos : 0 < b
⊢ n < b ^ e * b → n / b < b ^ e
tactic: simp only [Nat.pow_succ]
state_before: n✝ n b e : ℕ
h_b_pos : 0 < b
⊢ n < b ^ e * b → n / b < b ^ e
state_after: no goals
tactic: exact (@Nat.div_lt_iff_lt_mul b n (b ^ e) h_b_pos).mpr
Theorem: PowerSeries.coeff_coe
File: Mathlib/RingTheory/LaurentSeries.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
inst✝¹ : Semiring R
inst✝ : Ring R'
f g : R⟦X⟧
f' g' : R'⟦X⟧
i : ℤ
⊢ ((ofPowerSeries ℤ R) f).coeff i = if i < 0 then 0 else (coeff R i.natAbs) f
state_after: case ofNat
R : Type u_1
R' : Type u_2
inst✝¹ : Semiring R
inst✝ : Ring R'
f g : R⟦X⟧
f' g' : R'⟦X⟧
a✝ : ℕ
⊢ ((ofPowerSeries ℤ R) f).coeff (Int.ofNat a✝) = if Int.ofNat a✝ < 0 then 0 else (coeff R (Int.ofNat a✝).natAbs) f

case negSucc
R : Type u_1
R' : Type u_2
inst✝¹ : Semiring R
inst✝ : Ring R'
f g : R⟦X⟧
f' g' : R'⟦X⟧
a✝ : ℕ
⊢ ((ofPowerSeries ℤ R) f).coeff (Int.negSucc a✝) = if Int.negSucc a✝ < 0 then 0 else (coeff R (Int.negSucc a✝).natAbs) f
tactic: cases i
Theorem: List.get_insertNth_add_succ
File: Mathlib/Data/List/InsertNth.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
l : List α
x : α
n k : ℕ
hk' : n + k < l.length
⊢ n + k + 1 < (insertNth n x l).length
state_after: no goals
tactic: rwa [length_insertNth _ _ (by omega), Nat.succ_lt_succ_iff]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a : α
l : List α
x : α
n k : ℕ
hk' : n + k < l.length
hk : optParam (n + k + 1 < (insertNth n x l).length) ⋯
⊢ (insertNth n x l).get ⟨n + k + 1, hk⟩ = l.get ⟨n + k, hk'⟩
state_after: no goals
tactic: simp [getElem_insertNth_add_succ, hk, hk']
Theorem: MeasureTheory.trim_add
File: Mathlib/MeasureTheory/Measure/Trim.lean

Proof steps:
state_before: α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
s✝ : Set α
ν : Measure α
hm : m ≤ m0
s : Set α
hs : MeasurableSet s
⊢ ((μ + ν).trim hm) s = (μ.trim hm + ν.trim hm) s
state_after: no goals
tactic: simp [trim_measurableSet_eq hm hs]
Theorem: BooleanRing.le_sup_inf
File: Mathlib/Algebra/Ring/BooleanRing.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b c : α
⊢ (a + b + a * b) * (a + c + a * c) + (a + b * c + a * (b * c)) +
      (a + b + a * b) * (a + c + a * c) * (a + b * c + a * (b * c)) =
    a + b * c + a * (b * c)
state_after: no goals
tactic: rw [le_sup_inf_aux, add_self, mul_self, zero_add]
Theorem: MeasureTheory.Lp.indicatorConstLp_compMeasurePreserving
File: Mathlib/MeasureTheory/Function/LpSpace.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
β : Type u_5
inst✝ : MeasurableSpace β
μb : Measure β
f : α → β
s : Set β
hs : MeasurableSet s
hμs : μb s ≠ ⊤
c : E
hf : MeasurePreserving f μ μb
⊢ μ (f ⁻¹' s) ≠ ⊤
state_after: no goals
tactic: rwa [hf.measure_preimage hs.nullMeasurableSet]
Theorem: Real.surjOn_tan
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

Proof steps:
state_before: this : -(π / 2) < π / 2
⊢ Tendsto (fun x => tan ↑x) atBot atBot
state_after: this : -(π / 2) < π / 2
⊢ Tendsto tan (𝓝[>] (-(π / 2))) atBot
tactic: rw [tendsto_comp_coe_Ioo_atBot this]
state_before: this : -(π / 2) < π / 2
⊢ Tendsto tan (𝓝[>] (-(π / 2))) atBot
state_after: no goals
tactic: exact tendsto_tan_neg_pi_div_two
state_before: this : -(π / 2) < π / 2
⊢ Tendsto (fun x => tan ↑x) atTop atTop
state_after: this : -(π / 2) < π / 2
⊢ Tendsto tan (𝓝[<] (π / 2)) atTop
tactic: rw [tendsto_comp_coe_Ioo_atTop this]
state_before: this : -(π / 2) < π / 2
⊢ Tendsto tan (𝓝[<] (π / 2)) atTop
state_after: no goals
tactic: exact tendsto_tan_pi_div_two
Theorem: finsum_curry
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
f : α × β → M
hf : (mulSupport f).Finite
⊢ ∏ᶠ (ab : α × β), f ab = ∏ᶠ (a : α) (b : β), f (a, b)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
f : α × β → M
hf : (mulSupport f).Finite
h₁ : ∀ (a : α × β), ∏ᶠ (_ : a ∈ hf.toFinset), f a = f a
⊢ ∏ᶠ (ab : α × β), f ab = ∏ᶠ (a : α) (b : β), f (a, b)
tactic: have h₁ : ∀ a, ∏ᶠ _ : a ∈ hf.toFinset, f a = f a := by simp
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
f : α × β → M
hf : (mulSupport f).Finite
h₁ : ∀ (a : α × β), ∏ᶠ (_ : a ∈ hf.toFinset), f a = f a
⊢ ∏ᶠ (ab : α × β), f ab = ∏ᶠ (a : α) (b : β), f (a, b)
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
f : α × β → M
hf : (mulSupport f).Finite
h₁ : ∀ (a : α × β), ∏ᶠ (_ : a ∈ hf.toFinset), f a = f a
h₂ : ∏ᶠ (a : α × β), f a = ∏ᶠ (a : α × β) (_ : a ∈ hf.toFinset), f a
⊢ ∏ᶠ (ab : α × β), f ab = ∏ᶠ (a : α) (b : β), f (a, b)
tactic: have h₂ : ∏ᶠ a, f a = ∏ᶠ (a) (_ : a ∈ hf.toFinset), f a := by simp
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f✝ g : α → M
a b : α
s t : Set α
f : α × β → M
hf : (mulSupport f).Finite
h₁ : ∀ (a : α × β), ∏ᶠ (_ : a ∈ hf.toFinset), f a = f a
h₂ : ∏ᶠ (a : α × β), f a = ∏ᶠ (a : α × β) (_ : a ∈ hf.toFinset), f a
⊢ ∏ᶠ (ab : α × β), f ab = ∏ᶠ (a : α) (b : β), f (a, b)
state_after: no goals
tactic: simp_rw [h₂, finprod_mem_finset_product, h₁]
Theorem: Fintype.sum_extend_by_zero
File: Mathlib/Data/Fintype/BigOperators.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
inst✝ : CommMonoid α
s : Finset ι
f : ι → α
⊢ (∏ i : ι, if i ∈ s then f i else 1) = ∏ i ∈ s, f i
state_after: no goals
tactic: rw [← prod_filter, filter_mem_eq_inter, univ_inter]
Theorem: Nat.sub_add_sub_cancel
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hab : b ≤ a
hcb : c ≤ b
⊢ a - b + (b - c) = a - c
state_after: no goals
tactic: omega
Theorem: IsHomeomorphicTrivialFiberBundle.continuous_proj
File: Mathlib/Topology/FiberBundle/IsHomeomorphicTrivialBundle.lean

Proof steps:
state_before: B : Type u_1
F : Type u_2
Z : Type u_3
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : TopologicalSpace Z
proj : Z → B
h : IsHomeomorphicTrivialFiberBundle F proj
⊢ Continuous proj
state_after: case intro
B : Type u_1
F : Type u_2
Z : Type u_3
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : TopologicalSpace Z
e : Z ≃ₜ B × F
h : IsHomeomorphicTrivialFiberBundle F (Prod.fst ∘ ⇑e)
⊢ Continuous (Prod.fst ∘ ⇑e)
tactic: obtain ⟨e, rfl⟩ := h.proj_eq
state_before: case intro
B : Type u_1
F : Type u_2
Z : Type u_3
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
inst✝ : TopologicalSpace Z
e : Z ≃ₜ B × F
h : IsHomeomorphicTrivialFiberBundle F (Prod.fst ∘ ⇑e)
⊢ Continuous (Prod.fst ∘ ⇑e)
state_after: no goals
tactic: exact continuous_fst.comp e.continuous
Theorem: MeasureTheory.FiniteMeasure.restrict_eq_zero_iff
File: Mathlib/MeasureTheory/Measure/FiniteMeasure.lean

Proof steps:
state_before: Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
R : Type u_2
inst✝³ : SMul R ℝ≥0
inst✝² : SMul R ℝ≥0∞
inst✝¹ : IsScalarTower R ℝ≥0 ℝ≥0∞
inst✝ : IsScalarTower R ℝ≥0∞ ℝ≥0∞
μ : FiniteMeasure Ω
A : Set Ω
⊢ μ.restrict A = 0 ↔ μ A = 0
state_after: no goals
tactic: rw [← mass_zero_iff, restrict_mass]
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 α
inst✝ : MeasurableSingletonClass α
hs' : s.Nonempty
⊢ count s ≠ 0
state_after: α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
s : Set α
inst✝ : MeasurableSingletonClass α
hs' : s.Nonempty
⊢ ¬s = ∅
tactic: rw [Ne, count_eq_zero_iff]
state_before: α : Type u_1
β : Type u_2
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSpace β
s : Set α
inst✝ : MeasurableSingletonClass α
hs' : s.Nonempty
⊢ ¬s = ∅
state_after: no goals
tactic: exact hs'.ne_empty
Theorem: IsRightRegular.mul_right_eq_zero_iff
File: Mathlib/Algebra/Regular/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : MulZeroClass R
a b : R
hb : IsRightRegular b
⊢ a * b = 0 ↔ a = 0
state_after: R : Type u_1
inst✝ : MulZeroClass R
a b : R
hb : IsRightRegular b
⊢ a * b = 0 * b ↔ a = 0
tactic: nth_rw 1 [← zero_mul b]
state_before: R : Type u_1
inst✝ : MulZeroClass R
a b : R
hb : IsRightRegular b
⊢ a * b = 0 * b ↔ a = 0
state_after: no goals
tactic: exact ⟨fun h ↦ hb h, fun ha ↦ by rw [ha]⟩
Theorem: CategoryTheory.Pretriangulated.binaryProductTriangleIsoBinaryBiproductTriangle_inv_hom₂
File: Mathlib/CategoryTheory/Triangulated/Basic.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
X₁ X₂ : C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproduct X₁ X₂
⊢ (binaryProductTriangle X₁ X₂).mor₁ ≫ (biprod.isoProd X₁ X₂).symm.hom =
    (Iso.refl (binaryProductTriangle X₁ X₂).obj₁).hom ≫ (binaryBiproductTriangle X₁ X₂).mor₁
state_after: no goals
tactic: aesop_cat
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
X₁ X₂ : C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproduct X₁ X₂
⊢ (binaryProductTriangle X₁ X₂).mor₂ ≫ (Iso.refl (binaryProductTriangle X₁ X₂).obj₃).hom =
    (biprod.isoProd X₁ X₂).symm.hom ≫ (binaryBiproductTriangle X₁ X₂).mor₂
state_after: no goals
tactic: aesop_cat
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
X₁ X₂ : C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasBinaryBiproduct X₁ X₂
⊢ (binaryProductTriangle X₁ X₂).mor₃ ≫ (shiftFunctor C 1).map (Iso.refl (binaryProductTriangle X₁ X₂).obj₁).hom =
    (Iso.refl (binaryProductTriangle X₁ X₂).obj₃).hom ≫ (binaryBiproductTriangle X₁ X₂).mor₃
state_after: no goals
tactic: aesop_cat
Theorem: DirectSum.toAlgebra_apply
File: Mathlib/Algebra/DirectSum/Algebra.lean

Proof steps:
state_before: ι : Type uι
R : Type uR
A : ι → Type uA
B : Type uB
inst✝⁸ : DecidableEq ι
inst✝⁷ : CommSemiring R
inst✝⁶ : (i : ι) → AddCommMonoid (A i)
inst✝⁵ : (i : ι) → Module R (A i)
inst✝⁴ : AddMonoid ι
inst✝³ : GSemiring A
inst✝² : Semiring B
inst✝¹ : GAlgebra R A
inst✝ : Algebra R B
f : (i : ι) → A i →ₗ[R] B
hone : (f 0) GradedMonoid.GOne.one = 1
hmul : ∀ {i j : ι} (ai : A i) (aj : A j), (f (i + j)) (GradedMonoid.GMul.mul ai aj) = (f i) ai * (f j) aj
r : R
⊢ (↑↑{ toFun := ⇑(toSemiring (fun i => (f i).toAddMonoidHom) hone hmul), map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
              map_add' := ⋯ }).toFun
      ((algebraMap R (⨁ (i : ι), A i)) r) =
    (algebraMap R B) r
state_after: ι : Type uι
R : Type uR
A : ι → Type uA
B : Type uB
inst✝⁸ : DecidableEq ι
inst✝⁷ : CommSemiring R
inst✝⁶ : (i : ι) → AddCommMonoid (A i)
inst✝⁵ : (i : ι) → Module R (A i)
inst✝⁴ : AddMonoid ι
inst✝³ : GSemiring A
inst✝² : Semiring B
inst✝¹ : GAlgebra R A
inst✝ : Algebra R B
f : (i : ι) → A i →ₗ[R] B
hone : (f 0) GradedMonoid.GOne.one = 1
hmul : ∀ {i j : ι} (ai : A i) (aj : A j), (f (i + j)) (GradedMonoid.GMul.mul ai aj) = (f i) ai * (f j) aj
r : R
⊢ (toModule R ι B f) ((algebraMap R (⨁ (i : ι), A i)) r) = (algebraMap R B) r
tactic: show toModule R _ _ f (algebraMap R _ r) = _
state_before: ι : Type uι
R : Type uR
A : ι → Type uA
B : Type uB
inst✝⁸ : DecidableEq ι
inst✝⁷ : CommSemiring R
inst✝⁶ : (i : ι) → AddCommMonoid (A i)
inst✝⁵ : (i : ι) → Module R (A i)
inst✝⁴ : AddMonoid ι
inst✝³ : GSemiring A
inst✝² : Semiring B
inst✝¹ : GAlgebra R A
inst✝ : Algebra R B
f : (i : ι) → A i →ₗ[R] B
hone : (f 0) GradedMonoid.GOne.one = 1
hmul : ∀ {i j : ι} (ai : A i) (aj : A j), (f (i + j)) (GradedMonoid.GMul.mul ai aj) = (f i) ai * (f j) aj
r : R
⊢ (toModule R ι B f) ((algebraMap R (⨁ (i : ι), A i)) r) = (algebraMap R B) r
state_after: no goals
tactic: rw [Algebra.algebraMap_eq_smul_one, Algebra.algebraMap_eq_smul_one, map_smul, one_def,
        ← lof_eq_of R, toModule_lof, hone]