ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Over.ConstructProducts.conesEquivInverse_map_hom
File: Mathlib/CategoryTheory/Limits/Constructions/Over/Products.lean

Proof steps:
state_before: J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X B : C
J : Type w
F : Discrete J ⥤ Over B
X✝ Y✝ : Cone F
f : X✝ ⟶ Y✝
j : WidePullbackShape J
⊢ f.hom.left ≫ (conesEquivInverseObj B F Y✝).π.app j = (conesEquivInverseObj B F X✝).π.app j
state_after: case none
J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X B : C
J : Type w
F : Discrete J ⥤ Over B
X✝ Y✝ : Cone F
f : X✝ ⟶ Y✝
⊢ f.hom.left ≫ (conesEquivInverseObj B F Y✝).π.app none = (conesEquivInverseObj B F X✝).π.app none

case some
J✝ : Type w
C : Type u
inst✝ : Category.{v, u} C
X B : C
J : Type w
F : Discrete J ⥤ Over B
X✝ Y✝ : Cone F
f : X✝ ⟶ Y✝
j : J
⊢ f.hom.left ≫ (conesEquivInverseObj B F Y✝).π.app (some j) = (conesEquivInverseObj B F X✝).π.app (some j)
tactic: cases' j with j
Theorem: NNReal.le_iInf_mul
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: ι : Sort u_1
f : ι → ℝ≥0
inst✝ : Nonempty ι
a : ℝ≥0
g : ι → ℝ≥0
h : ℝ≥0
H : ∀ (i : ι), a ≤ g i * h
⊢ a ≤ iInf g * h
state_after: ι : Sort u_1
f : ι → ℝ≥0
inst✝ : Nonempty ι
a : ℝ≥0
g : ι → ℝ≥0
h : ℝ≥0
H : ∀ (i : ι), a ≤ g i * h
⊢ a ≤ ⨅ i, g i * h
tactic: rw [iInf_mul]
state_before: ι : Sort u_1
f : ι → ℝ≥0
inst✝ : Nonempty ι
a : ℝ≥0
g : ι → ℝ≥0
h : ℝ≥0
H : ∀ (i : ι), a ≤ g i * h
⊢ a ≤ ⨅ i, g i * h
state_after: no goals
tactic: exact le_ciInf H
Theorem: Lists.lt_sizeof_cons'
File: Mathlib/SetTheory/Lists.lean

