ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ChartedSpaceCore.open_source'
File: Mathlib/Geometry/Manifold/ChartedSpace.lean

Proof steps:
state_before: H : Type u
H' : Type u_1
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝ : TopologicalSpace H
c : ChartedSpaceCore H M
e : PartialEquiv M H
he : e ∈ c.atlas
⊢ IsOpen e.source
state_after: case a
H : Type u
H' : Type u_1
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝ : TopologicalSpace H
c : ChartedSpaceCore H M
e : PartialEquiv M H
he : e ∈ c.atlas
⊢ e.source ∈ ⋃ e ∈ c.atlas, ⋃ s, ⋃ (_ : IsOpen s), {↑e ⁻¹' s ∩ e.source}
tactic: apply TopologicalSpace.GenerateOpen.basic
state_before: case a
H : Type u
H' : Type u_1
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝ : TopologicalSpace H
c : ChartedSpaceCore H M
e : PartialEquiv M H
he : e ∈ c.atlas
⊢ e.source ∈ ⋃ e ∈ c.atlas, ⋃ s, ⋃ (_ : IsOpen s), {↑e ⁻¹' s ∩ e.source}
state_after: case a
H : Type u
H' : Type u_1
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝ : TopologicalSpace H
c : ChartedSpaceCore H M
e : PartialEquiv M H
he : e ∈ c.atlas
⊢ ∃ i ∈ c.atlas, ∃ i_1, IsOpen i_1 ∧ e.source = ↑i ⁻¹' i_1 ∩ i.source
tactic: simp only [exists_prop, mem_iUnion, mem_singleton_iff]
state_before: case a
H : Type u
H' : Type u_1
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝ : TopologicalSpace H
c : ChartedSpaceCore H M
e : PartialEquiv M H
he : e ∈ c.atlas
⊢ ∃ i ∈ c.atlas, ∃ i_1, IsOpen i_1 ∧ e.source = ↑i ⁻¹' i_1 ∩ i.source
state_after: case a
H : Type u
H' : Type u_1
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝ : TopologicalSpace H
c : ChartedSpaceCore H M
e : PartialEquiv M H
he : e ∈ c.atlas
⊢ e.source = ↑e ⁻¹' univ ∩ e.source
tactic: refine ⟨e, he, univ, isOpen_univ, ?_⟩
state_before: case a
H : Type u
H' : Type u_1
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝ : TopologicalSpace H
c : ChartedSpaceCore H M
e : PartialEquiv M H
he : e ∈ c.atlas
⊢ e.source = ↑e ⁻¹' univ ∩ e.source
state_after: no goals
tactic: simp only [Set.univ_inter, Set.preimage_univ]
Theorem: ProbabilityTheory.centralMoment_two_eq_variance
File: Mathlib/Probability/Moments.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
⊢ centralMoment X 2 μ = variance X μ
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
⊢ centralMoment X 2 μ = ∫ (x : Ω), ((X - fun x => ∫ (x : Ω), X x ∂μ) ^ 2) x ∂μ
tactic: rw [hX.variance_eq]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
hX : Memℒp X 2 μ
⊢ centralMoment X 2 μ = ∫ (x : Ω), ((X - fun x => ∫ (x : Ω), X x ∂μ) ^ 2) x ∂μ
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.OuterMeasure.restrict_mono
File: Mathlib/MeasureTheory/OuterMeasure/Operations.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m✝ : OuterMeasure α
s t : Set α
h : s ⊆ t
m m' : OuterMeasure α
hm : m ≤ m'
u : Set α
⊢ ((restrict s) m) u ≤ ((restrict t) m') u
state_after: α : Type u_1
β : Type u_2
m✝ : OuterMeasure α
s t : Set α
h : s ⊆ t
m m' : OuterMeasure α
hm : m ≤ m'
u : Set α
⊢ m (u ∩ s) ≤ m' (u ∩ t)
tactic: simp only [restrict_apply]
state_before: α : Type u_1
β : Type u_2
m✝ : OuterMeasure α
s t : Set α
h : s ⊆ t
m m' : OuterMeasure α
hm : m ≤ m'
u : Set α
⊢ m (u ∩ s) ≤ m' (u ∩ t)
state_after: no goals
tactic: exact (hm _).trans (m'.mono <| inter_subset_inter_right _ h)
Theorem: Polynomial.separable_prod_X_sub_C_iff
File: Mathlib/FieldTheory/Separable.lean

Proof steps:
state_before: F : Type u
inst✝² : Field F
K : Type v
inst✝¹ : Field K
ι : Type u_1
inst✝ : Fintype ι
f : ι → F
⊢ (∀ x ∈ univ, ∀ y ∈ univ, f x = f y → x = y) ↔ Function.Injective f
state_after: no goals
tactic: simp_rw [mem_univ, true_imp_iff, Function.Injective]
Theorem: Matrix.mul_invOf_mul_self_cancel
File: Mathlib/Data/Matrix/Invertible.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
α : Type u_3
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : Semiring α
A : Matrix m n α
B : Matrix n n α
inst✝ : Invertible B
⊢ A * ⅟B * B = A
state_after: no goals
tactic: rw [Matrix.mul_assoc, invOf_mul_self, Matrix.mul_one]
Theorem: tendstoUniformlyOn_singleton_iff_tendsto
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ TendstoUniformlyOn F f p {x} ↔ Tendsto (fun n => F n x) p (𝓝 (f x))
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ (∀ s ∈ 𝓤 β, (fun q => (f q.2, F q.1 q.2)) ⁻¹' s ∈ p ×ˢ 𝓟 {x}) ↔ ∀ s ∈ 𝓤 β, (fun x_1 => (f x, F x_1 x)) ⁻¹' s ∈ p
tactic: simp_rw [tendstoUniformlyOn_iff_tendsto, Uniform.tendsto_nhds_right, tendsto_def]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
⊢ (∀ s ∈ 𝓤 β, (fun q => (f q.2, F q.1 q.2)) ⁻¹' s ∈ p ×ˢ 𝓟 {x}) ↔ ∀ s ∈ 𝓤 β, (fun x_1 => (f x, F x_1 x)) ⁻¹' s ∈ p
state_after: no goals
tactic: exact forall₂_congr fun u _ => by simp [mem_prod_principal, preimage]
Theorem: Nat.clog_eq_one
File: Mathlib/Data/Nat/Log.lean

Proof steps:
state_before: b n : ℕ
hn : 2 ≤ n
h : n ≤ b
⊢ clog b n = 1
state_after: case hn
b n : ℕ
hn : 2 ≤ n
h : n ≤ b
⊢ (n + b - 1) / b ≤ 1
tactic: rw [clog_of_two_le (hn.trans h) hn, clog_of_right_le_one]
state_before: case hn
b n : ℕ
hn : 2 ≤ n
h : n ≤ b
⊢ (n + b - 1) / b ≤ 1
state_after: no goals
tactic: rw [← Nat.lt_succ_iff, Nat.div_lt_iff_lt_mul] <;> omega
Theorem: Set.Finite.isClosed_biUnion
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s✝ s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
s : Set α
f : α → Set X
hs : s.Finite
h : ∀ i ∈ s, IsClosed (f i)
⊢ IsClosed (⋃ i ∈ s, f i)
state_after: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s✝ s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
s : Set α
f : α → Set X
hs : s.Finite
h : ∀ i ∈ s, IsOpen (f i)ᶜ
⊢ IsOpen (⋂ i ∈ s, (f i)ᶜ)
tactic: simp only [← isOpen_compl_iff, compl_iUnion] at *
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s✝ s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
s : Set α
f : α → Set X
hs : s.Finite
h : ∀ i ∈ s, IsOpen (f i)ᶜ
⊢ IsOpen (⋂ i ∈ s, (f i)ᶜ)
state_after: no goals
tactic: exact hs.isOpen_biInter h
Theorem: PresheafOfModules.limitConeπApp_naturality
File: Mathlib/Algebra/Category/ModuleCat/Presheaf/Limits.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
R : Cᵒᵖ ⥤ RingCat
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
F : J ⥤ PresheafOfModules R
inst✝ : ∀ (X : Cᵒᵖ), Small.{v, max u₂ v} ↑((F ⋙ evaluation R X) ⋙ forget (ModuleCat ↑(R.obj X))).sections
i j : J
f : i ⟶ j
⊢ limitConeπApp F i ≫ F.map f = limitConeπApp F j
state_after: case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
R : Cᵒᵖ ⥤ RingCat
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
F : J ⥤ PresheafOfModules R
inst✝ : ∀ (X : Cᵒᵖ), Small.{v, max u₂ v} ↑((F ⋙ evaluation R X) ⋙ forget (ModuleCat ↑(R.obj X))).sections
i j : J
f : i ⟶ j
X : Cᵒᵖ
⊢ Hom.app (limitConeπApp F i ≫ F.map f) X = Hom.app (limitConeπApp F j) X
tactic: ext1 X
state_before: case w
C : Type u₁
inst✝² : Category.{v₁, u₁} C
R : Cᵒᵖ ⥤ RingCat
J : Type u₂
inst✝¹ : Category.{v₂, u₂} J
F : J ⥤ PresheafOfModules R
inst✝ : ∀ (X : Cᵒᵖ), Small.{v, max u₂ v} ↑((F ⋙ evaluation R X) ⋙ forget (ModuleCat ↑(R.obj X))).sections
i j : J
f : i ⟶ j
X : Cᵒᵖ
⊢ Hom.app (limitConeπApp F i ≫ F.map f) X = Hom.app (limitConeπApp F j) X
state_after: no goals
tactic: exact limit.w (F ⋙ evaluation R X) f
Theorem: noZeroDivisors_iff_isDomain_or_subsingleton
File: Mathlib/Algebra/Ring/Basic.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
inst✝ : Ring α
⊢ NoZeroDivisors α ↔ IsDomain α ∨ Subsingleton α
state_after: no goals
tactic: rw [← isCancelMulZero_iff_noZeroDivisors, isCancelMulZero_iff_isDomain_or_subsingleton]
Theorem: pow_pos
File: Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝³ : Semiring α
inst✝² : PartialOrder α
a b c d : α
inst✝¹ : ZeroLEOneClass α
inst✝ : PosMulStrictMono α
H : 0 < a
⊢ 0 < a ^ 0
state_after: α : Type u
β : Type u_1
inst✝⁴ : Semiring α
inst✝³ : PartialOrder α
a b c d : α
inst✝² : ZeroLEOneClass α
inst✝¹ : PosMulStrictMono α
H : 0 < a
inst✝ : Nontrivial α
⊢ 0 < a ^ 0
tactic: nontriviality
state_before: α : Type u
β : Type u_1
inst✝⁴ : Semiring α
inst✝³ : PartialOrder α
a b c d : α
inst✝² : ZeroLEOneClass α
inst✝¹ : PosMulStrictMono α
H : 0 < a
inst✝ : Nontrivial α
⊢ 0 < a ^ 0
state_after: α : Type u
β : Type u_1
inst✝⁴ : Semiring α
inst✝³ : PartialOrder α
a b c d : α
inst✝² : ZeroLEOneClass α
inst✝¹ : PosMulStrictMono α
H : 0 < a
inst✝ : Nontrivial α
⊢ 0 < 1
tactic: rw [pow_zero]
state_before: α : Type u
β : Type u_1
inst✝⁴ : Semiring α
inst✝³ : PartialOrder α
a b c d : α
inst✝² : ZeroLEOneClass α
inst✝¹ : PosMulStrictMono α
H : 0 < a
inst✝ : Nontrivial α
⊢ 0 < 1
state_after: no goals
tactic: exact zero_lt_one
state_before: α : Type u
β : Type u_1
inst✝³ : Semiring α
inst✝² : PartialOrder α
a b c d : α
inst✝¹ : ZeroLEOneClass α
inst✝ : PosMulStrictMono α
H : 0 < a
n : ℕ
⊢ 0 < a ^ (n + 1)
state_after: α : Type u
β : Type u_1
inst✝³ : Semiring α
inst✝² : PartialOrder α
a b c d : α
inst✝¹ : ZeroLEOneClass α
inst✝ : PosMulStrictMono α
H : 0 < a
n : ℕ
⊢ 0 < a ^ n * a
tactic: rw [pow_succ]
state_before: α : Type u
β : Type u_1
inst✝³ : Semiring α
inst✝² : PartialOrder α
a b c d : α
inst✝¹ : ZeroLEOneClass α
inst✝ : PosMulStrictMono α
H : 0 < a
n : ℕ
⊢ 0 < a ^ n * a
state_after: no goals
tactic: exact mul_pos (pow_pos H _) H
Theorem: Finset.zero_mem_smul_finset_iff
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁴ : Zero β
inst✝³ : SMulZeroClass α β
inst✝² : DecidableEq β
s : Finset α
t : Finset β
a : α
inst✝¹ : Zero α
inst✝ : NoZeroSMulDivisors α β
ha : a ≠ 0
⊢ 0 ∈ a • t ↔ 0 ∈ t
state_after: no goals
tactic: rw [← mem_coe, coe_smul_finset, Set.zero_mem_smul_set_iff ha, mem_coe]
Theorem: Multiset.eq_union_right
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s t u : Multiset α
a b : α
h : s ≤ t
⊢ s ∪ t = t
state_after: no goals
tactic: rw [union_comm, eq_union_left h]
Theorem: Mathlib.Meta.NormNum.isintCast
File: Mathlib/Tactic/NormNum/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Ring R
n m : ℤ
⊢ IsInt n m → IsInt (↑n) m
state_after: case mk.refl
R : Type u_1
inst✝ : Ring R
m : ℤ
⊢ IsInt (↑↑m) m
tactic: rintro ⟨⟨⟩⟩
state_before: case mk.refl
R : Type u_1
inst✝ : Ring R
m : ℤ
⊢ IsInt (↑↑m) m
state_after: no goals
tactic: exact ⟨rfl⟩
Theorem: eq_iff_eq_cancel_left
File: Mathlib/Logic/Basic.lean

Proof steps:
state_before: α : Sort u_1
b c : α
h : ∀ {a : α}, a = b ↔ a = c
⊢ b = c
state_after: no goals
tactic: rw [← h]
state_before: α : Sort u_1
b c : α
h : b = c
a : α
⊢ a = b ↔ a = c
state_after: no goals
tactic: rw [h]
Theorem: LieSubmodule.eq_bot_iff
File: Mathlib/Algebra/Lie/Submodule.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
⊢ N = ⊥ ↔ ∀ m ∈ N, m = 0
state_after: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
⊢ N ≤ ⊥ ↔ ∀ m ∈ N, m = 0
tactic: rw [eq_bot_iff]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
⊢ N ≤ ⊥ ↔ ∀ m ∈ N, m = 0
state_after: no goals
tactic: exact Iff.rfl
Theorem: CategoryTheory.Limits.Cotrident.condition
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)
j₁ j₂ : J
t : Cotrident f
⊢ f j₁ ≫ t.π = f j₂ ≫ t.π
state_after: no goals
tactic: rw [t.app_one, t.app_one]
Theorem: Submodule.FG.prod
File: Mathlib/RingTheory/Finiteness.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
P : Type u_3
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
f : M →ₗ[R] P
sb : Submodule R M
sc : Submodule R P
hsb : sb.FG
hsc : sc.FG
tb : Set M
htb : tb.Finite ∧ span R tb = sb
tc : Set P
htc : tc.Finite ∧ span R tc = sc
⊢ span R (⇑(LinearMap.inl R M P) '' tb ∪ ⇑(LinearMap.inr R M P) '' tc) = sb.prod sc
state_after: no goals
tactic: rw [LinearMap.span_inl_union_inr, htb.2, htc.2]
Theorem: ForInStep.bindList_cons'
File: .lake/packages/batteries/Batteries/Control/ForInStep/Lemmas.lean

Proof steps:
state_before: m : Type u_1 → Type u_2
α : Type u_3
β : Type u_1
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : α → β → m (ForInStep β)
s : ForInStep β
a : α
l : List α
⊢ bindList f (a :: l) s = do
    let x ← s.bind (f a)
    bindList f l x
state_after: no goals
tactic: simp
Theorem: AddSubgroup.closure_neg
File: Mathlib/Algebra/Group/Subgroup/Pointwise.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
A : Type u_3
S : Type u_4
inst✝¹ : Group G
inst✝ : AddGroup A
s✝ s : Set G
⊢ closure s⁻¹ = closure s
state_after: no goals
tactic: simp only [← toSubmonoid_eq, closure_toSubmonoid, inv_inv, union_comm]
Theorem: ENorm.map_sub_le
File: Mathlib/Analysis/NormedSpace/ENorm.lean

Proof steps:
state_before: 𝕜 : Type u_1
V : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup V
inst✝ : Module 𝕜 V
e : ENorm 𝕜 V
x y : V
⊢ ↑e (x - y) = ↑e (x + -y)
state_after: no goals
tactic: rw [sub_eq_add_neg]
state_before: 𝕜 : Type u_1
V : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup V
inst✝ : Module 𝕜 V
e : ENorm 𝕜 V
x y : V
⊢ ↑e x + ↑e (-y) = ↑e x + ↑e y
state_after: no goals
tactic: rw [e.map_neg]
Theorem: Polynomial.separable_C
File: Mathlib/FieldTheory/Separable.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
r : R
⊢ (C r).Separable ↔ IsUnit r
state_after: no goals
tactic: rw [separable_def, derivative_C, isCoprime_zero_right, isUnit_C]
Theorem: Subgroup.sup_eq_closure
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
H✝ K : Subgroup G
k : Set G
H H' : Subgroup G
⊢ H ⊔ H' = closure (↑H ∪ ↑H')
state_after: no goals
tactic: simp_rw [closure_union, closure_eq]
Theorem: CategoryTheory.Limits.opProductIsoCoproduct'_inv_comp_lift
File: Mathlib/CategoryTheory/Limits/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
f : Fan Z
c : Cofan fun x => op (Z x)
hf : IsLimit f
hc : IsColimit c
f' : Fan Z
⊢ (opProductIsoCoproduct' hf hc).inv ≫ (hf.lift f').op = hc.desc f'.op
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
f : Fan Z
c : Cofan fun x => op (Z x)
hf : IsLimit f
hc : IsColimit c
f' : Fan Z
x✝ : Discrete α
j : α
⊢ ((hf.lift f').op.unop ≫ f.π.app { as := j }).op =
    (((opProductIsoCoproduct' hf hc).hom ≫ hc.desc f'.op).unop ≫ f.π.app { as := j }).op
tactic: refine (Iso.inv_comp_eq _).mpr (Quiver.Hom.unop_inj (hf.hom_ext (fun ⟨j⟩ ↦ Quiver.Hom.op_inj ?_)))
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
f : Fan Z
c : Cofan fun x => op (Z x)
hf : IsLimit f
hc : IsColimit c
f' : Fan Z
x✝ : Discrete α
j : α
⊢ ((hf.lift f').op.unop ≫ f.π.app { as := j }).op =
    (((opProductIsoCoproduct' hf hc).hom ≫ hc.desc f'.op).unop ≫ f.π.app { as := j }).op
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
f : Fan Z
c : Cofan fun x => op (Z x)
hf : IsLimit f
hc : IsColimit c
f' : Fan Z
x✝ : Discrete α
j : α
⊢ (f'.π.app { as := j }).op =
    (f.π.app { as := j }).op ≫
      (opProductIsoCoproduct' hf hc).hom ≫ hc.desc (Cofan.mk (op f'.pt) fun a => (f'.proj a).op)
tactic: simp only [Discrete.functor_obj, unop_op, Quiver.Hom.unop_op, IsLimit.fac, Fan.op, unop_comp,
    Category.assoc, op_comp, op_unop, Quiver.Hom.op_unop]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
f : Fan Z
c : Cofan fun x => op (Z x)
hf : IsLimit f
hc : IsColimit c
f' : Fan Z
x✝ : Discrete α
j : α
⊢ (f'.π.app { as := j }).op =
    (f.π.app { as := j }).op ≫
      (opProductIsoCoproduct' hf hc).hom ≫ hc.desc (Cofan.mk (op f'.pt) fun a => (f'.proj a).op)
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
f : Fan Z
c : Cofan fun x => op (Z x)
hf : IsLimit f
hc : IsColimit c
f' : Fan Z
x✝ : Discrete α
j : α
⊢ (f'.π.app { as := j }).op = (Cofan.mk (op f'.pt) fun a => (f'.proj a).op).ι.app { as := j }
tactic: erw [← Category.assoc, proj_comp_opProductIsoCoproduct'_hom, IsColimit.fac]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X : Type v₂
α : Type u_1
Z : α → C
f : Fan Z
c : Cofan fun x => op (Z x)
hf : IsLimit f
hc : IsColimit c
f' : Fan Z
x✝ : Discrete α
j : α
⊢ (f'.π.app { as := j }).op = (Cofan.mk (op f'.pt) fun a => (f'.proj a).op).ι.app { as := j }
state_after: no goals
tactic: rfl
Theorem: Multiset.card_disjSum
File: Mathlib/Data/Multiset/Sum.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s : Multiset α
t : Multiset β
⊢ card (s.disjSum t) = card s + card t
state_after: no goals
tactic: rw [disjSum, card_add, card_map, card_map]
Theorem: CategoryTheory.GradedObject.Monoidal.ιTensorObj₃'_eq
File: Mathlib/CategoryTheory/GradedObject/Monoidal.lean

Proof steps:
state_before: I : Type u
inst✝¹⁰ : AddMonoid I
C : Type u_1
inst✝⁹ : Category.{?u.61493, u_1} C
inst✝⁸ : MonoidalCategory C
Z : C
X₁ X₂ X₃ : GradedObject I C
inst✝⁷ : X₁.HasTensor X₂
inst✝⁶ : X₂.HasTensor X₃
inst✝⁵ : (tensorObj X₁ X₂).HasTensor X₃
inst✝⁴ : X₁.HasTensor (tensorObj X₂ X₃)
Y₁ Y₂ Y₃ : GradedObject I C
inst✝³ : Y₁.HasTensor Y₂
inst✝² : Y₂.HasTensor Y₃
inst✝¹ : (tensorObj Y₁ Y₂).HasTensor Y₃
inst✝ : Y₁.HasTensor (tensorObj Y₂ Y₃)
i₁ i₂ i₃ j : I
h : i₁ + i₂ + i₃ = j
i₁₂ : I
h' : i₁ + i₂ = i₁₂
⊢ i₁₂ + i₃ = j
state_after: no goals
tactic: rw [← h', h]
state_before: I : Type u
inst✝¹⁰ : AddMonoid I
C : Type u_1
inst✝⁹ : Category.{u_2, u_1} C
inst✝⁸ : MonoidalCategory C
Z : C
X₁ X₂ X₃ : GradedObject I C
inst✝⁷ : X₁.HasTensor X₂
inst✝⁶ : X₂.HasTensor X₃
inst✝⁵ : (tensorObj X₁ X₂).HasTensor X₃
inst✝⁴ : X₁.HasTensor (tensorObj X₂ X₃)
Y₁ Y₂ Y₃ : GradedObject I C
inst✝³ : Y₁.HasTensor Y₂
inst✝² : Y₂.HasTensor Y₃
inst✝¹ : (tensorObj Y₁ Y₂).HasTensor Y₃
inst✝ : Y₁.HasTensor (tensorObj Y₂ Y₃)
i₁ i₂ i₃ j : I
h : i₁ + i₂ + i₃ = j
i₁₂ : I
h' : i₁ + i₂ = i₁₂
⊢ ιTensorObj₃' X₁ X₂ X₃ i₁ i₂ i₃ j h =
    ιTensorObj X₁ X₂ i₁ i₂ i₁₂ h' ▷ X₃ i₃ ≫ ιTensorObj (tensorObj X₁ X₂) X₃ i₁₂ i₃ j ⋯
state_after: I : Type u
inst✝¹⁰ : AddMonoid I
C : Type u_1
inst✝⁹ : Category.{u_2, u_1} C
inst✝⁸ : MonoidalCategory C
Z : C
X₁ X₂ X₃ : GradedObject I C
inst✝⁷ : X₁.HasTensor X₂
inst✝⁶ : X₂.HasTensor X₃
inst✝⁵ : (tensorObj X₁ X₂).HasTensor X₃
inst✝⁴ : X₁.HasTensor (tensorObj X₂ X₃)
Y₁ Y₂ Y₃ : GradedObject I C
inst✝³ : Y₁.HasTensor Y₂
inst✝² : Y₂.HasTensor Y₃
inst✝¹ : (tensorObj Y₁ Y₂).HasTensor Y₃
inst✝ : Y₁.HasTensor (tensorObj Y₂ Y₃)
i₁ i₂ i₃ j : I
h : i₁ + i₂ + i₃ = j
⊢ ιTensorObj₃' X₁ X₂ X₃ i₁ i₂ i₃ j h =
    ιTensorObj X₁ X₂ i₁ i₂ (i₁ + i₂) ⋯ ▷ X₃ i₃ ≫ ιTensorObj (tensorObj X₁ X₂) X₃ (i₁ + i₂) i₃ j ⋯
tactic: subst h'
state_before: I : Type u
inst✝¹⁰ : AddMonoid I
C : Type u_1
inst✝⁹ : Category.{u_2, u_1} C
inst✝⁸ : MonoidalCategory C
Z : C
X₁ X₂ X₃ : GradedObject I C
inst✝⁷ : X₁.HasTensor X₂
inst✝⁶ : X₂.HasTensor X₃
inst✝⁵ : (tensorObj X₁ X₂).HasTensor X₃
inst✝⁴ : X₁.HasTensor (tensorObj X₂ X₃)
Y₁ Y₂ Y₃ : GradedObject I C
inst✝³ : Y₁.HasTensor Y₂
inst✝² : Y₂.HasTensor Y₃
inst✝¹ : (tensorObj Y₁ Y₂).HasTensor Y₃
inst✝ : Y₁.HasTensor (tensorObj Y₂ Y₃)
i₁ i₂ i₃ j : I
h : i₁ + i₂ + i₃ = j
⊢ ιTensorObj₃' X₁ X₂ X₃ i₁ i₂ i₃ j h =
    ιTensorObj X₁ X₂ i₁ i₂ (i₁ + i₂) ⋯ ▷ X₃ i₃ ≫ ιTensorObj (tensorObj X₁ X₂) X₃ (i₁ + i₂) i₃ j ⋯
state_after: no goals
tactic: rfl
Theorem: Finset.hasSum
File: Mathlib/Topology/Algebra/InfiniteSum/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a b : α
s✝ s : Finset β
f : β → α
⊢ HasProd (f ∘ Subtype.val) (∏ b ∈ s, f b)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a b : α
s✝ s : Finset β
f : β → α
⊢ HasProd (f ∘ Subtype.val) (∏ x ∈ s.attach, f ↑x)
tactic: rw [← prod_attach]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : CommMonoid α
inst✝ : TopologicalSpace α
f✝ g : β → α
a b : α
s✝ s : Finset β
f : β → α
⊢ HasProd (f ∘ Subtype.val) (∏ x ∈ s.attach, f ↑x)
state_after: no goals
tactic: exact hasProd_fintype _
Theorem: Fin.isCycle_cycleRange
File: Mathlib/GroupTheory/Perm/Fin.lean

Proof steps:
state_before: n : ℕ
i : Fin (n + 1)
h0 : i ≠ 0
⊢ i.cycleRange.IsCycle
state_after: case mk
n i : ℕ
hi : i < n + 1
h0 : ⟨i, hi⟩ ≠ 0
⊢ ⟨i, hi⟩.cycleRange.IsCycle
tactic: cases' i with i hi
state_before: case mk
n i : ℕ
hi : i < n + 1
h0 : ⟨i, hi⟩ ≠ 0
⊢ ⟨i, hi⟩.cycleRange.IsCycle
state_after: case mk.zero
n : ℕ
hi : 0 < n + 1
h0 : ⟨0, hi⟩ ≠ 0
⊢ ⟨0, hi⟩.cycleRange.IsCycle

case mk.succ
n n✝ : ℕ
hi : n✝ + 1 < n + 1
h0 : ⟨n✝ + 1, hi⟩ ≠ 0
⊢ ⟨n✝ + 1, hi⟩.cycleRange.IsCycle
tactic: cases i
state_before: case mk.succ
n n✝ : ℕ
hi : n✝ + 1 < n + 1
h0 : ⟨n✝ + 1, hi⟩ ≠ 0
⊢ ⟨n✝ + 1, hi⟩.cycleRange.IsCycle
state_after: no goals
tactic: exact isCycle_finRotate.extendDomain _
Theorem: Nat.floor_one
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a : α
n : ℕ
⊢ ⌊1⌋₊ = 1
state_after: no goals
tactic: rw [← Nat.cast_one, floor_natCast]
Theorem: CategoryTheory.Limits.Types.zigzag_of_eqvGen_quot_rel
File: Mathlib/CategoryTheory/Limits/IsConnected.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F : C ⥤ Type w
c d : (j : C) × F.obj j
h : EqvGen (Quot.Rel F) c d
⊢ Zigzag c.fst d.fst
state_after: no goals
tactic: induction h with
  | rel _ _ h => exact Zigzag.of_hom <| Exists.choose h
  | refl _ => exact Zigzag.refl _
  | symm _ _ _ ih => exact zigzag_symmetric ih
  | trans _ _ _ _ _ ih₁ ih₂ => exact ih₁.trans ih₂