Proof steps:
state_before: α : Type u_1
b : Bool
a : Lists' α b
l : Lists' α true
⊢ sizeOf ⟨b, a⟩ < sizeOf (a.cons' l)
state_after: α : Type u_1
b : Bool
a : Lists' α b
l : Lists' α true
⊢ 0 < sizeOf l
tactic: simp only [Sigma.mk.sizeOf_spec, Lists'.cons'.sizeOf_spec, lt_add_iff_pos_right]
state_before: α : Type u_1
b : Bool
a : Lists' α b
l : Lists' α true
⊢ 0 < sizeOf l
state_after: no goals
tactic: apply sizeof_pos
Theorem: Nat.ModEq.add_right_cancel
File: Mathlib/Data/Nat/ModEq.lean

Proof steps:
state_before: m n a b c d : ℕ
h₁ : c ≡ d [MOD n]
h₂ : a + c ≡ b + d [MOD n]
⊢ a ≡ b [MOD n]
state_after: m n a b c d : ℕ
h₁ : c ≡ d [MOD n]
h₂ : c + a ≡ d + b [MOD n]
⊢ a ≡ b [MOD n]
tactic: rw [add_comm a, add_comm b] at h₂
state_before: m n a b c d : ℕ
h₁ : c ≡ d [MOD n]
h₂ : c + a ≡ d + b [MOD n]
⊢ a ≡ b [MOD n]
state_after: no goals
tactic: exact h₁.add_left_cancel h₂
Theorem: CategoryTheory.Iso.commRingIsoToRingEquiv_symm_toRingHom
File: Mathlib/Algebra/Category/Ring/Basic.lean

Proof steps:
state_before: X Y : CommRingCat
i : X ≅ Y
⊢ i.commRingCatIsoToRingEquiv.symm.toRingHom = i.inv
state_after: case a
X Y : CommRingCat
i : X ≅ Y
x✝ : ↑Y
⊢ i.commRingCatIsoToRingEquiv.symm.toRingHom x✝ = i.inv x✝
tactic: ext
state_before: case a
X Y : CommRingCat
i : X ≅ Y
x✝ : ↑Y
⊢ i.commRingCatIsoToRingEquiv.symm.toRingHom x✝ = i.inv x✝
state_after: no goals
tactic: rfl
Theorem: uniformContinuous_addMonoidHom_of_continuous
File: Mathlib/Topology/Algebra/UniformGroup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁷ : UniformSpace α
inst✝⁶ : Group α
inst✝⁵ : UniformGroup α
hom : Type u_3
inst✝⁴ : UniformSpace β
inst✝³ : Group β
inst✝² : UniformGroup β
inst✝¹ : FunLike hom α β
inst✝ : MonoidHomClass hom α β
f : hom
h : Continuous ⇑f
this : Tendsto (⇑f) (𝓝 1) (𝓝 (f 1))
⊢ Tendsto (⇑f) (𝓝 1) (𝓝 1)
state_after: no goals
tactic: rwa [map_one] at this
Theorem: Ordinal.le_cof_iff_blsub
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

Proof steps:
state_before: α : Type u_1
r : α → α → Prop
b : Ordinal.{u}
a : Cardinal.{u}
H : ∀ {ι : Type u} (f : ι → Ordinal.{u}), lsub f = b → a ≤ #ι
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
hf : o.blsub f = b
⊢ a ≤ o.card
state_after: no goals
tactic: simpa using H _ hf
state_before: α : Type u_1
r : α → α → Prop
b : Ordinal.{u}
a : Cardinal.{u}
H : ∀ {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), o.blsub f = b → a ≤ o.card
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = b
⊢ a ≤ #ι
state_after: case intro.intro
α : Type u_1
r✝ : α → α → Prop
b : Ordinal.{u}
a : Cardinal.{u}
H : ∀ {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), o.blsub f = b → a ≤ o.card
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = b
r : ι → ι → Prop
hr : IsWellOrder ι r
hι' : (#ι).ord = type r
⊢ a ≤ #ι
tactic: rcases Cardinal.ord_eq ι with ⟨r, hr, hι'⟩
state_before: case intro.intro
α : Type u_1
r✝ : α → α → Prop
b : Ordinal.{u}
a : Cardinal.{u}
H : ∀ {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), o.blsub f = b → a ≤ o.card
ι : Type u
f : ι → Ordinal.{u}
hf : lsub f = b
r : ι → ι → Prop
hr : IsWellOrder ι r
hι' : (#ι).ord = type r
⊢ a ≤ #ι
state_after: case intro.intro
α : Type u_1
r✝ : α → α → Prop
b : Ordinal.{u}
a : Cardinal.{u}
H : ∀ {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), o.blsub f = b → a ≤ o.card
ι : Type u
f : ι → Ordinal.{u}
r : ι → ι → Prop
hr : IsWellOrder ι r
hf : (type r).blsub (bfamilyOfFamily' r f) = b
hι' : (#ι).ord = type r
⊢ a ≤ #ι
tactic: rw [← @blsub_eq_lsub' ι r hr] at hf
state_before: case intro.intro
α : Type u_1
r✝ : α → α → Prop
b : Ordinal.{u}
a : Cardinal.{u}
H : ∀ {o : Ordinal.{u}} (f : (a : Ordinal.{u}) → a < o → Ordinal.{u}), o.blsub f = b → a ≤ o.card
ι : Type u
f : ι → Ordinal.{u}
r : ι → ι → Prop
hr : IsWellOrder ι r
hf : (type r).blsub (bfamilyOfFamily' r f) = b
hι' : (#ι).ord = type r
⊢ a ≤ #ι
state_after: no goals
tactic: simpa using H _ hf
Theorem: Ideal.prod_eq_bot
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: R✝ : Type u
ι : Type u_1
inst✝² : CommSemiring R✝
I J K L : Ideal R✝
R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
s : Multiset (Ideal R)
⊢ s.prod = ⊥ ↔ ∃ I ∈ s, I = ⊥
state_after: no goals
tactic: simp
Theorem: CategoryTheory.ShortComplex.RightHomologyData.rightHomologyIso_hom_comp_ι
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.RightHomologyData
inst✝ : S.HasRightHomology
⊢ h.rightHomologyIso.hom ≫ h.ι = S.rightHomologyι ≫ h.opcyclesIso.hom
state_after: no goals
tactic: simp only [← cancel_mono h.opcyclesIso.inv, ← cancel_epi h.rightHomologyIso.inv,
    assoc, Iso.inv_hom_id_assoc, Iso.hom_inv_id, comp_id, rightHomologyIso_inv_comp_rightHomologyι]
Theorem: Sum.isLeft_eq_false
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
x : α ⊕ β
⊢ x.isLeft = false ↔ x.isRight = true
state_after: no goals
tactic: cases x <;> simp
Theorem: Filter.tendsto_const_mul_atTop_of_neg
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : LinearOrderedField α
l : Filter β
f : β → α
r : α
hr : r < 0
⊢ Tendsto (fun x => r * f x) l atTop ↔ Tendsto f l atBot
state_after: no goals
tactic: simpa only [neg_mul, tendsto_neg_atBot_iff] using tendsto_const_mul_atBot_of_pos (neg_pos.2 hr)
Theorem: BoxIntegral.Box.volume_apply
File: Mathlib/Analysis/BoxIntegral/Partition/Measure.lean

Proof steps:
state_before: ι : Type u_1
inst✝ : Fintype ι
I : Box ι
⊢ volume.toBoxAdditive I = ∏ i : ι, (I.upper i - I.lower i)
state_after: no goals
tactic: rw [Measure.toBoxAdditive_apply, coe_eq_pi, Real.volume_pi_Ioc_toReal I.lower_le_upper]
Theorem: Finset.sdiff_erase
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
h : a ∈ s
⊢ s \ t.erase a = insert a (s \ t)
state_after: no goals
tactic: rw [← sdiff_singleton_eq_erase, sdiff_sdiff_eq_sdiff_union (singleton_subset_iff.2 h), insert_eq,
    union_comm]
Theorem: EuclideanGeometry.oangle_rotate_sign
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
⊢ (∡ p₂ p₃ p₁).sign = (∡ p₁ p₂ p₃).sign
state_after: no goals
tactic: rw [← oangle_swap₁₂_sign, oangle_swap₁₃_sign]
Theorem: RingSeminorm.ne_zero_iff
File: Mathlib/Analysis/Normed/Ring/Seminorm.lean

Proof steps:
state_before: F : Type u_1
R : Type u_2
S : Type u_3
x y : R
r : ℝ
inst✝ : NonUnitalRing R
p : RingSeminorm R
⊢ p ≠ 0 ↔ ∃ x, p x ≠ 0
state_after: no goals
tactic: simp [eq_zero_iff]
Theorem: CategoryTheory.CosimplicialObject.Augmented.toArrow_obj_left
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ (𝟭 C).map (point.map η) ≫
      ((fun X => { left := point.obj X, right := (drop.obj X).obj [0], hom := X.hom.app [0] }) Y✝).hom =
    ((fun X => { left := point.obj X, right := (drop.obj X).obj [0], hom := X.hom.app [0] }) X✝).hom ≫
      (𝟭 C).map ((drop.map η).app [0])
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = X✝.hom.app [0] ≫ η.right.app [0]
tactic: dsimp
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = X✝.hom.app [0] ≫ η.right.app [0]
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = (X✝.hom ≫ η.right).app [0]
tactic: rw [← NatTrans.comp_app]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = (X✝.hom ≫ η.right).app [0]
state_after: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = ((const C).map η.left ≫ Y✝.hom).app [0]
tactic: erw [← η.w]
state_before: C : Type u
inst✝ : Category.{v, u} C
X : CosimplicialObject C
X✝ Y✝ : Augmented C
η : X✝ ⟶ Y✝
⊢ η.left ≫ Y✝.hom.app [0] = ((const C).map η.left ≫ Y✝.hom).app [0]
state_after: no goals
tactic: rfl
Theorem: Finset.vadd_univ
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : Group α
inst✝¹ : MulAction α β
s✝ t : Finset β
a : α
b : β
inst✝ : Fintype β
s : Finset α
hs : s.Nonempty
⊢ ↑(s • univ) = ↑univ
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : Group α
inst✝¹ : MulAction α β
s✝ t : Finset β
a : α
b : β
inst✝ : Fintype β
s : Finset α
hs : s.Nonempty
⊢ ↑s • Set.univ = Set.univ
tactic: push_cast
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : Group α
inst✝¹ : MulAction α β
s✝ t : Finset β
a : α
b : β
inst✝ : Fintype β
s : Finset α
hs : s.Nonempty
⊢ ↑s • Set.univ = Set.univ
state_after: no goals
tactic: exact Set.smul_univ hs
Theorem: SimpleGraph.TripartiteFromTriangles.Graph.in₁₂_iff'
File: Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
⊢ (graph t).Adj (in₁ b) (in₂ c) → ∃ x ∈ t, x.2.1 = b ∧ x.2.2 = c
state_after: case in₁₂
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
a✝¹ : α
a✝ : (a✝¹, b, c) ∈ t
⊢ ∃ x ∈ t, x.2.1 = b ∧ x.2.2 = c
tactic: rintro ⟨⟩
state_before: case in₁₂
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
a✝¹ : α
a✝ : (a✝¹, b, c) ∈ t
⊢ ∃ x ∈ t, x.2.1 = b ∧ x.2.2 = c
state_after: no goals
tactic: exact ⟨_, ‹_›, by simp⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a a' : α
b b' : β
c c' : γ
x : α × β × γ
ε : 𝕜
⊢ (∃ x ∈ t, x.2.1 = b ∧ x.2.2 = c) → (graph t).Adj (in₁ b) (in₂ c)
state_after: case intro.mk.mk.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a✝ a' : α
b' : β
c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ (graph t).Adj (in₁ (a, b, c).2.1) (in₂ (a, b, c).2.2)
tactic: rintro ⟨⟨a, b, c⟩, h, rfl, rfl⟩
state_before: case intro.mk.mk.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a✝ a' : α
b' : β
c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ (graph t).Adj (in₁ (a, b, c).2.1) (in₂ (a, b, c).2.2)
state_after: case intro.mk.mk.intro.intro.a
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a✝ a' : α
b' : β
c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ (?intro.mk.mk.intro.intro.a, (a, b, c).2.1, (a, b, c).2.2) ∈ t

case intro.mk.mk.intro.intro.a
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a✝ a' : α
b' : β
c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ α
tactic: constructor
state_before: case intro.mk.mk.intro.intro.a
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a✝ a' : α
b' : β
c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ (?intro.mk.mk.intro.intro.a, (a, b, c).2.1, (a, b, c).2.2) ∈ t

case intro.mk.mk.intro.intro.a
α : Type u_1
β : Type u_2
γ : Type u_3
𝕜 : Type u_4
inst✝ : LinearOrderedField 𝕜
t : Finset (α × β × γ)
a✝ a' : α
b' : β
c' : γ
x : α × β × γ
ε : 𝕜
a : α
b : β
c : γ
h : (a, b, c) ∈ t
⊢ α
state_after: no goals
tactic: assumption
Theorem: Multiset.untrop_sum
File: Mathlib/Algebra/Tropical/BigOperators.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : Multiset (Tropical R)
⊢ untrop s.sum = (map untrop s).inf
state_after: case empty
R : Type u_1
S : Type u_2
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
⊢ untrop (sum 0) = (map untrop 0).inf

case cons
R : Type u_1
S : Type u_2
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
s : Tropical R
x : Multiset (Tropical R)
IH : untrop x.sum = (map untrop x).inf
⊢ untrop (s ::ₘ x).sum = (map untrop (s ::ₘ x)).inf
tactic: induction' s using Multiset.induction with s x IH
Theorem: Finset.Ioc_diff_Ioo_self
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidableEq α
h : a < b
⊢ Ioc a b \ Ioo a b = {b}
state_after: no goals
tactic: simp [← coe_inj, h]
Theorem: NNReal.summable_nat_add_iff
File: Mathlib/Topology/Instances/NNReal.lean

Proof steps:
state_before: α : Type u_1
f : ℕ → ℝ≥0
k : ℕ
⊢ (Summable fun i => f (i + k)) ↔ Summable f
state_after: α : Type u_1
f : ℕ → ℝ≥0
k : ℕ
⊢ (Summable fun a => ↑(f (a + k))) ↔ Summable fun a => ↑(f a)
tactic: rw [← summable_coe, ← summable_coe]
state_before: α : Type u_1
f : ℕ → ℝ≥0
k : ℕ
⊢ (Summable fun a => ↑(f (a + k))) ↔ Summable fun a => ↑(f a)
state_after: no goals
tactic: exact @summable_nat_add_iff ℝ _ _ _ (fun i => (f i : ℝ)) k
Theorem: Finset.nsmul_piAntidiag_univ
File: Mathlib/Algebra/Order/Antidiag/Pi.lean

Proof steps:
state_before: ι : Type u_1
μ : Type u_2
μ' : Type u_3
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
m n : ℕ
hn : n ≠ 0
⊢ SMul.smul n (univ.piAntidiag m) = filter (fun f => ∀ (i : ι), n ∣ f i) (univ.piAntidiag (n * m))
state_after: ι : Type u_1
μ : Type u_2
μ' : Type u_3
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
m n : ℕ
hn : n ≠ 0
this : SMul.smul n (univ.piAntidiag m) = filter (fun f => ∀ i ∈ univ, n ∣ f i) (univ.piAntidiag (n * m))
⊢ SMul.smul n (univ.piAntidiag m) = filter (fun f => ∀ (i : ι), n ∣ f i) (univ.piAntidiag (n * m))
tactic: have := nsmul_piAntidiag (univ : Finset ι) m hn
state_before: ι : Type u_1
μ : Type u_2
μ' : Type u_3
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
m n : ℕ
hn : n ≠ 0
this : SMul.smul n (univ.piAntidiag m) = filter (fun f => ∀ i ∈ univ, n ∣ f i) (univ.piAntidiag (n * m))
⊢ SMul.smul n (univ.piAntidiag m) = filter (fun f => ∀ (i : ι), n ∣ f i) (univ.piAntidiag (n * m))
state_after: ι : Type u_1
μ : Type u_2
μ' : Type u_3
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
m n : ℕ
hn : n ≠ 0
this : SMul.smul n (univ.piAntidiag m) = filter (fun f => ∀ (i : ι), n ∣ f i) (univ.piAntidiag (n * m))
⊢ SMul.smul n (univ.piAntidiag m) = filter (fun f => ∀ (i : ι), n ∣ f i) (univ.piAntidiag (n * m))
tactic: simp at this
state_before: ι : Type u_1
μ : Type u_2
μ' : Type u_3
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
m n : ℕ
hn : n ≠ 0
this : SMul.smul n (univ.piAntidiag m) = filter (fun f => ∀ (i : ι), n ∣ f i) (univ.piAntidiag (n * m))
⊢ SMul.smul n (univ.piAntidiag m) = filter (fun f => ∀ (i : ι), n ∣ f i) (univ.piAntidiag (n * m))
state_after: no goals
tactic: convert this
Theorem: Complex.cos_conj
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ cos ((starRingEnd ℂ) x) = (starRingEnd ℂ) (cos x)
state_after: no goals
tactic: rw [← cosh_mul_I, ← conj_neg_I, ← RingHom.map_mul, ← cosh_mul_I, cosh_conj, mul_neg, cosh_neg]
Theorem: Subgroup.map_commutator
File: Mathlib/GroupTheory/Commutator.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
F : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : FunLike F G G'
inst✝ : MonoidHomClass F G G'
f✝ : F
g₁ g₂ g₃ g : G
H₁ H₂ H₃ K₁ K₂ : Subgroup G
f : G →* G'
⊢ map f ⁅H₁, H₂⁆ = ⁅map f H₁, map f H₂⁆
state_after: G : Type u_1
G' : Type u_2
F : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : FunLike F G G'
inst✝ : MonoidHomClass F G G'
f✝ : F
g₁ g₂ g₃ g : G
H₁ H₂ H₃ K₁ K₂ : Subgroup G
f : G →* G'
⊢ (∀ g₁ ∈ H₁, ∀ g₂ ∈ H₂, ⁅f g₁, f g₂⁆ ∈ ⁅map f H₁, map f H₂⁆) ∧
    ∀ g₁ ∈ map f H₁, ∀ g₂ ∈ map f H₂, ⁅g₁, g₂⁆ ∈ map f ⁅H₁, H₂⁆
tactic: simp_rw [le_antisymm_iff, map_le_iff_le_comap, commutator_le, mem_comap, map_commutatorElement]
state_before: G : Type u_1
G' : Type u_2
F : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : FunLike F G G'
inst✝ : MonoidHomClass F G G'
f✝ : F
g₁ g₂ g₃ g : G
H₁ H₂ H₃ K₁ K₂ : Subgroup G
f : G →* G'
⊢ (∀ g₁ ∈ H₁, ∀ g₂ ∈ H₂, ⁅f g₁, f g₂⁆ ∈ ⁅map f H₁, map f H₂⁆) ∧
    ∀ g₁ ∈ map f H₁, ∀ g₂ ∈ map f H₂, ⁅g₁, g₂⁆ ∈ map f ⁅H₁, H₂⁆
state_after: case left
G : Type u_1
G' : Type u_2
F : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : FunLike F G G'
inst✝ : MonoidHomClass F G G'
f✝ : F
g₁ g₂ g₃ g : G
H₁ H₂ H₃ K₁ K₂ : Subgroup G
f : G →* G'
⊢ ∀ g₁ ∈ H₁, ∀ g₂ ∈ H₂, ⁅f g₁, f g₂⁆ ∈ ⁅map f H₁, map f H₂⁆

case right
G : Type u_1
G' : Type u_2
F : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : FunLike F G G'
inst✝ : MonoidHomClass F G G'
f✝ : F
g₁ g₂ g₃ g : G
H₁ H₂ H₃ K₁ K₂ : Subgroup G
f : G →* G'
⊢ ∀ g₁ ∈ map f H₁, ∀ g₂ ∈ map f H₂, ⁅g₁, g₂⁆ ∈ map f ⁅H₁, H₂⁆
tactic: constructor
Theorem: ContinuousMap.periodic_tsum_comp_add_zsmul
File: Mathlib/Topology/ContinuousFunction/Algebra.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝⁶ : TopologicalSpace X
inst✝⁵ : TopologicalSpace Y
inst✝⁴ : AddCommGroup X
inst✝³ : TopologicalAddGroup X
inst✝² : AddCommMonoid Y
inst✝¹ : ContinuousAdd Y
inst✝ : T2Space Y
f : C(X, Y)
p : X
⊢ Function.Periodic (⇑(∑' (n : ℤ), f.comp (ContinuousMap.addRight (n • p)))) p
state_after: X : Type u_1
Y : Type u_2
inst✝⁶ : TopologicalSpace X
inst✝⁵ : TopologicalSpace Y
inst✝⁴ : AddCommGroup X
inst✝³ : TopologicalAddGroup X
inst✝² : AddCommMonoid Y
inst✝¹ : ContinuousAdd Y
inst✝ : T2Space Y
f : C(X, Y)
p x : X
⊢ (∑' (n : ℤ), f.comp (ContinuousMap.addRight (n • p))) (x + p) =
    (∑' (n : ℤ), f.comp (ContinuousMap.addRight (n • p))) x
tactic: intro x
state_before: X : Type u_1
Y : Type u_2
inst✝⁶ : TopologicalSpace X
inst✝⁵ : TopologicalSpace Y
inst✝⁴ : AddCommGroup X
inst✝³ : TopologicalAddGroup X
inst✝² : AddCommMonoid Y
inst✝¹ : ContinuousAdd Y
inst✝ : T2Space Y
f : C(X, Y)
p x : X
⊢ (∑' (n : ℤ), f.comp (ContinuousMap.addRight (n • p))) (x + p) =
    (∑' (n : ℤ), f.comp (ContinuousMap.addRight (n • p))) x
state_after: case pos
X : Type u_1
Y : Type u_2
inst✝⁶ : TopologicalSpace X
inst✝⁵ : TopologicalSpace Y
inst✝⁴ : AddCommGroup X
inst✝³ : TopologicalAddGroup X
inst✝² : AddCommMonoid Y
inst✝¹ : ContinuousAdd Y
inst✝ : T2Space Y
f : C(X, Y)
p x : X
h : Summable fun n => f.comp (ContinuousMap.addRight (n • p))
⊢ (∑' (n : ℤ), f.comp (ContinuousMap.addRight (n • p))) (x + p) =
    (∑' (n : ℤ), f.comp (ContinuousMap.addRight (n • p))) x

case neg
X : Type u_1
Y : Type u_2
inst✝⁶ : TopologicalSpace X
inst✝⁵ : TopologicalSpace Y
inst✝⁴ : AddCommGroup X
inst✝³ : TopologicalAddGroup X
inst✝² : AddCommMonoid Y
inst✝¹ : ContinuousAdd Y
inst✝ : T2Space Y
f : C(X, Y)
p x : X
h : ¬Summable fun n => f.comp (ContinuousMap.addRight (n • p))
⊢ (∑' (n : ℤ), f.comp (ContinuousMap.addRight (n • p))) (x + p) =
    (∑' (n : ℤ), f.comp (ContinuousMap.addRight (n • p))) x
tactic: by_cases h : Summable fun n : ℤ => f.comp (ContinuousMap.addRight (n • p))
Theorem: NNReal.sInf_empty
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: r r₁ r₂ : ℝ≥0
x y : ℝ
⊢ sInf ∅ = 0
state_after: no goals
tactic: rw [← coe_eq_zero, coe_sInf, Set.image_empty, Real.sInf_empty]
Theorem: MeasureTheory.aemeasurable_withDensity_ennreal_iff'
File: Mathlib/MeasureTheory/Measure/WithDensity.lean

Proof steps:
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0
hf : AEMeasurable f μ
g : α → ℝ≥0∞
⊢ AEMeasurable g (μ.withDensity fun x => ↑(f x)) ↔ AEMeasurable (fun x => ↑(f x) * g x) μ
state_after: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0
hf : AEMeasurable f μ
g : α → ℝ≥0∞
t : ∃ f', Measurable f' ∧ f =ᶠ[ae μ] f'
⊢ AEMeasurable g (μ.withDensity fun x => ↑(f x)) ↔ AEMeasurable (fun x => ↑(f x) * g x) μ
tactic: have t : ∃ f', Measurable f' ∧ f =ᵐ[μ] f' := hf
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0
hf : AEMeasurable f μ
g : α → ℝ≥0∞
t : ∃ f', Measurable f' ∧ f =ᶠ[ae μ] f'
⊢ AEMeasurable g (μ.withDensity fun x => ↑(f x)) ↔ AEMeasurable (fun x => ↑(f x) * g x) μ
state_after: case intro.intro
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0
hf : AEMeasurable f μ
g : α → ℝ≥0∞
f' : α → ℝ≥0
hf'_m : Measurable f'
hf'_ae : f =ᶠ[ae μ] f'
⊢ AEMeasurable g (μ.withDensity fun x => ↑(f x)) ↔ AEMeasurable (fun x => ↑(f x) * g x) μ
tactic: rcases t with ⟨f', hf'_m, hf'_ae⟩
state_before: case intro.intro
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0
hf : AEMeasurable f μ
g : α → ℝ≥0∞
f' : α → ℝ≥0
hf'_m : Measurable f'
hf'_ae : f =ᶠ[ae μ] f'
⊢ AEMeasurable g (μ.withDensity fun x => ↑(f x)) ↔ AEMeasurable (fun x => ↑(f x) * g x) μ
state_after: case intro.intro.mp
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0
hf : AEMeasurable f μ
g : α → ℝ≥0∞
f' : α → ℝ≥0
hf'_m : Measurable f'
hf'_ae : f =ᶠ[ae μ] f'
⊢ AEMeasurable g (μ.withDensity fun x => ↑(f x)) → AEMeasurable (fun x => ↑(f x) * g x) μ

case intro.intro.mpr
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0
hf : AEMeasurable f μ
g : α → ℝ≥0∞
f' : α → ℝ≥0
hf'_m : Measurable f'
hf'_ae : f =ᶠ[ae μ] f'
⊢ AEMeasurable (fun x => ↑(f x) * g x) μ → AEMeasurable g (μ.withDensity fun x => ↑(f x))
tactic: constructor
Theorem: Filter.map_sub_atTop_eq_nat
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
k b : ℕ
x✝ : b ≥ 0
⊢ b ≤ (fun a => a + k) b - k
state_after: no goals
tactic: rw [add_tsub_cancel_right]